public object WithRefsWithReturn(
     ref string param1,
     ref int param2,
     ref short param3,
     ref long param4,
     ref uint param5,
     ref ushort param6,
     ref ulong param7,
     ref bool param8,
     ref double param9,
     ref decimal param10,
     ref int? param11,
     ref object param12,
     ref char param13,
     ref DateTime param14,
     ref Single param15,
     ref IntPtr param16,
     ref UInt16 param17,
     ref UInt32 param18,
     ref UInt64 param19,
     ref UIntPtr param20
     )
 {
     throw new Exception("Foo");
 }

        public ValueVersion(UInt64 ve, string ss, byte[] va, int ec, ProcessStatus status, Int64 start, Int64 stop)
        {
            version = ve;
            shortStatus = ss;
            value = va;
            exitCode = ec;
            startTime = start;
            stopTime = stop;
            switch (status)
            {
                case ProcessStatus.Queued:
                    processStatus = "Queued";
                    break;

                case ProcessStatus.Running:
                    processStatus = "Running";
                    break;

                case ProcessStatus.Canceling:
                    processStatus = "Canceling";
                    break;

                default:
                    processStatus = "Completed";
                    break;
            }
        }

 /**
  * @since 3.0
  */
 public DistortionData(UInt64 version, float width, float height, float[] data)
 {
   Version = version;
   Width = width;
   Height = height;
   Data = data;
 }

        // Initialize *this for looking up user_key at a snapshot with
        // the specified sequence number.
        public LookupKey(Slice user_key, UInt64 sequence)
        {
            int usize = user_key.Size;
            int needed = usize + 13;  // A conservative estimate
            ByteArrayPointer dst;

            if (needed <= space_.Length)
            {
                dst = new ByteArrayPointer(space_);
            }
            else
            {
                dst = new ByteArrayPointer(needed);
            }

            start_ = dst;
            dst = Coding.EncodeVarint32(dst, (uint)(usize + 8));
            kstart_ = dst;

            user_key.Data.CopyTo(dst, usize);

            dst += usize;

            Coding.EncodeFixed64(dst, Global.PackSequenceAndType(sequence ,Global.kValueTypeForSeek));
            end_ = dst + 8;
        }

		/// <summary>
		/// Reverses the bytes.
		/// </summary>
		/// <returns>The bytes.</returns>
		/// <param name="value">Value.</param>
		private static UInt64 ReverseBytes(UInt64 value)
		{
			return (value & 0x00000000000000FFUL) << 56 | (value & 0x000000000000FF00UL) << 40 |
				(value & 0x0000000000FF0000UL) << 24 | (value & 0x00000000FF000000UL) << 8 |
				(value & 0x000000FF00000000UL) >> 8 | (value & 0x0000FF0000000000UL) >> 24 |
				(value & 0x00FF000000000000UL) >> 40 | (value & 0xFF00000000000000UL) >> 56;
		}

 public WebSocketBinaryFrame(byte[] data, UInt64 pos, UInt64 length, bool isFinal)
 {
     this.Data = data;
     this.Pos = pos;
     this.Length = length;
     this.IsFinal = isFinal;
 }

 public SftpWriteRequest(uint requestId, byte[] handle, UInt64 offset, byte[] data, Action<SftpStatusResponse> statusAction)
     : base(requestId, statusAction)
 {
     this.Handle = handle;
     this.Offset = offset;
     this.Data = data;
 }

 internal static object AddImpl(UInt64 left, UInt64 right)
 {
     if (left > UInt64.MaxValue - right) {
         return BigInteger.Create(left) + BigInteger.Create(right);
     }
     return left + right;
 }

 public ArpGenericData(UInt64 destinationEthernetAddress, ArpOperation arpOperation, UInt64 targetPhysicalAddress, UInt32 targetProtocolAddress)
 {
     this.DestinationEthernetAddress = destinationEthernetAddress;
     this.ArpOperaton = arpOperation;
     this.TargetPhysicalAddress = targetPhysicalAddress;
     this.TargetProtocolAddress = targetProtocolAddress;
 }

        internal static Tweak EncodeTweak(UInt64 position, bool bitPad, TweakType type, bool first, bool final)
        {
            //
            // Takes tweak parameters and encodes them in a 128 bit value. The lower half of the 128 byte value (only the position)
            // is stuck in low64 and the high half in stuck in high64.
            //
            // N.B SimpleSkeinManaged specifies that position can be upto 2^96 but we support only 2^64. We could add support by rolling our own BigInteger
            //
            // The encoding is as follows (ASCII art not to scale)
            //
            // 128             120                   112            96                                    0
            // --------------------------------------------------------------------------------------------
            // F1|F2|    Type   |B|       TreeLevel   |   reserved  |      Position                       |
            //   |  |           | |                   |             |                                     |
            // --------------------------------------------------------------------------------------------
            //  F1 = First
            //  F2 = Final
            //  B  - BitPad
            //

            Tweak tweak = new Tweak(0,0);
            tweak.high64 = 0;

            //
            // The shift numbers are calculated using 64 - (128 - end-byte-from-diagram-above)
            //
            if (final) tweak.high64 |= (UInt64)1L << 63; // Set F1 in diagram above
            if (first) tweak.high64 |= (UInt64)1L << 62; // Set F2 in diagram above
            tweak.high64 |= (UInt64)type << 56; // Set type
            if (bitPad) tweak.high64 |= (UInt64)1L << 55; // Set bit pad

            tweak.low64 = position;
            return tweak;
        }

 /// <summary>
 /// Compute the fingerprint
 /// </summary>
 /// <param name="source">String to compute</param>
 /// <returns>Hash key</returns>
 public static UInt64 ComputeFingerPrint(string source)
 {
     byte[] table = Encoding.Unicode.GetBytes(source);
     UInt64[] values = new UInt64[table.LongLength];
     ConvertBytes(ref table, ref values);
     return Compute(values);
 }

        public void onRemoveAvatar(UInt64 dbid)
        {
            Dbg.DEBUG_MSG("Account::onRemoveAvatar: dbid=" + dbid);

            avatars.Remove(dbid);
            Event.fire("onRemoveAvatar", new object[]{dbid});
        }

 public static string getAssignDepartmentToDoctorQuery(UInt64 departmentID, UInt64 doctorID)
 {
     StringBuilder query = new StringBuilder();
     query.Append("Insert into doctors(dr_id, dept_id) values(").Append(doctorID).Append(", ");
     query.Append(departmentID).Append(")");
     return query.ToString();
 }

 public PackageMissingException(string name, string arch, UInt64 version, string publicKeyToken)
 {
     Name = name;
     Arch = arch;
     Version = version;
     PublicKeyToken = publicKeyToken;
 }

 public Result(UInt64 number, UInt64 skip, UInt64 first, bool includeTotalCount)
 {
     this._number = number;
     this._skip = skip;
     this._first = first;
     this._includeTotalCount = includeTotalCount;
 }

        // Store entry into TTable
        public void storeTTable(UInt64 key, TTEntry entry)
        {
            int index = (int) (key % Constants.TT_SIZE);

            // If entry in bucket has same hash key, then replace
            for (int i = index; i < index + Constants.BUCKET_SIZE; i++) {
                if (this.transpositionTable[i].key == key) {
                    this.transpositionTable[i] = entry;
                    return;
                }
            }
            // If there is an empty spot in the bucket, then store it there
            for (int i = index; i < index + Constants.BUCKET_SIZE; i++) {
                if (this.transpositionTable[i].key == 0) {
                    this.transpositionTable[i] = entry;
                    return;
                }
            }
            // If all spots full, then replace entry with lowest depth
            int shallowestDepth = Constants.INF;
            int indexOfShallowestEntry = -1;
            for (int i = index; i < index + Constants.BUCKET_SIZE; i++) {
                if (this.transpositionTable[i].depth < shallowestDepth) {
                    shallowestDepth = this.transpositionTable[i].depth;
                    indexOfShallowestEntry = i;
                }
            }
            this.transpositionTable[indexOfShallowestEntry] = entry;
        }

        public static void RunTest(Byte[] code, UInt64 address)
        {
            var u = new Unicorn(Common.UC_ARCH_X86, Common.UC_MODE_32);
            Console.WriteLine("Unicorn version: {0}", u.Version());

            // map 2MB of memory for this emulation
            Utils.CheckError(u.MemMap(address, new UIntPtr(2 * 1024 * 1024), Common.UC_PROT_ALL));

            // write machine code to be emulated to memory
            Utils.CheckError(u.MemWrite(address, code));

            // initialize machine registers
            Utils.CheckError(u.RegWrite(X86.UC_X86_REG_ESP, Utils.Int64ToBytes(address + 0x200000)));

            // tracing all instructions by having @begin > @end
            Utils.CheckError(u.AddCodeHook(CodeHookCallback, null, 1, 0).Item1);

            // handle interrupt ourself
            Utils.CheckError(u.AddInterruptHook(InterruptHookCallback, null).Item1);

            // handle SYSCALL
            Utils.CheckError(u.AddSyscallHook(SyscallHookCallback, null).Item1);

            Console.WriteLine(">>> Start tracing linux code");

            // emulate machine code in infinite time
            u.EmuStart(address, address + (UInt64)code.Length, 0u, new UIntPtr(0));

            Console.WriteLine(">>> Emulation Done!");
        }

 /// <summary>
 /// Translate a Teambox data timestamp to a DateTime object in UTC.
 /// </summary>
 public static DateTime KDateToDateTimeUTC(UInt64 _date)
 {
     DateTime date = new DateTime((long)_date * TimeSpan.TicksPerSecond);
     DateTime epochStartTime = Convert.ToDateTime("1/1/1970 00:00:00 AM");
     TimeSpan t = new TimeSpan(date.Ticks + epochStartTime.Ticks);
     return new DateTime(t.Ticks);
 }

 public static UInt64 Reverse(UInt64 i)
 {
     return (i & 0x00000000000000FFUL) << 56 | (i & 0x000000000000FF00UL) << 40 |
            (i & 0x0000000000FF0000UL) << 24 | (i & 0x00000000FF000000UL) << 8 |
            (i & 0x000000FF00000000UL) >> 8 | (i & 0x0000FF0000000000UL) >> 24 |
            (i & 0x00FF000000000000UL) >> 40 | (i & 0xFF00000000000000UL) >> 56;
 }

        public Mdhd(FileStream fs, ulong size)
        {
            Buffer = new byte[size - 4];
            fs.Read(Buffer, 0, Buffer.Length);
            int languageIndex = 20;
            int version = Buffer[0];
            if (version == 0)
            {
                CreationTime = GetUInt(4);
                ModificationTime = GetUInt(8);
                TimeScale = GetUInt(12);
                Duration = GetUInt(16);
                Quality = GetWord(22);
            }
            else
            {
                CreationTime = GetUInt64(4);
                ModificationTime = GetUInt64(12);
                TimeScale = GetUInt(16);
                Duration = GetUInt64(20);
                languageIndex = 24;
                Quality = GetWord(26);
            }

            // language code = skip first byte, 5 bytes + 5 bytes + 5 bytes (add 0x60 to get ascii value)
            int languageByte = ((Buffer[languageIndex] << 1) >> 3) + 0x60;
            int languageByte2 = ((Buffer[languageIndex] & 0x3) << 3) + (Buffer[languageIndex + 1] >> 5) + 0x60;
            int languageByte3 = (Buffer[languageIndex + 1] & 0x1f) + 0x60;
            char x = (char)languageByte;
            char x2 = (char)languageByte2;
            char x3 = (char)languageByte3;
            Iso639ThreeLetterCode = x.ToString(CultureInfo.InvariantCulture) + x2.ToString(CultureInfo.InvariantCulture) + x3.ToString(CultureInfo.InvariantCulture);
        }