public override void Write(Int32 val)
		{
			val = Utilities.SwapBytes(val);
			base.Write(val);

			if (AutoFlush) Flush();
		}

 private void OnSuggest(IPeerWireClient client, Int32 pieceIndex)
 {
     if (SuggestPiece != null)
     {
         SuggestPiece(client, pieceIndex);
     }
 }

        /// <summary>
        /// Find suffixes in the pattern.
        /// </summary>
        /// <param name="pattern">Pattern for search.</param>
        /// <returns>Suffix array.</returns>
        private static Int32[] FindSuffixes(String pattern)
        {
            Int32 f = 0, g;

            Int32 patternLength = pattern.Length;
            Int32[] suffixes = new Int32[pattern.Length + 1];

            suffixes[patternLength - 1] = patternLength;
            g = patternLength - 1;
            for (Int32 i = patternLength - 2; i >= 0; --i)
            {
                if (i > g && suffixes[i + patternLength - 1 - f] < i - g)
                {
                    suffixes[i] = suffixes[i + patternLength - 1 - f];
                }
                else
                {
                    if (i < g)
                    {
                        g = i;
                    }
                    
                    f = i;

                    while (g >= 0 && (pattern[g] == pattern[g + patternLength - 1 - f]))
                    {
                        --g;
                    }

                    suffixes[i] = f - g;
                }
            }

            return suffixes;
        }

        /// <summary>
        /// Converts a <see cref="Int32"/> to big endian notation.
        /// </summary>
        /// <param name="input">The <see cref="Int32"/> to convert.</param>
        /// <returns>The converted <see cref="Int32"/>.</returns>
        public static Int32 BigEndian(Int32 input)
        {
            if (!BitConverter.IsLittleEndian)
                return input;

            return Swap(input);
        }

 private static Boolean HexNumberToInt32(ref NumberBuffer number, ref Int32 value)
 {
     UInt32 passedValue = 0;
     Boolean returnValue = HexNumberToUInt32(ref number, ref passedValue);
     value = (Int32)passedValue;
     return returnValue;
 }

        private static void VerifyInt32ImplicitCastToComplex(Int32 value)
        {
            Complex c_cast = value;

            if (false == Support.VerifyRealImaginaryProperties(c_cast, value, 0.0))
            {
                Console.WriteLine("Int32ImplicitCast ({0})" + value);
                Assert.True(false, "Verification Failed");
            }
            else
            {
                if (value != Int32.MaxValue)
                {
                    Complex c_cast_plus = c_cast + 1;
                    if (false == Support.VerifyRealImaginaryProperties(c_cast_plus, value + 1, 0.0))
                    {
                        Console.WriteLine("PLuS + Int32ImplicitCast ({0})" + value);
                        Assert.True(false, "Verification Failed");
                    }
                }

                if (value != Int32.MinValue)
                {
                    Complex c_cast_minus = c_cast - 1;
                    if (false == Support.VerifyRealImaginaryProperties(c_cast_minus, value - 1, 0.0))
                    {
                        Console.WriteLine("Minus - Int32ImplicitCast + 1 ({0})" + value);
                        Assert.True(false, "Verification Failed");
                    }
                }
            }
        }

 public static Money[] Distribute(this Money money,
     FractionReceivers fractionReceivers,
     RoundingPlaces roundingPlaces,
     Int32 count)
 {
     return new MoneyDistributor(money, fractionReceivers, roundingPlaces).Distribute(count);
 }

    public void Enter() {
        // If calling thread already owns the lock, increment recursion count and return
        Int32 threadId = Thread.CurrentThread.ManagedThreadId;
        if (threadId == m_owningThreadId) { m_recursion++; return; }

        // The calling thread doesn't own the lock, try to get it
        SpinWait spinwait = new SpinWait();
        for (Int32 spinCount = 0; spinCount < m_spincount; spinCount++) {
            // If the lock was free, this thread got it; set some state and return
            if (Interlocked.CompareExchange(ref m_waiters, 1, 0) == 0) goto GotLock;

            // Black magic: give other threads a chance to run
            // in hopes that the lock will be released
            spinwait.SpinOnce();
        }

        // Spinning is over and the lock was still not obtained, try one more time
        if (Interlocked.Increment(ref m_waiters) > 1) {
            // Still contention, this thread must wait
            m_waiterLock.WaitOne(); // Wait for the lock; performance hit
            // When this thread wakes, it owns the lock; set some state and return
        }

        GotLock:
        // When a thread gets the lock, we record its ID and
        // indicate that the thread owns the lock once
        m_owningThreadId = threadId; m_recursion = 1;
    }

 public Document(
     Int16 _TypeId,
     Int64 _Serial,
     Int32 _SignedUser,
     DateTime _Date,
     Boolean _Printed,
     String _DocumentShortName,
     String _DocumentFullName,
     String _MedexDataTable,
     String _DocumentBody,
     String _DocumentHeader,
     Boolean _SetDeleted
     
     )
 {
     TypeId = _TypeId;
        Serial = _Serial;
        SignedUser = _SignedUser;
        Date = _Date;
        Printed = _Printed;
        DocumentShortName = _DocumentShortName;
        DocumentFullName = _DocumentFullName;
        MedexDataTable = _MedexDataTable;
        DocumentBody = _DocumentBody;
        DocumentHeader = _DocumentHeader;
        SetDeleted = _SetDeleted;
 }

        public Task<bool> WaitAsync(Int32 duration, CancellationToken token)
        {
           VerboseLog("{0:000}|{1}|async wait requested", Thread.CurrentThread.Id, _id);

            CheckDisposed();
            token.ThrowIfCancellationRequested();

            if (_sem.TryAcquire())
            {
                VerboseLog("{0:000}|{1}|async wait immediate success", Thread.CurrentThread.Id,_id);
                return Task.FromResult(true);
            }
                

            if(duration == 0)
                return Task.FromResult(false);
            
            if (_asyncWaiters == null)
            {
                lock (this)
                {
                    if (_asyncWaiters == null)
                        _asyncWaiters = new ConcurrentLinkedQueue<AsyncWaiter>();
                }
            }

            AsyncWaiter waiter = new AsyncWaiter();
            TaskCompletionSource<bool> task = new TaskCompletionSource<bool>();
            
            waiter.Task = task;

            if (duration != -1)
            {
                waiter.CancelDelay = new CancellationTokenSource();
                waiter.Delay = Task.Delay(duration, waiter.CancelDelay.Token);
                waiter.Delay.ContinueWith(new ActionContinuation(() => TimeoutAsync(waiter)));
            }

            if (token != CancellationToken.None)
            {
                waiter.CancelRegistration = token.Register(() => CancelAsync(waiter));
            }
         
            _asyncWaiters.Add(waiter);

            VerboseLog("{0:000}|{1}|async wait enqued: {2:X}; {3}", Thread.CurrentThread.Id, _id, waiter.GetHashCode(), waiter.Task.Task.Id);

            if (_wasDisposed || token.IsCancellationRequested || waiter.Delay != null && waiter.Delay.IsCompleted)
            {
                // Mitigate the above race where a finishing condition occured
                // before where able to add our waiter to the waiters list.
                if (_asyncWaiters.Remove(waiter))
                {
                    CleanUpWaiter(waiter);
                }
            }

            return task.Task;
        }

            public AnnounceInfo(IEnumerable<EndPoint> peers, Int32 a, Int32 b, Int32 c)
            {
                Peers = peers;

                WaitTime = a;
                Seeders = b;
                Leachers = c;
            }

        public static byte[] Int32(Int32 i, Endianness e = Endianness.Machine)
        {
            byte[] bytes = BitConverter.GetBytes(i);

            if (NeedsFlipping(e)) Array.Reverse(bytes);

            return bytes;
        }

        public static UInt32 UInt32(byte[] bytes, Int32 start, Endianness e = Endianness.Machine)
        {
            byte[] intBytes = Utils.GetBytes(bytes, start, 4);

            if (NeedsFlipping(e)) Array.Reverse(intBytes);

            return BitConverter.ToUInt32(intBytes, 0);
        }

        public static void SetInt32(this Byte[] buffer, Int32 value, Int32 pos)
        {
            Byte[] copybuffer;

            copybuffer = BitConverter.GetBytes(value);
            Array.Reverse(copybuffer);
            Array.Copy(copybuffer, 0, buffer, pos, 4);
        }

 public RpcHeader RequestAdd(Int32 a, Int32 b)
 {
     var packetId = Interlocked.Increment(ref globalPacketId);
     return w.Request(() => {
     w.Write(a);
     w.Write(b);
     }, length => new RpcHeader((int)MethodId.Add, (uint)packetId, length));
 }

 internal RegexTree(RegexNode root, Dictionary<Int32, Int32> caps, Int32[] capnumlist, int captop, Dictionary<String, Int32> capnames, String[] capslist, RegexOptions opts)
 {
     _root = root;
     _caps = caps;
     _capnumlist = capnumlist;
     _capnames = capnames;
     _capslist = capslist;
     _captop = captop;
     _options = opts;
 }

        public User(string login, UInt64 passwordHash, Int32 ID)
        {
            pLogin = login;
            pPassword = new Password(passwordHash);
            pID = ID;

            pStaticAddressess = new List<UnifiedAddress>();
            pDynamicAddressess = new List<UnifiedAddress>();
            pCurrentAddress = null;
        }

 internal RegexTree(RegexNode root, Hashtable caps, Int32[] capnumlist, int captop, Hashtable capnames, String[] capslist, RegexOptions opts)
 {
     _root = root;
     _caps = caps;
     _capnumlist = capnumlist;
     _capnames = capnames;
     _capslist = capslist;
     _captop = captop;
     _options = opts;
 }

        public static UInt32 GetUInt32(this Byte[] buffer, Int32 pos)
        {
            Byte[] copybuffer;

            copybuffer = new Byte[4];
            Array.Copy(buffer, pos, copybuffer, 0, 4);
            Array.Reverse(copybuffer);

            return BitConverter.ToUInt32(copybuffer, 0);
        }

        /// <summary>Returns the next token in <paramref name="str"/> from position <paramref name="start"/>. Barring whitespace, it returns the sequence of characters from <paramref name="start"/> that share the same unicode category.</summary>
        public static String Tok(this String str, ref Int32 start)
        {
            if(start >= str.Length) throw new ArgumentOutOfRangeException("start");

            Int32 i = start;

            StringBuilder sb = new StringBuilder();

            Char c = str[i];

            // skip whitespace
            while( i < str.Length ) {

                c = str[ i ];
                if( !Char.IsWhiteSpace( c ) ) break;
                i++;
            }
            if( Char.IsWhiteSpace( c ) ) {
                start = str.Length;
                return null; // then it's got some trailing whitespace left, and it's at the end
            }

            Boolean doneRadixPoint = false;
            UnicodeCategory currentCat, initialCat;
            Char initialChar = c;
            initialCat = currentCat = Char.GetUnicodeCategory( c );

            // special case for ( and )
            if( initialChar == '(' || initialChar == ')' ) {
                start = i + 1;
                return initialChar.ToString();
            }

            while( i < str.Length && CategoryEquals(initialCat, currentCat) ) {

                c = str[i];
                sb.Append( str[i++] );

                if( i >= str.Length ) break;

                currentCat = Char.GetUnicodeCategory(str, i);

                // special case exception for radix points, there can only be 1
                if( initialCat == UnicodeCategory.DecimalDigitNumber && str[i] == '.' && !doneRadixPoint) {
                    currentCat = UnicodeCategory.DecimalDigitNumber;
                    doneRadixPoint = true;
                }

            }

            start = i;

            return sb.ToString();
        }