426 lines
17 KiB
C#
426 lines
17 KiB
C#
|
#region PDFsharp - A .NET library for processing PDF
|
||
|
|
//
|
||
|
|
// Authors:
|
||
|
|
// Stefan Lange
|
||
|
|
//
|
||
|
|
// Copyright (c) 2005-2017 empira Software GmbH, Cologne Area (Germany)
|
||
|
|
//
|
||
|
|
// http://www.pdfsharp.com
|
||
|
|
// http://sourceforge.net/projects/pdfsharp
|
||
|
|
//
|
||
|
|
// Permission is hereby granted, free of charge, to any person obtaining a
|
||
|
|
// copy of this software and associated documentation files (the "Software"),
|
||
|
|
// to deal in the Software without restriction, including without limitation
|
||
|
|
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
||
|
|
// and/or sell copies of the Software, and to permit persons to whom the
|
||
|
|
// Software is furnished to do so, subject to the following conditions:
|
||
|
|
//
|
||
|
|
// The above copyright notice and this permission notice shall be included
|
||
|
|
// in all copies or substantial portions of the Software.
|
||
|
|
//
|
||
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
||
|
|
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||
|
|
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
||
|
|
// DEALINGS IN THE SOFTWARE.
|
||
|
|
#endregion
|
||
|
|
|
||
|
|
// Based on code from here:
|
||
|
|
// http://archive.msdn.microsoft.com/SilverlightMD5/Release/ProjectReleases.aspx?ReleaseId=2206
|
||
|
|
//
|
||
|
|
// **************************************************************
|
||
|
|
// * Raw implementation of the MD5 hash algorithm
|
||
|
|
// * from RFC 1321.
|
||
|
|
// *
|
||
|
|
// * Written By: Reid Borsuk and Jenny Zheng
|
||
|
|
// * Copyright (c) Microsoft Corporation. All rights reserved.
|
||
|
|
// **************************************************************
|
||
|
|
|
||
|
|
using System;
|
||
|
|
using System.Diagnostics;
|
||
|
|
#if !NETFX_CORE && !UWP
|
||
|
|
using System.Security.Cryptography;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
// ReSharper disable InconsistentNaming
|
||
|
|
|
||
|
|
#if SILVERLIGHT || WINDOWS_PHONE || UWP || (GDI && DEBUG)
|
||
|
|
namespace PdfSharp.Pdf.Security
|
||
|
|
{
|
||
|
|
#if UWP
|
||
|
|
class HashAlgorithm
|
||
|
|
{
|
||
|
|
public int HashSizeValue { get; set; }
|
||
|
|
|
||
|
|
public virtual void Initialize()
|
||
|
|
{ }
|
||
|
|
|
||
|
|
protected virtual void HashCore(byte[] array, int ibStart, int cbSize)
|
||
|
|
{ }
|
||
|
|
|
||
|
|
protected virtual byte[] HashFinal()
|
||
|
|
{
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
|
||
|
|
public byte[] HashValue { get; set; }
|
||
|
|
|
||
|
|
public void TransformBlock(byte[] a, int b, int c, byte[] d, int e)
|
||
|
|
{ }
|
||
|
|
|
||
|
|
public void TransformFinalBlock(byte[] a, int b, int c)
|
||
|
|
{ }
|
||
|
|
|
||
|
|
public byte[] ComputeHash(byte[] a)
|
||
|
|
{
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
|
||
|
|
public byte[] Hash
|
||
|
|
{
|
||
|
|
get { return null; }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
/// <summary>
|
||
|
|
/// A managed implementation of the MD5 algorithm.
|
||
|
|
/// Necessary because MD5 is not part of the framework in Silverlight and WP.
|
||
|
|
/// </summary>
|
||
|
|
class MD5Managed
|
||
|
|
//#if !UWP
|
||
|
|
: HashAlgorithm // TODO: WinRT has not even a HashAlgorithm base class.
|
||
|
|
//#endif
|
||
|
|
{
|
||
|
|
// Intitial values as defined in RFC 1321.
|
||
|
|
const uint A = 0x67452301;
|
||
|
|
const uint B = 0xefcdab89;
|
||
|
|
const uint C = 0x98badcfe;
|
||
|
|
const uint D = 0x10325476;
|
||
|
|
|
||
|
|
public MD5Managed()
|
||
|
|
{
|
||
|
|
HashSizeValue = 128;
|
||
|
|
Initialize();
|
||
|
|
}
|
||
|
|
|
||
|
|
public sealed override void Initialize()
|
||
|
|
{
|
||
|
|
_data = new byte[64];
|
||
|
|
_dataSize = 0;
|
||
|
|
_totalLength = 0;
|
||
|
|
_abcd = new MD5Core.ABCDStruct();
|
||
|
|
|
||
|
|
// Intitial values as defined in RFC 1321.
|
||
|
|
_abcd.A = A;
|
||
|
|
_abcd.B = B;
|
||
|
|
_abcd.C = C;
|
||
|
|
_abcd.D = D;
|
||
|
|
}
|
||
|
|
|
||
|
|
protected override void HashCore(byte[] array, int ibStart, int cbSize)
|
||
|
|
{
|
||
|
|
int startIndex = ibStart;
|
||
|
|
int totalArrayLength = _dataSize + cbSize;
|
||
|
|
if (totalArrayLength >= 64)
|
||
|
|
{
|
||
|
|
Array.Copy(array, startIndex, _data, _dataSize, 64 - _dataSize);
|
||
|
|
// Process message of 64 bytes (512 bits)
|
||
|
|
MD5Core.GetHashBlock(_data, ref _abcd, 0);
|
||
|
|
startIndex += 64 - _dataSize;
|
||
|
|
totalArrayLength -= 64;
|
||
|
|
while (totalArrayLength >= 64)
|
||
|
|
{
|
||
|
|
Array.Copy(array, startIndex, _data, 0, 64);
|
||
|
|
MD5Core.GetHashBlock(array, ref _abcd, startIndex);
|
||
|
|
totalArrayLength -= 64;
|
||
|
|
startIndex += 64;
|
||
|
|
}
|
||
|
|
_dataSize = totalArrayLength;
|
||
|
|
Array.Copy(array, startIndex, _data, 0, totalArrayLength);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
Array.Copy(array, startIndex, _data, _dataSize, cbSize);
|
||
|
|
_dataSize = totalArrayLength;
|
||
|
|
}
|
||
|
|
_totalLength += cbSize;
|
||
|
|
}
|
||
|
|
|
||
|
|
protected override byte[] HashFinal()
|
||
|
|
{
|
||
|
|
HashValue = MD5Core.GetHashFinalBlock(_data, 0, _dataSize, _abcd, _totalLength * 8);
|
||
|
|
return HashValue;
|
||
|
|
}
|
||
|
|
|
||
|
|
byte[] _data;
|
||
|
|
MD5Core.ABCDStruct _abcd;
|
||
|
|
Int64 _totalLength;
|
||
|
|
int _dataSize;
|
||
|
|
|
||
|
|
static class MD5Core
|
||
|
|
{
|
||
|
|
#if true
|
||
|
|
public static byte[] GetHash(byte[] input)
|
||
|
|
{
|
||
|
|
if (null == input)
|
||
|
|
throw new ArgumentNullException("input");
|
||
|
|
|
||
|
|
// Intitial values defined in RFC 1321.
|
||
|
|
ABCDStruct abcd = new ABCDStruct();
|
||
|
|
abcd.A = A;
|
||
|
|
abcd.B = B;
|
||
|
|
abcd.C = C;
|
||
|
|
abcd.D = D;
|
||
|
|
|
||
|
|
// We pass in the input array by block, the final block of data must be handled specially for padding & length embeding.
|
||
|
|
int startIndex = 0;
|
||
|
|
while (startIndex <= input.Length - 64)
|
||
|
|
{
|
||
|
|
GetHashBlock(input, ref abcd, startIndex);
|
||
|
|
startIndex += 64;
|
||
|
|
}
|
||
|
|
// The final data block.
|
||
|
|
return GetHashFinalBlock(input, startIndex, input.Length - startIndex, abcd, (Int64)input.Length * 8);
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
internal static byte[] GetHashFinalBlock(byte[] input, int ibStart, int cbSize, ABCDStruct abcd, Int64 len)
|
||
|
|
{
|
||
|
|
byte[] working = new byte[64];
|
||
|
|
byte[] length = BitConverter.GetBytes(len);
|
||
|
|
|
||
|
|
// Padding is a single bit 1, followed by the number of 0s required to make size congruent to 448 modulo 512. Step 1 of RFC 1321
|
||
|
|
// The CLR ensures that our buffer is 0-assigned, we don't need to explicitly set it. This is why it ends up being quicker to just
|
||
|
|
// use a temporary array rather then doing in-place assignment (5% for small inputs)
|
||
|
|
Array.Copy(input, ibStart, working, 0, cbSize);
|
||
|
|
working[cbSize] = 0x80;
|
||
|
|
|
||
|
|
// We have enough room to store the length in this chunk.
|
||
|
|
if (cbSize <= 56)
|
||
|
|
{
|
||
|
|
Array.Copy(length, 0, working, 56, 8);
|
||
|
|
GetHashBlock(working, ref abcd, 0);
|
||
|
|
}
|
||
|
|
else // We need an aditional chunk to store the length.
|
||
|
|
{
|
||
|
|
GetHashBlock(working, ref abcd, 0);
|
||
|
|
// Create an entirely new chunk due to the 0-assigned trick mentioned above, to avoid an extra function call clearing the array.
|
||
|
|
working = new byte[64];
|
||
|
|
Array.Copy(length, 0, working, 56, 8);
|
||
|
|
GetHashBlock(working, ref abcd, 0);
|
||
|
|
}
|
||
|
|
byte[] output = new byte[16];
|
||
|
|
Array.Copy(BitConverter.GetBytes(abcd.A), 0, output, 0, 4);
|
||
|
|
Array.Copy(BitConverter.GetBytes(abcd.B), 0, output, 4, 4);
|
||
|
|
Array.Copy(BitConverter.GetBytes(abcd.C), 0, output, 8, 4);
|
||
|
|
Array.Copy(BitConverter.GetBytes(abcd.D), 0, output, 12, 4);
|
||
|
|
return output;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal static void GetHashBlock(byte[] input, ref ABCDStruct ABCDValue, int ibStart)
|
||
|
|
{
|
||
|
|
uint[] temp = Converter(input, ibStart);
|
||
|
|
uint a = ABCDValue.A;
|
||
|
|
uint b = ABCDValue.B;
|
||
|
|
uint c = ABCDValue.C;
|
||
|
|
uint d = ABCDValue.D;
|
||
|
|
|
||
|
|
a = r1(a, b, c, d, temp[0], 7, 0xd76aa478);
|
||
|
|
d = r1(d, a, b, c, temp[1], 12, 0xe8c7b756);
|
||
|
|
c = r1(c, d, a, b, temp[2], 17, 0x242070db);
|
||
|
|
b = r1(b, c, d, a, temp[3], 22, 0xc1bdceee);
|
||
|
|
a = r1(a, b, c, d, temp[4], 7, 0xf57c0faf);
|
||
|
|
d = r1(d, a, b, c, temp[5], 12, 0x4787c62a);
|
||
|
|
c = r1(c, d, a, b, temp[6], 17, 0xa8304613);
|
||
|
|
b = r1(b, c, d, a, temp[7], 22, 0xfd469501);
|
||
|
|
a = r1(a, b, c, d, temp[8], 7, 0x698098d8);
|
||
|
|
d = r1(d, a, b, c, temp[9], 12, 0x8b44f7af);
|
||
|
|
c = r1(c, d, a, b, temp[10], 17, 0xffff5bb1);
|
||
|
|
b = r1(b, c, d, a, temp[11], 22, 0x895cd7be);
|
||
|
|
a = r1(a, b, c, d, temp[12], 7, 0x6b901122);
|
||
|
|
d = r1(d, a, b, c, temp[13], 12, 0xfd987193);
|
||
|
|
c = r1(c, d, a, b, temp[14], 17, 0xa679438e);
|
||
|
|
b = r1(b, c, d, a, temp[15], 22, 0x49b40821);
|
||
|
|
|
||
|
|
a = r2(a, b, c, d, temp[1], 5, 0xf61e2562);
|
||
|
|
d = r2(d, a, b, c, temp[6], 9, 0xc040b340);
|
||
|
|
c = r2(c, d, a, b, temp[11], 14, 0x265e5a51);
|
||
|
|
b = r2(b, c, d, a, temp[0], 20, 0xe9b6c7aa);
|
||
|
|
a = r2(a, b, c, d, temp[5], 5, 0xd62f105d);
|
||
|
|
d = r2(d, a, b, c, temp[10], 9, 0x02441453);
|
||
|
|
c = r2(c, d, a, b, temp[15], 14, 0xd8a1e681);
|
||
|
|
b = r2(b, c, d, a, temp[4], 20, 0xe7d3fbc8);
|
||
|
|
a = r2(a, b, c, d, temp[9], 5, 0x21e1cde6);
|
||
|
|
d = r2(d, a, b, c, temp[14], 9, 0xc33707d6);
|
||
|
|
c = r2(c, d, a, b, temp[3], 14, 0xf4d50d87);
|
||
|
|
b = r2(b, c, d, a, temp[8], 20, 0x455a14ed);
|
||
|
|
a = r2(a, b, c, d, temp[13], 5, 0xa9e3e905);
|
||
|
|
d = r2(d, a, b, c, temp[2], 9, 0xfcefa3f8);
|
||
|
|
c = r2(c, d, a, b, temp[7], 14, 0x676f02d9);
|
||
|
|
b = r2(b, c, d, a, temp[12], 20, 0x8d2a4c8a);
|
||
|
|
|
||
|
|
a = r3(a, b, c, d, temp[5], 4, 0xfffa3942);
|
||
|
|
d = r3(d, a, b, c, temp[8], 11, 0x8771f681);
|
||
|
|
c = r3(c, d, a, b, temp[11], 16, 0x6d9d6122);
|
||
|
|
b = r3(b, c, d, a, temp[14], 23, 0xfde5380c);
|
||
|
|
a = r3(a, b, c, d, temp[1], 4, 0xa4beea44);
|
||
|
|
d = r3(d, a, b, c, temp[4], 11, 0x4bdecfa9);
|
||
|
|
c = r3(c, d, a, b, temp[7], 16, 0xf6bb4b60);
|
||
|
|
b = r3(b, c, d, a, temp[10], 23, 0xbebfbc70);
|
||
|
|
a = r3(a, b, c, d, temp[13], 4, 0x289b7ec6);
|
||
|
|
d = r3(d, a, b, c, temp[0], 11, 0xeaa127fa);
|
||
|
|
c = r3(c, d, a, b, temp[3], 16, 0xd4ef3085);
|
||
|
|
b = r3(b, c, d, a, temp[6], 23, 0x04881d05);
|
||
|
|
a = r3(a, b, c, d, temp[9], 4, 0xd9d4d039);
|
||
|
|
d = r3(d, a, b, c, temp[12], 11, 0xe6db99e5);
|
||
|
|
c = r3(c, d, a, b, temp[15], 16, 0x1fa27cf8);
|
||
|
|
b = r3(b, c, d, a, temp[2], 23, 0xc4ac5665);
|
||
|
|
|
||
|
|
a = r4(a, b, c, d, temp[0], 6, 0xf4292244);
|
||
|
|
d = r4(d, a, b, c, temp[7], 10, 0x432aff97);
|
||
|
|
c = r4(c, d, a, b, temp[14], 15, 0xab9423a7);
|
||
|
|
b = r4(b, c, d, a, temp[5], 21, 0xfc93a039);
|
||
|
|
a = r4(a, b, c, d, temp[12], 6, 0x655b59c3);
|
||
|
|
d = r4(d, a, b, c, temp[3], 10, 0x8f0ccc92);
|
||
|
|
c = r4(c, d, a, b, temp[10], 15, 0xffeff47d);
|
||
|
|
b = r4(b, c, d, a, temp[1], 21, 0x85845dd1);
|
||
|
|
a = r4(a, b, c, d, temp[8], 6, 0x6fa87e4f);
|
||
|
|
d = r4(d, a, b, c, temp[15], 10, 0xfe2ce6e0);
|
||
|
|
c = r4(c, d, a, b, temp[6], 15, 0xa3014314);
|
||
|
|
b = r4(b, c, d, a, temp[13], 21, 0x4e0811a1);
|
||
|
|
a = r4(a, b, c, d, temp[4], 6, 0xf7537e82);
|
||
|
|
d = r4(d, a, b, c, temp[11], 10, 0xbd3af235);
|
||
|
|
c = r4(c, d, a, b, temp[2], 15, 0x2ad7d2bb);
|
||
|
|
b = r4(b, c, d, a, temp[9], 21, 0xeb86d391);
|
||
|
|
|
||
|
|
ABCDValue.A = unchecked(a + ABCDValue.A);
|
||
|
|
ABCDValue.B = unchecked(b + ABCDValue.B);
|
||
|
|
ABCDValue.C = unchecked(c + ABCDValue.C);
|
||
|
|
ABCDValue.D = unchecked(d + ABCDValue.D);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Manually unrolling these equations nets us a 20% performance improvement
|
||
|
|
private static uint r1(uint a, uint b, uint c, uint d, uint x, int s, uint t)
|
||
|
|
{
|
||
|
|
// (b + LSR((a + F(b, c, d) + x + t), s))
|
||
|
|
// F(x, y, z) ((x & y) | ((x ^ 0xFFFFFFFF) & z))
|
||
|
|
return unchecked(b + LSR((a + ((b & c) | ((b ^ 0xFFFFFFFF) & d)) + x + t), s));
|
||
|
|
}
|
||
|
|
|
||
|
|
private static uint r2(uint a, uint b, uint c, uint d, uint x, int s, uint t)
|
||
|
|
{
|
||
|
|
// (b + LSR((a + G(b, c, d) + x + t), s))
|
||
|
|
// G(x, y, z) ((x & z) | (y & (z ^ 0xFFFFFFFF)))
|
||
|
|
return unchecked(b + LSR((a + ((b & d) | (c & (d ^ 0xFFFFFFFF))) + x + t), s));
|
||
|
|
}
|
||
|
|
|
||
|
|
private static uint r3(uint a, uint b, uint c, uint d, uint x, int s, uint t)
|
||
|
|
{
|
||
|
|
// (b + LSR((a + H(b, c, d) + k + i), s))
|
||
|
|
// H(x, y, z) (x ^ y ^ z)
|
||
|
|
return unchecked(b + LSR((a + (b ^ c ^ d) + x + t), s));
|
||
|
|
}
|
||
|
|
|
||
|
|
private static uint r4(uint a, uint b, uint c, uint d, uint x, int s, uint t)
|
||
|
|
{
|
||
|
|
// (b + LSR((a + I(b, c, d) + k + i), s))
|
||
|
|
// I(x, y, z) (y ^ (x | (z ^ 0xFFFFFFFF)))
|
||
|
|
return unchecked(b + LSR((a + (c ^ (b | (d ^ 0xFFFFFFFF))) + x + t), s));
|
||
|
|
}
|
||
|
|
|
||
|
|
// Implementation of left rotate
|
||
|
|
// s is an int instead of a uint becuase the CLR requires the argument passed to >>/<< is of
|
||
|
|
// type int. Doing the demoting inside this function would add overhead.
|
||
|
|
private static uint LSR(uint i, int s)
|
||
|
|
{
|
||
|
|
return (i << s) | (i >> (32 - s));
|
||
|
|
}
|
||
|
|
|
||
|
|
// Convert input array into array of UInts.
|
||
|
|
static uint[] Converter(byte[] input, int ibStart)
|
||
|
|
{
|
||
|
|
if (null == input)
|
||
|
|
throw new ArgumentNullException("input");
|
||
|
|
|
||
|
|
uint[] result = new uint[16];
|
||
|
|
for (int idx = 0; idx < 16; idx++)
|
||
|
|
{
|
||
|
|
result[idx] = (uint)input[ibStart + idx * 4];
|
||
|
|
result[idx] += (uint)input[ibStart + idx * 4 + 1] << 8;
|
||
|
|
result[idx] += (uint)input[ibStart + idx * 4 + 2] << 16;
|
||
|
|
result[idx] += (uint)input[ibStart + idx * 4 + 3] << 24;
|
||
|
|
|
||
|
|
Debug.Assert(result[idx] ==
|
||
|
|
(input[ibStart + idx * 4]) +
|
||
|
|
((uint)input[ibStart + idx * 4 + 1] << 8) +
|
||
|
|
((uint)input[ibStart + idx * 4 + 2] << 16) +
|
||
|
|
((uint)input[ibStart + idx * 4 + 3] << 24));
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Simple struct for the (a,b,c,d) which is used to compute the mesage digest.
|
||
|
|
public struct ABCDStruct
|
||
|
|
{
|
||
|
|
public uint A;
|
||
|
|
public uint B;
|
||
|
|
public uint C;
|
||
|
|
public uint D;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
#if GDI && DEBUG && true_
|
||
|
|
|
||
|
|
// See here for details: http://archive.msdn.microsoft.com/SilverlightMD5/WorkItem/View.aspx?WorkItemId=3
|
||
|
|
|
||
|
|
public static class TestMD5
|
||
|
|
{
|
||
|
|
public static void Test()
|
||
|
|
{
|
||
|
|
Random rnd = new Random();
|
||
|
|
for (int i = 0; i < 10000; i++)
|
||
|
|
{
|
||
|
|
int count = rnd.Next(1000) + 1;
|
||
|
|
Console.WriteLine(String.Format("{0}: {1}", i, count));
|
||
|
|
Test2(count);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static void Test2(int count)
|
||
|
|
{
|
||
|
|
byte[] bytes = new byte[count];
|
||
|
|
|
||
|
|
for (int idx = 0; idx < count; idx += 16)
|
||
|
|
Array.Copy(Guid.NewGuid().ToByteArray(), 0, bytes, idx, Math.Min(16, count - idx));
|
||
|
|
|
||
|
|
MD5 md5dotNet = new MD5CryptoServiceProvider();
|
||
|
|
md5dotNet.Initialize();
|
||
|
|
MD5Managed md5m = new MD5Managed();
|
||
|
|
md5m.Initialize();
|
||
|
|
|
||
|
|
byte[] result1 = md5dotNet.ComputeHash(bytes);
|
||
|
|
byte[] result2 = md5m.ComputeHash(bytes);
|
||
|
|
|
||
|
|
if (!CompareBytes(result1, result2))
|
||
|
|
{
|
||
|
|
count.GetType();
|
||
|
|
//throw new Exception("Bug in MD5Managed...");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static bool CompareBytes(byte[] bytes1, byte[] bytes2)
|
||
|
|
{
|
||
|
|
for (int idx = 0; idx < bytes1.Length; idx++)
|
||
|
|
{
|
||
|
|
if (bytes1[idx] != bytes2[idx])
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
#endif
|