[Add] FishNet

Assets/FishNet/CodeGenerating/cecil-0.11.4/Mono.Cecil.Cil/Code.cs

@@ -0,0 +1,235 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+namespace MonoFN.Cecil.Cil
+{
+    public enum Code
+    {
+        Nop,
+        Break,
+        Ldarg_0,
+        Ldarg_1,
+        Ldarg_2,
+        Ldarg_3,
+        Ldloc_0,
+        Ldloc_1,
+        Ldloc_2,
+        Ldloc_3,
+        Stloc_0,
+        Stloc_1,
+        Stloc_2,
+        Stloc_3,
+        Ldarg_S,
+        Ldarga_S,
+        Starg_S,
+        Ldloc_S,
+        Ldloca_S,
+        Stloc_S,
+        Ldnull,
+        Ldc_I4_M1,
+        Ldc_I4_0,
+        Ldc_I4_1,
+        Ldc_I4_2,
+        Ldc_I4_3,
+        Ldc_I4_4,
+        Ldc_I4_5,
+        Ldc_I4_6,
+        Ldc_I4_7,
+        Ldc_I4_8,
+        Ldc_I4_S,
+        Ldc_I4,
+        Ldc_I8,
+        Ldc_R4,
+        Ldc_R8,
+        Dup,
+        Pop,
+        Jmp,
+        Call,
+        Calli,
+        Ret,
+        Br_S,
+        Brfalse_S,
+        Brtrue_S,
+        Beq_S,
+        Bge_S,
+        Bgt_S,
+        Ble_S,
+        Blt_S,
+        Bne_Un_S,
+        Bge_Un_S,
+        Bgt_Un_S,
+        Ble_Un_S,
+        Blt_Un_S,
+        Br,
+        Brfalse,
+        Brtrue,
+        Beq,
+        Bge,
+        Bgt,
+        Ble,
+        Blt,
+        Bne_Un,
+        Bge_Un,
+        Bgt_Un,
+        Ble_Un,
+        Blt_Un,
+        Switch,
+        Ldind_I1,
+        Ldind_U1,
+        Ldind_I2,
+        Ldind_U2,
+        Ldind_I4,
+        Ldind_U4,
+        Ldind_I8,
+        Ldind_I,
+        Ldind_R4,
+        Ldind_R8,
+        Ldind_Ref,
+        Stind_Ref,
+        Stind_I1,
+        Stind_I2,
+        Stind_I4,
+        Stind_I8,
+        Stind_R4,
+        Stind_R8,
+        Add,
+        Sub,
+        Mul,
+        Div,
+        Div_Un,
+        Rem,
+        Rem_Un,
+        And,
+        Or,
+        Xor,
+        Shl,
+        Shr,
+        Shr_Un,
+        Neg,
+        Not,
+        Conv_I1,
+        Conv_I2,
+        Conv_I4,
+        Conv_I8,
+        Conv_R4,
+        Conv_R8,
+        Conv_U4,
+        Conv_U8,
+        Callvirt,
+        Cpobj,
+        Ldobj,
+        Ldstr,
+        Newobj,
+        Castclass,
+        Isinst,
+        Conv_R_Un,
+        Unbox,
+        Throw,
+        Ldfld,
+        Ldflda,
+        Stfld,
+        Ldsfld,
+        Ldsflda,
+        Stsfld,
+        Stobj,
+        Conv_Ovf_I1_Un,
+        Conv_Ovf_I2_Un,
+        Conv_Ovf_I4_Un,
+        Conv_Ovf_I8_Un,
+        Conv_Ovf_U1_Un,
+        Conv_Ovf_U2_Un,
+        Conv_Ovf_U4_Un,
+        Conv_Ovf_U8_Un,
+        Conv_Ovf_I_Un,
+        Conv_Ovf_U_Un,
+        Box,
+        Newarr,
+        Ldlen,
+        Ldelema,
+        Ldelem_I1,
+        Ldelem_U1,
+        Ldelem_I2,
+        Ldelem_U2,
+        Ldelem_I4,
+        Ldelem_U4,
+        Ldelem_I8,
+        Ldelem_I,
+        Ldelem_R4,
+        Ldelem_R8,
+        Ldelem_Ref,
+        Stelem_I,
+        Stelem_I1,
+        Stelem_I2,
+        Stelem_I4,
+        Stelem_I8,
+        Stelem_R4,
+        Stelem_R8,
+        Stelem_Ref,
+        Ldelem_Any,
+        Stelem_Any,
+        Unbox_Any,
+        Conv_Ovf_I1,
+        Conv_Ovf_U1,
+        Conv_Ovf_I2,
+        Conv_Ovf_U2,
+        Conv_Ovf_I4,
+        Conv_Ovf_U4,
+        Conv_Ovf_I8,
+        Conv_Ovf_U8,
+        Refanyval,
+        Ckfinite,
+        Mkrefany,
+        Ldtoken,
+        Conv_U2,
+        Conv_U1,
+        Conv_I,
+        Conv_Ovf_I,
+        Conv_Ovf_U,
+        Add_Ovf,
+        Add_Ovf_Un,
+        Mul_Ovf,
+        Mul_Ovf_Un,
+        Sub_Ovf,
+        Sub_Ovf_Un,
+        Endfinally,
+        Leave,
+        Leave_S,
+        Stind_I,
+        Conv_U,
+        Arglist,
+        Ceq,
+        Cgt,
+        Cgt_Un,
+        Clt,
+        Clt_Un,
+        Ldftn,
+        Ldvirtftn,
+        Ldarg,
+        Ldarga,
+        Starg,
+        Ldloc,
+        Ldloca,
+        Stloc,
+        Localloc,
+        Endfilter,
+        Unaligned,
+        Volatile,
+        Tail,
+        Initobj,
+        Constrained,
+        Cpblk,
+        Initblk,
+        No,
+        Rethrow,
+        Sizeof,
+        Refanytype,
+        Readonly
+    }
+}

Assets/FishNet/CodeGenerating/cecil-0.11.4/Mono.Cecil.Cil/Code.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 2619210c5ef352b4aac70d8e5fab7a43
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/CodeGenerating/cecil-0.11.4/Mono.Cecil.Cil/Code.cs
+  uploadId: 866910

Assets/FishNet/CodeGenerating/cecil-0.11.4/Mono.Cecil.Cil/CodeReader.cs

@@ -0,0 +1,675 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using MonoFN.Cecil.PE;
+using MonoFN.Collections.Generic;
+using System;
+
+namespace MonoFN.Cecil.Cil
+{
+    internal sealed class CodeReader : BinaryStreamReader
+    {
+        internal readonly MetadataReader reader;
+        private int start;
+        private MethodDefinition method;
+        private MethodBody body;
+        private int Offset
+        {
+            get { return Position - start; }
+        }
+
+        public CodeReader(MetadataReader reader) : base(reader.image.Stream.value)
+        {
+            this.reader = reader;
+        }
+
+        public int MoveTo(MethodDefinition method)
+        {
+            this.method = method;
+            reader.context = method;
+            int position = Position;
+            Position = (int)reader.image.ResolveVirtualAddress((uint)method.RVA);
+            return position;
+        }
+
+        public void MoveBackTo(int position)
+        {
+            reader.context = null;
+            Position = position;
+        }
+
+        public MethodBody ReadMethodBody(MethodDefinition method)
+        {
+            int position = MoveTo(method);
+            body = new(method);
+
+            ReadMethodBody();
+
+            MoveBackTo(position);
+            return body;
+        }
+
+        public int ReadCodeSize(MethodDefinition method)
+        {
+            int position = MoveTo(method);
+
+            int code_size = ReadCodeSize();
+
+            MoveBackTo(position);
+            return code_size;
+        }
+
+        private int ReadCodeSize()
+        {
+            byte flags = ReadByte();
+            switch (flags & 0x3)
+            {
+                case 0x2: // tiny
+                    return flags >> 2;
+                case 0x3: // fat
+                    Advance(-1 + 2 + 2); // go back, 2 bytes flags, 2 bytes stack size
+                    return (int)ReadUInt32();
+                default:
+                    throw new InvalidOperationException();
+            }
+        }
+
+        private void ReadMethodBody()
+        {
+            byte flags = ReadByte();
+            switch (flags & 0x3)
+            {
+                case 0x2: // tiny
+                    body.code_size = flags >> 2;
+                    body.MaxStackSize = 8;
+                    ReadCode();
+                    break;
+                case 0x3: // fat
+                    Advance(-1);
+                    ReadFatMethod();
+                    break;
+                default:
+                    throw new InvalidOperationException();
+            }
+
+            ISymbolReader symbol_reader = reader.module.symbol_reader;
+
+            if (symbol_reader != null && method.debug_info == null)
+                method.debug_info = symbol_reader.Read(method);
+
+            if (method.debug_info != null)
+                ReadDebugInfo();
+        }
+
+        private void ReadFatMethod()
+        {
+            ushort flags = ReadUInt16();
+            body.max_stack_size = ReadUInt16();
+            body.code_size = (int)ReadUInt32();
+            body.local_var_token = new(ReadUInt32());
+            body.init_locals = (flags & 0x10) != 0;
+
+            if (body.local_var_token.RID != 0)
+                body.variables = ReadVariables(body.local_var_token);
+
+            ReadCode();
+
+            if ((flags & 0x8) != 0)
+                ReadSection();
+        }
+
+        public VariableDefinitionCollection ReadVariables(MetadataToken local_var_token)
+        {
+            int position = reader.position;
+            VariableDefinitionCollection variables = reader.ReadVariables(local_var_token, method);
+            reader.position = position;
+
+            return variables;
+        }
+
+        private void ReadCode()
+        {
+            start = Position;
+            int code_size = body.code_size;
+
+            if (code_size < 0 || Length <= (uint)(code_size + Position))
+                code_size = 0;
+
+            int end = start + code_size;
+            Collection<Instruction> instructions = body.instructions = new InstructionCollection(method, (code_size + 1) / 2);
+
+            while (Position < end)
+            {
+                int offset = Position - start;
+                OpCode opcode = ReadOpCode();
+                Instruction current = new(offset, opcode);
+
+                if (opcode.OperandType != OperandType.InlineNone)
+                    current.operand = ReadOperand(current);
+
+                instructions.Add(current);
+            }
+
+            ResolveBranches(instructions);
+        }
+
+        private OpCode ReadOpCode()
+        {
+            byte il_opcode = ReadByte();
+            return il_opcode != 0xfe ? OpCodes.OneByteOpCode[il_opcode] : OpCodes.TwoBytesOpCode[ReadByte()];
+        }
+
+        private object ReadOperand(Instruction instruction)
+        {
+            switch (instruction.opcode.OperandType)
+            {
+                case OperandType.InlineSwitch:
+                    int length = ReadInt32();
+                    int base_offset = Offset + 4 * length;
+                    int[] branches = new int [length];
+                    for (int i = 0; i < length; i++)
+                        branches[i] = base_offset + ReadInt32();
+                    return branches;
+                case OperandType.ShortInlineBrTarget:
+                    return ReadSByte() + Offset;
+                case OperandType.InlineBrTarget:
+                    return ReadInt32() + Offset;
+                case OperandType.ShortInlineI:
+                    if (instruction.opcode == OpCodes.Ldc_I4_S)
+                        return ReadSByte();
+
+                    return ReadByte();
+                case OperandType.InlineI:
+                    return ReadInt32();
+                case OperandType.ShortInlineR:
+                    return ReadSingle();
+                case OperandType.InlineR:
+                    return ReadDouble();
+                case OperandType.InlineI8:
+                    return ReadInt64();
+                case OperandType.ShortInlineVar:
+                    return GetVariable(ReadByte());
+                case OperandType.InlineVar:
+                    return GetVariable(ReadUInt16());
+                case OperandType.ShortInlineArg:
+                    return GetParameter(ReadByte());
+                case OperandType.InlineArg:
+                    return GetParameter(ReadUInt16());
+                case OperandType.InlineSig:
+                    return GetCallSite(ReadToken());
+                case OperandType.InlineString:
+                    return GetString(ReadToken());
+                case OperandType.InlineTok:
+                case OperandType.InlineType:
+                case OperandType.InlineMethod:
+                case OperandType.InlineField:
+                    return reader.LookupToken(ReadToken());
+                default:
+                    throw new NotSupportedException();
+            }
+        }
+
+        public string GetString(MetadataToken token)
+        {
+            return reader.image.UserStringHeap.Read(token.RID);
+        }
+
+        public ParameterDefinition GetParameter(int index)
+        {
+            return body.GetParameter(index);
+        }
+
+        public VariableDefinition GetVariable(int index)
+        {
+            return body.GetVariable(index);
+        }
+
+        public CallSite GetCallSite(MetadataToken token)
+        {
+            return reader.ReadCallSite(token);
+        }
+
+        private void ResolveBranches(Collection<Instruction> instructions)
+        {
+            Instruction[] items = instructions.items;
+            int size = instructions.size;
+
+            for (int i = 0; i < size; i++)
+            {
+                Instruction instruction = items[i];
+                switch (instruction.opcode.OperandType)
+                {
+                    case OperandType.ShortInlineBrTarget:
+                    case OperandType.InlineBrTarget:
+                        instruction.operand = GetInstruction((int)instruction.operand);
+                        break;
+                    case OperandType.InlineSwitch:
+                        int[] offsets = (int[])instruction.operand;
+                        Instruction[] branches = new Instruction [offsets.Length];
+                        for (int j = 0; j < offsets.Length; j++)
+                            branches[j] = GetInstruction(offsets[j]);
+
+                        instruction.operand = branches;
+                        break;
+                }
+            }
+        }
+
+        private Instruction GetInstruction(int offset)
+        {
+            return GetInstruction(body.Instructions, offset);
+        }
+
+        private static Instruction GetInstruction(Collection<Instruction> instructions, int offset)
+        {
+            int size = instructions.size;
+            Instruction[] items = instructions.items;
+            if (offset < 0 || offset > items[size - 1].offset)
+                return null;
+
+            int min = 0;
+            int max = size - 1;
+            while (min <= max)
+            {
+                int mid = min + (max - min) / 2;
+                Instruction instruction = items[mid];
+                int instruction_offset = instruction.offset;
+
+                if (offset == instruction_offset)
+                    return instruction;
+
+                if (offset < instruction_offset)
+                    max = mid - 1;
+                else
+                    min = mid + 1;
+            }
+
+            return null;
+        }
+
+        private void ReadSection()
+        {
+            Align(4);
+
+            const byte fat_format = 0x40;
+            const byte more_sects = 0x80;
+
+            byte flags = ReadByte();
+            if ((flags & fat_format) == 0)
+                ReadSmallSection();
+            else
+                ReadFatSection();
+
+            if ((flags & more_sects) != 0)
+                ReadSection();
+        }
+
+        private void ReadSmallSection()
+        {
+            int count = ReadByte() / 12;
+            Advance(2);
+
+            ReadExceptionHandlers(count, () => (int)ReadUInt16(), () => (int)ReadByte());
+        }
+
+        private void ReadFatSection()
+        {
+            Advance(-1);
+            int count = (ReadInt32() >> 8) / 24;
+
+            ReadExceptionHandlers(count, ReadInt32, ReadInt32);
+        }
+
+        // inline ?
+        private void ReadExceptionHandlers(int count, Func<int> read_entry, Func<int> read_length)
+        {
+            for (int i = 0; i < count; i++)
+            {
+                ExceptionHandler handler = new((ExceptionHandlerType)(read_entry() & 0x7));
+
+                handler.TryStart = GetInstruction(read_entry());
+                handler.TryEnd = GetInstruction(handler.TryStart.Offset + read_length());
+
+                handler.HandlerStart = GetInstruction(read_entry());
+                handler.HandlerEnd = GetInstruction(handler.HandlerStart.Offset + read_length());
+
+                ReadExceptionHandlerSpecific(handler);
+
+                body.ExceptionHandlers.Add(handler);
+            }
+        }
+
+        private void ReadExceptionHandlerSpecific(ExceptionHandler handler)
+        {
+            switch (handler.HandlerType)
+            {
+                case ExceptionHandlerType.Catch:
+                    handler.CatchType = (TypeReference)reader.LookupToken(ReadToken());
+                    break;
+                case ExceptionHandlerType.Filter:
+                    handler.FilterStart = GetInstruction(ReadInt32());
+                    break;
+                default:
+                    Advance(4);
+                    break;
+            }
+        }
+
+        public MetadataToken ReadToken()
+        {
+            return new(ReadUInt32());
+        }
+
+        private void ReadDebugInfo()
+        {
+            if (method.debug_info.sequence_points != null)
+                ReadSequencePoints();
+
+            if (method.debug_info.scope != null)
+                ReadScope(method.debug_info.scope);
+
+            if (method.custom_infos != null)
+                ReadCustomDebugInformations(method);
+        }
+
+        private void ReadCustomDebugInformations(MethodDefinition method)
+        {
+            Collection<CustomDebugInformation> custom_infos = method.custom_infos;
+
+            for (int i = 0; i < custom_infos.Count; i++)
+            {
+                StateMachineScopeDebugInformation state_machine_scope = custom_infos[i] as StateMachineScopeDebugInformation;
+                if (state_machine_scope != null)
+                    ReadStateMachineScope(state_machine_scope);
+
+                AsyncMethodBodyDebugInformation async_method = custom_infos[i] as AsyncMethodBodyDebugInformation;
+                if (async_method != null)
+                    ReadAsyncMethodBody(async_method);
+            }
+        }
+
+        private void ReadAsyncMethodBody(AsyncMethodBodyDebugInformation async_method)
+        {
+            if (async_method.catch_handler.Offset > -1)
+                async_method.catch_handler = new(GetInstruction(async_method.catch_handler.Offset));
+
+            if (!async_method.yields.IsNullOrEmpty())
+                for (int i = 0; i < async_method.yields.Count; i++)
+                    async_method.yields[i] = new(GetInstruction(async_method.yields[i].Offset));
+
+            if (!async_method.resumes.IsNullOrEmpty())
+                for (int i = 0; i < async_method.resumes.Count; i++)
+                    async_method.resumes[i] = new(GetInstruction(async_method.resumes[i].Offset));
+        }
+
+        private void ReadStateMachineScope(StateMachineScopeDebugInformation state_machine_scope)
+        {
+            if (state_machine_scope.scopes.IsNullOrEmpty())
+                return;
+
+            foreach (StateMachineScope scope in state_machine_scope.scopes)
+            {
+                scope.start = new(GetInstruction(scope.start.Offset));
+
+                Instruction end_instruction = GetInstruction(scope.end.Offset);
+                scope.end = end_instruction == null ? new() : new InstructionOffset(end_instruction);
+            }
+        }
+
+        private void ReadSequencePoints()
+        {
+            MethodDebugInformation symbol = method.debug_info;
+
+            for (int i = 0; i < symbol.sequence_points.Count; i++)
+            {
+                SequencePoint sequence_point = symbol.sequence_points[i];
+                Instruction instruction = GetInstruction(sequence_point.Offset);
+                if (instruction != null)
+                    sequence_point.offset = new(instruction);
+            }
+        }
+
+        private void ReadScopes(Collection<ScopeDebugInformation> scopes)
+        {
+            for (int i = 0; i < scopes.Count; i++)
+                ReadScope(scopes[i]);
+        }
+
+        private void ReadScope(ScopeDebugInformation scope)
+        {
+            Instruction start_instruction = GetInstruction(scope.Start.Offset);
+            if (start_instruction != null)
+                scope.Start = new(start_instruction);
+
+            Instruction end_instruction = GetInstruction(scope.End.Offset);
+            scope.End = end_instruction != null ? new(end_instruction) : new InstructionOffset();
+
+            if (!scope.variables.IsNullOrEmpty())
+            {
+                for (int i = 0; i < scope.variables.Count; i++)
+                {
+                    VariableDebugInformation variable_info = scope.variables[i];
+                    VariableDefinition variable = GetVariable(variable_info.Index);
+                    if (variable != null)
+                        variable_info.index = new(variable);
+                }
+            }
+
+            if (!scope.scopes.IsNullOrEmpty())
+                ReadScopes(scope.scopes);
+        }
+
+        public ByteBuffer PatchRawMethodBody(MethodDefinition method, CodeWriter writer, out int code_size, out MetadataToken local_var_token)
+        {
+            int position = MoveTo(method);
+
+            ByteBuffer buffer = new();
+
+            byte flags = ReadByte();
+
+            switch (flags & 0x3)
+            {
+                case 0x2: // tiny
+                    buffer.WriteByte(flags);
+                    local_var_token = MetadataToken.Zero;
+                    code_size = flags >> 2;
+                    PatchRawCode(buffer, code_size, writer);
+                    break;
+                case 0x3: // fat
+                    Advance(-1);
+                    PatchRawFatMethod(buffer, writer, out code_size, out local_var_token);
+                    break;
+                default:
+                    throw new NotSupportedException();
+            }
+
+            MoveBackTo(position);
+
+            return buffer;
+        }
+
+        private void PatchRawFatMethod(ByteBuffer buffer, CodeWriter writer, out int code_size, out MetadataToken local_var_token)
+        {
+            ushort flags = ReadUInt16();
+            buffer.WriteUInt16(flags);
+            buffer.WriteUInt16(ReadUInt16());
+            code_size = ReadInt32();
+            buffer.WriteInt32(code_size);
+            local_var_token = ReadToken();
+
+            if (local_var_token.RID > 0)
+            {
+                VariableDefinitionCollection variables = ReadVariables(local_var_token);
+                buffer.WriteUInt32(variables != null ? writer.GetStandAloneSignature(variables).ToUInt32() : 0);
+            }
+            else
+            {
+                buffer.WriteUInt32(0);
+            }
+
+            PatchRawCode(buffer, code_size, writer);
+
+            if ((flags & 0x8) != 0)
+                PatchRawSection(buffer, writer.metadata);
+        }
+
+        private void PatchRawCode(ByteBuffer buffer, int code_size, CodeWriter writer)
+        {
+            MetadataBuilder metadata = writer.metadata;
+            buffer.WriteBytes(ReadBytes(code_size));
+            int end = buffer.position;
+            buffer.position -= code_size;
+
+            while (buffer.position < end)
+            {
+                OpCode opcode;
+                byte il_opcode = buffer.ReadByte();
+                if (il_opcode != 0xfe)
+                {
+                    opcode = OpCodes.OneByteOpCode[il_opcode];
+                }
+                else
+                {
+                    byte il_opcode2 = buffer.ReadByte();
+                    opcode = OpCodes.TwoBytesOpCode[il_opcode2];
+                }
+
+                switch (opcode.OperandType)
+                {
+                    case OperandType.ShortInlineI:
+                    case OperandType.ShortInlineBrTarget:
+                    case OperandType.ShortInlineVar:
+                    case OperandType.ShortInlineArg:
+                        buffer.position += 1;
+                        break;
+                    case OperandType.InlineVar:
+                    case OperandType.InlineArg:
+                        buffer.position += 2;
+                        break;
+                    case OperandType.InlineBrTarget:
+                    case OperandType.ShortInlineR:
+                    case OperandType.InlineI:
+                        buffer.position += 4;
+                        break;
+                    case OperandType.InlineI8:
+                    case OperandType.InlineR:
+                        buffer.position += 8;
+                        break;
+                    case OperandType.InlineSwitch:
+                        int length = buffer.ReadInt32();
+                        buffer.position += length * 4;
+                        break;
+                    case OperandType.InlineString:
+                        string @string = GetString(new(buffer.ReadUInt32()));
+                        buffer.position -= 4;
+                        buffer.WriteUInt32(new MetadataToken(TokenType.String, metadata.user_string_heap.GetStringIndex(@string)).ToUInt32());
+                        break;
+                    case OperandType.InlineSig:
+                        CallSite call_site = GetCallSite(new(buffer.ReadUInt32()));
+                        buffer.position -= 4;
+                        buffer.WriteUInt32(writer.GetStandAloneSignature(call_site).ToUInt32());
+                        break;
+                    case OperandType.InlineTok:
+                    case OperandType.InlineType:
+                    case OperandType.InlineMethod:
+                    case OperandType.InlineField:
+                        IMetadataTokenProvider provider = reader.LookupToken(new(buffer.ReadUInt32()));
+                        buffer.position -= 4;
+                        buffer.WriteUInt32(metadata.LookupToken(provider).ToUInt32());
+                        break;
+                }
+            }
+        }
+
+        private void PatchRawSection(ByteBuffer buffer, MetadataBuilder metadata)
+        {
+            int position = Position;
+            Align(4);
+            buffer.WriteBytes(Position - position);
+
+            const byte fat_format = 0x40;
+            const byte more_sects = 0x80;
+
+            byte flags = ReadByte();
+            if ((flags & fat_format) == 0)
+            {
+                buffer.WriteByte(flags);
+                PatchRawSmallSection(buffer, metadata);
+            }
+            else
+            {
+                PatchRawFatSection(buffer, metadata);
+            }
+
+            if ((flags & more_sects) != 0)
+                PatchRawSection(buffer, metadata);
+        }
+
+        private void PatchRawSmallSection(ByteBuffer buffer, MetadataBuilder metadata)
+        {
+            byte length = ReadByte();
+            buffer.WriteByte(length);
+            Advance(2);
+
+            buffer.WriteUInt16(0);
+
+            int count = length / 12;
+
+            PatchRawExceptionHandlers(buffer, metadata, count, false);
+        }
+
+        private void PatchRawFatSection(ByteBuffer buffer, MetadataBuilder metadata)
+        {
+            Advance(-1);
+            int length = ReadInt32();
+            buffer.WriteInt32(length);
+
+            int count = (length >> 8) / 24;
+
+            PatchRawExceptionHandlers(buffer, metadata, count, true);
+        }
+
+        private void PatchRawExceptionHandlers(ByteBuffer buffer, MetadataBuilder metadata, int count, bool fat_entry)
+        {
+            const int fat_entry_size = 16;
+            const int small_entry_size = 6;
+
+            for (int i = 0; i < count; i++)
+            {
+                ExceptionHandlerType handler_type;
+                if (fat_entry)
+                {
+                    uint type = ReadUInt32();
+                    handler_type = (ExceptionHandlerType)(type & 0x7);
+                    buffer.WriteUInt32(type);
+                }
+                else
+                {
+                    ushort type = ReadUInt16();
+                    handler_type = (ExceptionHandlerType)(type & 0x7);
+                    buffer.WriteUInt16(type);
+                }
+
+                buffer.WriteBytes(ReadBytes(fat_entry ? fat_entry_size : small_entry_size));
+
+                switch (handler_type)
+                {
+                    case ExceptionHandlerType.Catch:
+                        IMetadataTokenProvider exception = reader.LookupToken(ReadToken());
+                        buffer.WriteUInt32(metadata.LookupToken(exception).ToUInt32());
+                        break;
+                    default:
+                        buffer.WriteUInt32(ReadUInt32());
+                        break;
+                }
+            }
+        }
+    }
+}

Assets/FishNet/CodeGenerating/cecil-0.11.4/Mono.Cecil.Cil/CodeReader.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 451f6a2407c53554f9a16eeb62d806ce
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/CodeGenerating/cecil-0.11.4/Mono.Cecil.Cil/CodeReader.cs
+  uploadId: 866910

Assets/FishNet/CodeGenerating/cecil-0.11.4/Mono.Cecil.Cil/CodeWriter.cs

@@ -0,0 +1,668 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using MonoFN.Cecil.Metadata;
+using MonoFN.Cecil.PE;
+using MonoFN.Collections.Generic;
+using System;
+using System.Collections.Generic;
+using RVA = System.UInt32;
+
+namespace MonoFN.Cecil.Cil
+{
+    internal sealed class CodeWriter : ByteBuffer
+    {
+        private readonly RVA code_base;
+        internal readonly MetadataBuilder metadata;
+        private readonly Dictionary<uint, MetadataToken> standalone_signatures;
+        private readonly Dictionary<ByteBuffer, RVA> tiny_method_bodies;
+        private MethodBody body;
+
+        public CodeWriter(MetadataBuilder metadata) : base(0)
+        {
+            code_base = metadata.text_map.GetNextRVA(TextSegment.CLIHeader);
+            this.metadata = metadata;
+            standalone_signatures = new();
+            tiny_method_bodies = new(new ByteBufferEqualityComparer());
+        }
+
+        public RVA WriteMethodBody(MethodDefinition method)
+        {
+            RVA rva;
+
+            if (IsUnresolved(method))
+            {
+                if (method.rva == 0)
+                    return 0;
+
+                rva = WriteUnresolvedMethodBody(method);
+            }
+            else
+            {
+                if (IsEmptyMethodBody(method.Body))
+                    return 0;
+
+                rva = WriteResolvedMethodBody(method);
+            }
+
+            return rva;
+        }
+
+        private static bool IsEmptyMethodBody(MethodBody body)
+        {
+            return body.instructions.IsNullOrEmpty() && body.variables.IsNullOrEmpty();
+        }
+
+        private static bool IsUnresolved(MethodDefinition method)
+        {
+            return method.HasBody && method.HasImage && method.body == null;
+        }
+
+        private RVA WriteUnresolvedMethodBody(MethodDefinition method)
+        {
+            CodeReader code_reader = metadata.module.reader.code;
+
+            int code_size;
+            MetadataToken local_var_token;
+            ByteBuffer raw_body = code_reader.PatchRawMethodBody(method, this, out code_size, out local_var_token);
+            bool fat_header = (raw_body.buffer[0] & 0x3) == 0x3;
+            if (fat_header)
+                Align(4);
+
+            RVA rva = BeginMethod();
+
+            if (fat_header || !GetOrMapTinyMethodBody(raw_body, ref rva))
+            {
+                WriteBytes(raw_body);
+            }
+
+            if (method.debug_info == null)
+                return rva;
+
+            ISymbolWriter symbol_writer = metadata.symbol_writer;
+            if (symbol_writer != null)
+            {
+                method.debug_info.code_size = code_size;
+                method.debug_info.local_var_token = local_var_token;
+                symbol_writer.Write(method.debug_info);
+            }
+
+            return rva;
+        }
+
+        private RVA WriteResolvedMethodBody(MethodDefinition method)
+        {
+            RVA rva;
+
+            body = method.Body;
+            ComputeHeader();
+            if (RequiresFatHeader())
+            {
+                Align(4);
+                rva = BeginMethod();
+                WriteFatHeader();
+                WriteInstructions();
+
+                if (body.HasExceptionHandlers)
+                    WriteExceptionHandlers();
+            }
+            else
+            {
+                rva = BeginMethod();
+                WriteByte((byte)(0x2 | (body.CodeSize << 2))); // tiny
+                WriteInstructions();
+
+                int start_position = (int)(rva - code_base);
+                int body_size = position - start_position;
+                byte[] body_bytes = new byte [body_size];
+
+                Array.Copy(buffer, start_position, body_bytes, 0, body_size);
+
+                if (GetOrMapTinyMethodBody(new(body_bytes), ref rva))
+                    position = start_position;
+            }
+
+            ISymbolWriter symbol_writer = metadata.symbol_writer;
+            if (symbol_writer != null && method.debug_info != null)
+            {
+                method.debug_info.code_size = body.CodeSize;
+                method.debug_info.local_var_token = body.local_var_token;
+                symbol_writer.Write(method.debug_info);
+            }
+
+            return rva;
+        }
+
+        private bool GetOrMapTinyMethodBody(ByteBuffer body, ref RVA rva)
+        {
+            RVA existing_rva;
+            if (tiny_method_bodies.TryGetValue(body, out existing_rva))
+            {
+                rva = existing_rva;
+                return true;
+            }
+
+            tiny_method_bodies.Add(body, rva);
+            return false;
+        }
+
+        private void WriteFatHeader()
+        {
+            MethodBody body = this.body;
+            byte flags = 0x3; // fat
+            if (body.InitLocals)
+                flags |= 0x10; // init locals
+            if (body.HasExceptionHandlers)
+                flags |= 0x8; // more sections
+
+            WriteByte(flags);
+            WriteByte(0x30);
+            WriteInt16((short)body.max_stack_size);
+            WriteInt32(body.code_size);
+            body.local_var_token = body.HasVariables ? GetStandAloneSignature(body.Variables) : MetadataToken.Zero;
+            WriteMetadataToken(body.local_var_token);
+        }
+
+        private void WriteInstructions()
+        {
+            Collection<Instruction> instructions = body.Instructions;
+            Instruction[] items = instructions.items;
+            int size = instructions.size;
+
+            for (int i = 0; i < size; i++)
+            {
+                Instruction instruction = items[i];
+                WriteOpCode(instruction.opcode);
+                WriteOperand(instruction);
+            }
+        }
+
+        private void WriteOpCode(OpCode opcode)
+        {
+            if (opcode.Size == 1)
+            {
+                WriteByte(opcode.Op2);
+            }
+            else
+            {
+                WriteByte(opcode.Op1);
+                WriteByte(opcode.Op2);
+            }
+        }
+
+        private void WriteOperand(Instruction instruction)
+        {
+            OpCode opcode = instruction.opcode;
+            OperandType operand_type = opcode.OperandType;
+            if (operand_type == OperandType.InlineNone)
+                return;
+
+            object operand = instruction.operand;
+            if (operand == null && !(operand_type == OperandType.InlineBrTarget || operand_type == OperandType.ShortInlineBrTarget))
+            {
+                throw new ArgumentException();
+            }
+
+            switch (operand_type)
+            {
+                case OperandType.InlineSwitch:
+                {
+                    Instruction[] targets = (Instruction[])operand;
+                    WriteInt32(targets.Length);
+                    int diff = instruction.Offset + opcode.Size + 4 * (targets.Length + 1);
+                    for (int i = 0; i < targets.Length; i++)
+                        WriteInt32(GetTargetOffset(targets[i]) - diff);
+                    break;
+                }
+                case OperandType.ShortInlineBrTarget:
+                {
+                    Instruction target = (Instruction)operand;
+                    int offset = target != null ? GetTargetOffset(target) : body.code_size;
+                    WriteSByte((sbyte)(offset - (instruction.Offset + opcode.Size + 1)));
+                    break;
+                }
+                case OperandType.InlineBrTarget:
+                {
+                    Instruction target = (Instruction)operand;
+                    int offset = target != null ? GetTargetOffset(target) : body.code_size;
+                    WriteInt32(offset - (instruction.Offset + opcode.Size + 4));
+                    break;
+                }
+                case OperandType.ShortInlineVar:
+                    WriteByte((byte)GetVariableIndex((VariableDefinition)operand));
+                    break;
+                case OperandType.ShortInlineArg:
+                    WriteByte((byte)GetParameterIndex((ParameterDefinition)operand));
+                    break;
+                case OperandType.InlineVar:
+                    WriteInt16((short)GetVariableIndex((VariableDefinition)operand));
+                    break;
+                case OperandType.InlineArg:
+                    WriteInt16((short)GetParameterIndex((ParameterDefinition)operand));
+                    break;
+                case OperandType.InlineSig:
+                    WriteMetadataToken(GetStandAloneSignature((CallSite)operand));
+                    break;
+                case OperandType.ShortInlineI:
+                    if (opcode == OpCodes.Ldc_I4_S)
+                        WriteSByte((sbyte)operand);
+                    else
+                        WriteByte((byte)operand);
+                    break;
+                case OperandType.InlineI:
+                    WriteInt32((int)operand);
+                    break;
+                case OperandType.InlineI8:
+                    WriteInt64((long)operand);
+                    break;
+                case OperandType.ShortInlineR:
+                    WriteSingle((float)operand);
+                    break;
+                case OperandType.InlineR:
+                    WriteDouble((double)operand);
+                    break;
+                case OperandType.InlineString:
+                    WriteMetadataToken(new(TokenType.String, GetUserStringIndex((string)operand)));
+                    break;
+                case OperandType.InlineType:
+                case OperandType.InlineField:
+                case OperandType.InlineMethod:
+                case OperandType.InlineTok:
+                    WriteMetadataToken(metadata.LookupToken((IMetadataTokenProvider)operand));
+                    break;
+                default:
+                    throw new ArgumentException();
+            }
+        }
+
+        private int GetTargetOffset(Instruction instruction)
+        {
+            if (instruction == null)
+            {
+                Instruction last = body.instructions[body.instructions.size - 1];
+                return last.offset + last.GetSize();
+            }
+
+            return instruction.offset;
+        }
+
+        private uint GetUserStringIndex(string @string)
+        {
+            if (@string == null)
+                return 0;
+
+            return metadata.user_string_heap.GetStringIndex(@string);
+        }
+
+        private static int GetVariableIndex(VariableDefinition variable)
+        {
+            return variable.Index;
+        }
+
+        private int GetParameterIndex(ParameterDefinition parameter)
+        {
+            if (body.method.HasThis)
+            {
+                if (parameter == body.this_parameter)
+                    return 0;
+
+                return parameter.Index + 1;
+            }
+
+            return parameter.Index;
+        }
+
+        private bool RequiresFatHeader()
+        {
+            MethodBody body = this.body;
+            return body.CodeSize >= 64 || body.InitLocals || body.HasVariables || body.HasExceptionHandlers || body.MaxStackSize > 8;
+        }
+
+        private void ComputeHeader()
+        {
+            int offset = 0;
+            Collection<Instruction> instructions = body.instructions;
+            Instruction[] items = instructions.items;
+            int count = instructions.size;
+            int stack_size = 0;
+            int max_stack = 0;
+            Dictionary<Instruction, int> stack_sizes = null;
+
+            if (body.HasExceptionHandlers)
+                ComputeExceptionHandlerStackSize(ref stack_sizes);
+
+            for (int i = 0; i < count; i++)
+            {
+                Instruction instruction = items[i];
+                instruction.offset = offset;
+                offset += instruction.GetSize();
+
+                ComputeStackSize(instruction, ref stack_sizes, ref stack_size, ref max_stack);
+            }
+
+            body.code_size = offset;
+            body.max_stack_size = max_stack;
+        }
+
+        private void ComputeExceptionHandlerStackSize(ref Dictionary<Instruction, int> stack_sizes)
+        {
+            Collection<ExceptionHandler> exception_handlers = body.ExceptionHandlers;
+
+            for (int i = 0; i < exception_handlers.Count; i++)
+            {
+                ExceptionHandler exception_handler = exception_handlers[i];
+
+                switch (exception_handler.HandlerType)
+                {
+                    case ExceptionHandlerType.Catch:
+                        AddExceptionStackSize(exception_handler.HandlerStart, ref stack_sizes);
+                        break;
+                    case ExceptionHandlerType.Filter:
+                        AddExceptionStackSize(exception_handler.FilterStart, ref stack_sizes);
+                        AddExceptionStackSize(exception_handler.HandlerStart, ref stack_sizes);
+                        break;
+                }
+            }
+        }
+
+        private static void AddExceptionStackSize(Instruction handler_start, ref Dictionary<Instruction, int> stack_sizes)
+        {
+            if (handler_start == null)
+                return;
+
+            if (stack_sizes == null)
+                stack_sizes = new();
+
+            stack_sizes[handler_start] = 1;
+        }
+
+        private static void ComputeStackSize(Instruction instruction, ref Dictionary<Instruction, int> stack_sizes, ref int stack_size, ref int max_stack)
+        {
+            int computed_size;
+            if (stack_sizes != null && stack_sizes.TryGetValue(instruction, out computed_size))
+                stack_size = computed_size;
+
+            max_stack = Math.Max(max_stack, stack_size);
+            ComputeStackDelta(instruction, ref stack_size);
+            max_stack = Math.Max(max_stack, stack_size);
+
+            CopyBranchStackSize(instruction, ref stack_sizes, stack_size);
+            ComputeStackSize(instruction, ref stack_size);
+        }
+
+        private static void CopyBranchStackSize(Instruction instruction, ref Dictionary<Instruction, int> stack_sizes, int stack_size)
+        {
+            if (stack_size == 0)
+                return;
+
+            switch (instruction.opcode.OperandType)
+            {
+                case OperandType.ShortInlineBrTarget:
+                case OperandType.InlineBrTarget:
+                    CopyBranchStackSize(ref stack_sizes, (Instruction)instruction.operand, stack_size);
+                    break;
+                case OperandType.InlineSwitch:
+                    Instruction[] targets = (Instruction[])instruction.operand;
+                    for (int i = 0; i < targets.Length; i++)
+                        CopyBranchStackSize(ref stack_sizes, targets[i], stack_size);
+                    break;
+            }
+        }
+
+        private static void CopyBranchStackSize(ref Dictionary<Instruction, int> stack_sizes, Instruction target, int stack_size)
+        {
+            if (stack_sizes == null)
+                stack_sizes = new();
+
+            int branch_stack_size = stack_size;
+
+            int computed_size;
+            if (stack_sizes.TryGetValue(target, out computed_size))
+                branch_stack_size = Math.Max(branch_stack_size, computed_size);
+
+            stack_sizes[target] = branch_stack_size;
+        }
+
+        private static void ComputeStackSize(Instruction instruction, ref int stack_size)
+        {
+            switch (instruction.opcode.FlowControl)
+            {
+                case FlowControl.Branch:
+                case FlowControl.Throw:
+                case FlowControl.Return:
+                    stack_size = 0;
+                    break;
+            }
+        }
+
+        private static void ComputeStackDelta(Instruction instruction, ref int stack_size)
+        {
+            switch (instruction.opcode.FlowControl)
+            {
+                case FlowControl.Call:
+                {
+                    IMethodSignature method = (IMethodSignature)instruction.operand;
+                    // pop 'this' argument
+                    if (method.HasImplicitThis() && instruction.opcode.Code != Code.Newobj)
+                        stack_size--;
+                    // pop normal arguments
+                    if (method.HasParameters)
+                        stack_size -= method.Parameters.Count;
+                    // pop function pointer
+                    if (instruction.opcode.Code == Code.Calli)
+                        stack_size--;
+                    // push return value
+                    if (method.ReturnType.etype != ElementType.Void || instruction.opcode.Code == Code.Newobj)
+                        stack_size++;
+                    break;
+                }
+                default:
+                    ComputePopDelta(instruction.opcode.StackBehaviourPop, ref stack_size);
+                    ComputePushDelta(instruction.opcode.StackBehaviourPush, ref stack_size);
+                    break;
+            }
+        }
+
+        private static void ComputePopDelta(StackBehaviour pop_behavior, ref int stack_size)
+        {
+            switch (pop_behavior)
+            {
+                case StackBehaviour.Popi:
+                case StackBehaviour.Popref:
+                case StackBehaviour.Pop1:
+                    stack_size--;
+                    break;
+                case StackBehaviour.Pop1_pop1:
+                case StackBehaviour.Popi_pop1:
+                case StackBehaviour.Popi_popi:
+                case StackBehaviour.Popi_popi8:
+                case StackBehaviour.Popi_popr4:
+                case StackBehaviour.Popi_popr8:
+                case StackBehaviour.Popref_pop1:
+                case StackBehaviour.Popref_popi:
+                    stack_size -= 2;
+                    break;
+                case StackBehaviour.Popi_popi_popi:
+                case StackBehaviour.Popref_popi_popi:
+                case StackBehaviour.Popref_popi_popi8:
+                case StackBehaviour.Popref_popi_popr4:
+                case StackBehaviour.Popref_popi_popr8:
+                case StackBehaviour.Popref_popi_popref:
+                    stack_size -= 3;
+                    break;
+                case StackBehaviour.PopAll:
+                    stack_size = 0;
+                    break;
+            }
+        }
+
+        private static void ComputePushDelta(StackBehaviour push_behaviour, ref int stack_size)
+        {
+            switch (push_behaviour)
+            {
+                case StackBehaviour.Push1:
+                case StackBehaviour.Pushi:
+                case StackBehaviour.Pushi8:
+                case StackBehaviour.Pushr4:
+                case StackBehaviour.Pushr8:
+                case StackBehaviour.Pushref:
+                    stack_size++;
+                    break;
+                case StackBehaviour.Push1_push1:
+                    stack_size += 2;
+                    break;
+            }
+        }
+
+        private void WriteExceptionHandlers()
+        {
+            Align(4);
+
+            Collection<ExceptionHandler> handlers = body.ExceptionHandlers;
+
+            if (handlers.Count < 0x15 && !RequiresFatSection(handlers))
+                WriteSmallSection(handlers);
+            else
+                WriteFatSection(handlers);
+        }
+
+        private static bool RequiresFatSection(Collection<ExceptionHandler> handlers)
+        {
+            for (int i = 0; i < handlers.Count; i++)
+            {
+                ExceptionHandler handler = handlers[i];
+
+                if (IsFatRange(handler.TryStart, handler.TryEnd))
+                    return true;
+
+                if (IsFatRange(handler.HandlerStart, handler.HandlerEnd))
+                    return true;
+
+                if (handler.HandlerType == ExceptionHandlerType.Filter && IsFatRange(handler.FilterStart, handler.HandlerStart))
+                    return true;
+            }
+
+            return false;
+        }
+
+        private static bool IsFatRange(Instruction start, Instruction end)
+        {
+            if (start == null)
+                throw new ArgumentException();
+
+            if (end == null)
+                return true;
+
+            return end.Offset - start.Offset > 255 || start.Offset > 65535;
+        }
+
+        private void WriteSmallSection(Collection<ExceptionHandler> handlers)
+        {
+            const byte eh_table = 0x1;
+
+            WriteByte(eh_table);
+            WriteByte((byte)(handlers.Count * 12 + 4));
+            WriteBytes(2);
+
+            WriteExceptionHandlers(handlers, i => WriteUInt16((ushort)i), i => WriteByte((byte)i));
+        }
+
+        private void WriteFatSection(Collection<ExceptionHandler> handlers)
+        {
+            const byte eh_table = 0x1;
+            const byte fat_format = 0x40;
+
+            WriteByte(eh_table | fat_format);
+
+            int size = handlers.Count * 24 + 4;
+            WriteByte((byte)(size & 0xff));
+            WriteByte((byte)((size >> 8) & 0xff));
+            WriteByte((byte)((size >> 16) & 0xff));
+
+            WriteExceptionHandlers(handlers, WriteInt32, WriteInt32);
+        }
+
+        private void WriteExceptionHandlers(Collection<ExceptionHandler> handlers, Action<int> write_entry, Action<int> write_length)
+        {
+            for (int i = 0; i < handlers.Count; i++)
+            {
+                ExceptionHandler handler = handlers[i];
+
+                write_entry((int)handler.HandlerType);
+
+                write_entry(handler.TryStart.Offset);
+                write_length(GetTargetOffset(handler.TryEnd) - handler.TryStart.Offset);
+
+                write_entry(handler.HandlerStart.Offset);
+                write_length(GetTargetOffset(handler.HandlerEnd) - handler.HandlerStart.Offset);
+
+                WriteExceptionHandlerSpecific(handler);
+            }
+        }
+
+        private void WriteExceptionHandlerSpecific(ExceptionHandler handler)
+        {
+            switch (handler.HandlerType)
+            {
+                case ExceptionHandlerType.Catch:
+                    WriteMetadataToken(metadata.LookupToken(handler.CatchType));
+                    break;
+                case ExceptionHandlerType.Filter:
+                    WriteInt32(handler.FilterStart.Offset);
+                    break;
+                default:
+                    WriteInt32(0);
+                    break;
+            }
+        }
+
+        public MetadataToken GetStandAloneSignature(Collection<VariableDefinition> variables)
+        {
+            uint signature = metadata.GetLocalVariableBlobIndex(variables);
+
+            return GetStandAloneSignatureToken(signature);
+        }
+
+        public MetadataToken GetStandAloneSignature(CallSite call_site)
+        {
+            uint signature = metadata.GetCallSiteBlobIndex(call_site);
+            MetadataToken token = GetStandAloneSignatureToken(signature);
+            call_site.MetadataToken = token;
+            return token;
+        }
+
+        private MetadataToken GetStandAloneSignatureToken(uint signature)
+        {
+            MetadataToken token;
+            if (standalone_signatures.TryGetValue(signature, out token))
+                return token;
+
+            token = new(TokenType.Signature, metadata.AddStandAloneSignature(signature));
+            standalone_signatures.Add(signature, token);
+            return token;
+        }
+
+        private RVA BeginMethod()
+        {
+            return (RVA)(code_base + position);
+        }
+
+        private void WriteMetadataToken(MetadataToken token)
+        {
+            WriteUInt32(token.ToUInt32());
+        }
+
+        private void Align(int align)
+        {
+            align--;
+            WriteBytes(((position + align) & ~align) - position);
+        }
+    }
+}

Assets/FishNet/CodeGenerating/cecil-0.11.4/Mono.Cecil.Cil/CodeWriter.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 278f89c983a1bc6429c65a1d49dff091
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/CodeGenerating/cecil-0.11.4/Mono.Cecil.Cil/CodeWriter.cs
+  uploadId: 866910

Assets/FishNet/CodeGenerating/cecil-0.11.4/Mono.Cecil.Cil/Document.cs

@@ -0,0 +1,90 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+namespace MonoFN.Cecil.Cil
+{
+    public enum DocumentType
+    {
+        Other,
+        Text
+    }
+
+    public enum DocumentHashAlgorithm
+    {
+        None,
+        MD5,
+        SHA1,
+        SHA256
+    }
+
+    public enum DocumentLanguage
+    {
+        Other,
+        C,
+        Cpp,
+        CSharp,
+        Basic,
+        Java,
+        Cobol,
+        Pascal,
+        Cil,
+        JScript,
+        Smc,
+        MCpp,
+        FSharp
+    }
+
+    public enum DocumentLanguageVendor
+    {
+        Other,
+        Microsoft
+    }
+
+    public sealed class Document : DebugInformation
+    {
+        public string Url { get; set; }
+        public DocumentType Type
+        {
+            get { return TypeGuid.ToType(); }
+            set { TypeGuid = value.ToGuid(); }
+        }
+        public Guid TypeGuid { get; set; }
+        public DocumentHashAlgorithm HashAlgorithm
+        {
+            get { return HashAlgorithmGuid.ToHashAlgorithm(); }
+            set { HashAlgorithmGuid = value.ToGuid(); }
+        }
+        public Guid HashAlgorithmGuid { get; set; }
+        public DocumentLanguage Language
+        {
+            get { return LanguageGuid.ToLanguage(); }
+            set { LanguageGuid = value.ToGuid(); }
+        }
+        public Guid LanguageGuid { get; set; }
+        public DocumentLanguageVendor LanguageVendor
+        {
+            get { return LanguageVendorGuid.ToVendor(); }
+            set { LanguageVendorGuid = value.ToGuid(); }
+        }
+        public Guid LanguageVendorGuid { get; set; }
+        public byte[] Hash { get; set; }
+        public byte[] EmbeddedSource { get; set; }
+
+        public Document(string url)
+        {
+            this.Url = url;
+            Hash = Empty<byte>.Array;
+            EmbeddedSource = Empty<byte>.Array;
+            token = new(TokenType.Document);
+        }
+    }
+}

Assets/FishNet/CodeGenerating/cecil-0.11.4/Mono.Cecil.Cil/Document.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 86b3083301304a341b6059ea8c29be7a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/CodeGenerating/cecil-0.11.4/Mono.Cecil.Cil/Document.cs
+  uploadId: 866910

Assets/FishNet/CodeGenerating/cecil-0.11.4/Mono.Cecil.Cil/ExceptionHandler.cs

@@ -0,0 +1,36 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+namespace MonoFN.Cecil.Cil
+{
+    public enum ExceptionHandlerType
+    {
+        Catch = 0,
+        Filter = 1,
+        Finally = 2,
+        Fault = 4
+    }
+
+    public sealed class ExceptionHandler
+    {
+        public Instruction TryStart { get; set; }
+        public Instruction TryEnd { get; set; }
+        public Instruction FilterStart { get; set; }
+        public Instruction HandlerStart { get; set; }
+        public Instruction HandlerEnd { get; set; }
+        public TypeReference CatchType { get; set; }
+        public ExceptionHandlerType HandlerType { get; set; }
+
+        public ExceptionHandler(ExceptionHandlerType handlerType)
+        {
+            HandlerType = handlerType;
+        }
+    }
+}

Assets/FishNet/CodeGenerating/cecil-0.11.4/Mono.Cecil.Cil/ExceptionHandler.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: eb17bcae1a67ec344b65d6ed78ffb704
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/CodeGenerating/cecil-0.11.4/Mono.Cecil.Cil/ExceptionHandler.cs
+  uploadId: 866910

Assets/FishNet/CodeGenerating/cecil-0.11.4/Mono.Cecil.Cil/ILProcessor.cs

@@ -0,0 +1,287 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using MonoFN.Collections.Generic;
+using System;
+
+namespace MonoFN.Cecil.Cil
+{
+    public sealed class ILProcessor
+    {
+        private readonly Collection<Instruction> instructions;
+        public MethodBody Body { get; }
+
+        internal ILProcessor(MethodBody body)
+        {
+            this.Body = body;
+            instructions = body.Instructions;
+        }
+
+        public Instruction Create(OpCode opcode)
+        {
+            return Instruction.Create(opcode);
+        }
+
+        public Instruction Create(OpCode opcode, TypeReference type)
+        {
+            return Instruction.Create(opcode, type);
+        }
+
+        public Instruction Create(OpCode opcode, CallSite site)
+        {
+            return Instruction.Create(opcode, site);
+        }
+
+        public Instruction Create(OpCode opcode, MethodReference method)
+        {
+            return Instruction.Create(opcode, method);
+        }
+
+        public Instruction Create(OpCode opcode, FieldReference field)
+        {
+            return Instruction.Create(opcode, field);
+        }
+
+        public Instruction Create(OpCode opcode, string value)
+        {
+            return Instruction.Create(opcode, value);
+        }
+
+        public Instruction Create(OpCode opcode, sbyte value)
+        {
+            return Instruction.Create(opcode, value);
+        }
+
+        public Instruction Create(OpCode opcode, byte value)
+        {
+            if (opcode.OperandType == OperandType.ShortInlineVar)
+                return Instruction.Create(opcode, Body.Variables[value]);
+
+            if (opcode.OperandType == OperandType.ShortInlineArg)
+                return Instruction.Create(opcode, Body.GetParameter(value));
+
+            return Instruction.Create(opcode, value);
+        }
+
+        public Instruction Create(OpCode opcode, int value)
+        {
+            if (opcode.OperandType == OperandType.InlineVar)
+                return Instruction.Create(opcode, Body.Variables[value]);
+
+            if (opcode.OperandType == OperandType.InlineArg)
+                return Instruction.Create(opcode, Body.GetParameter(value));
+
+            return Instruction.Create(opcode, value);
+        }
+
+        public Instruction Create(OpCode opcode, long value)
+        {
+            return Instruction.Create(opcode, value);
+        }
+
+        public Instruction Create(OpCode opcode, float value)
+        {
+            return Instruction.Create(opcode, value);
+        }
+
+        public Instruction Create(OpCode opcode, double value)
+        {
+            return Instruction.Create(opcode, value);
+        }
+
+        public Instruction Create(OpCode opcode, Instruction target)
+        {
+            return Instruction.Create(opcode, target);
+        }
+
+        public Instruction Create(OpCode opcode, Instruction[] targets)
+        {
+            return Instruction.Create(opcode, targets);
+        }
+
+        public Instruction Create(OpCode opcode, VariableDefinition variable)
+        {
+            return Instruction.Create(opcode, variable);
+        }
+
+        public Instruction Create(OpCode opcode, ParameterDefinition parameter)
+        {
+            return Instruction.Create(opcode, parameter);
+        }
+
+        public void Emit(OpCode opcode)
+        {
+            Append(Create(opcode));
+        }
+
+        public void Emit(OpCode opcode, TypeReference type)
+        {
+            Append(Create(opcode, type));
+        }
+
+        public void Emit(OpCode opcode, MethodReference method)
+        {
+            Append(Create(opcode, method));
+        }
+
+        public void Emit(OpCode opcode, CallSite site)
+        {
+            Append(Create(opcode, site));
+        }
+
+        public void Emit(OpCode opcode, FieldReference field)
+        {
+            Append(Create(opcode, field));
+        }
+
+        public void Emit(OpCode opcode, string value)
+        {
+            Append(Create(opcode, value));
+        }
+
+        public void Emit(OpCode opcode, byte value)
+        {
+            Append(Create(opcode, value));
+        }
+
+        public void Emit(OpCode opcode, sbyte value)
+        {
+            Append(Create(opcode, value));
+        }
+
+        public void Emit(OpCode opcode, int value)
+        {
+            Append(Create(opcode, value));
+        }
+
+        public void Emit(OpCode opcode, long value)
+        {
+            Append(Create(opcode, value));
+        }
+
+        public void Emit(OpCode opcode, float value)
+        {
+            Append(Create(opcode, value));
+        }
+
+        public void Emit(OpCode opcode, double value)
+        {
+            Append(Create(opcode, value));
+        }
+
+        public void Emit(OpCode opcode, Instruction target)
+        {
+            Append(Create(opcode, target));
+        }
+
+        public void Emit(OpCode opcode, Instruction[] targets)
+        {
+            Append(Create(opcode, targets));
+        }
+
+        public void Emit(OpCode opcode, VariableDefinition variable)
+        {
+            Append(Create(opcode, variable));
+        }
+
+        public void Emit(OpCode opcode, ParameterDefinition parameter)
+        {
+            Append(Create(opcode, parameter));
+        }
+
+        public void InsertBefore(Instruction target, Instruction instruction)
+        {
+            if (target == null)
+                throw new ArgumentNullException("target");
+            if (instruction == null)
+                throw new ArgumentNullException("instruction");
+
+            int index = instructions.IndexOf(target);
+            if (index == -1)
+                throw new ArgumentOutOfRangeException("target");
+
+            instructions.Insert(index, instruction);
+        }
+
+        public void InsertAfter(Instruction target, Instruction instruction)
+        {
+            if (target == null)
+                throw new ArgumentNullException("target");
+            if (instruction == null)
+                throw new ArgumentNullException("instruction");
+
+            int index = instructions.IndexOf(target);
+            if (index == -1)
+                throw new ArgumentOutOfRangeException("target");
+
+            instructions.Insert(index + 1, instruction);
+        }
+
+        public void InsertAfter(int index, Instruction instruction)
+        {
+            if (index < 0 || index >= instructions.Count)
+                throw new ArgumentOutOfRangeException("index");
+            if (instruction == null)
+                throw new ArgumentNullException("instruction");
+
+            instructions.Insert(index + 1, instruction);
+        }
+
+        public void Append(Instruction instruction)
+        {
+            if (instruction == null)
+                throw new ArgumentNullException("instruction");
+
+            instructions.Add(instruction);
+        }
+
+        public void Replace(Instruction target, Instruction instruction)
+        {
+            if (target == null)
+                throw new ArgumentNullException("target");
+            if (instruction == null)
+                throw new ArgumentNullException("instruction");
+
+            InsertAfter(target, instruction);
+            Remove(target);
+        }
+
+        public void Replace(int index, Instruction instruction)
+        {
+            if (instruction == null)
+                throw new ArgumentNullException("instruction");
+
+            InsertAfter(index, instruction);
+            RemoveAt(index);
+        }
+
+        public void Remove(Instruction instruction)
+        {
+            if (instruction == null)
+                throw new ArgumentNullException("instruction");
+
+            if (!instructions.Remove(instruction))
+                throw new ArgumentOutOfRangeException("instruction");
+        }
+
+        public void RemoveAt(int index)
+        {
+            if (index < 0 || index >= instructions.Count)
+                throw new ArgumentOutOfRangeException("index");
+
+            instructions.RemoveAt(index);
+        }
+
+        public void Clear()
+        {
+            instructions.Clear();
+        }
+    }
+}

Assets/FishNet/CodeGenerating/cecil-0.11.4/Mono.Cecil.Cil/ILProcessor.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 26902ea42064c624d82727d9ef9a8f5e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/CodeGenerating/cecil-0.11.4/Mono.Cecil.Cil/ILProcessor.cs
+  uploadId: 866910

Assets/FishNet/CodeGenerating/cecil-0.11.4/Mono.Cecil.Cil/Instruction.cs

@@ -0,0 +1,290 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+using System.Text;
+
+namespace MonoFN.Cecil.Cil
+{
+    public sealed class Instruction
+    {
+        internal int offset;
+        internal OpCode opcode;
+        internal object operand;
+        internal Instruction previous;
+        internal Instruction next;
+        public int Offset
+        {
+            get { return offset; }
+            set { offset = value; }
+        }
+        public OpCode OpCode
+        {
+            get { return opcode; }
+            set { opcode = value; }
+        }
+        public object Operand
+        {
+            get { return operand; }
+            set { operand = value; }
+        }
+        public Instruction Previous
+        {
+            get { return previous; }
+            set { previous = value; }
+        }
+        public Instruction Next
+        {
+            get { return next; }
+            set { next = value; }
+        }
+
+        internal Instruction(int offset, OpCode opCode)
+        {
+            this.offset = offset;
+            opcode = opCode;
+        }
+
+        internal Instruction(OpCode opcode, object operand)
+        {
+            this.opcode = opcode;
+            this.operand = operand;
+        }
+
+        public int GetSize()
+        {
+            int size = opcode.Size;
+
+            switch (opcode.OperandType)
+            {
+                case OperandType.InlineSwitch:
+                    return size + (1 + ((Instruction[])operand).Length) * 4;
+                case OperandType.InlineI8:
+                case OperandType.InlineR:
+                    return size + 8;
+                case OperandType.InlineBrTarget:
+                case OperandType.InlineField:
+                case OperandType.InlineI:
+                case OperandType.InlineMethod:
+                case OperandType.InlineString:
+                case OperandType.InlineTok:
+                case OperandType.InlineType:
+                case OperandType.ShortInlineR:
+                case OperandType.InlineSig:
+                    return size + 4;
+                case OperandType.InlineArg:
+                case OperandType.InlineVar:
+                    return size + 2;
+                case OperandType.ShortInlineBrTarget:
+                case OperandType.ShortInlineI:
+                case OperandType.ShortInlineArg:
+                case OperandType.ShortInlineVar:
+                    return size + 1;
+                default:
+                    return size;
+            }
+        }
+
+        public override string ToString()
+        {
+            StringBuilder instruction = new();
+
+            AppendLabel(instruction, this);
+            instruction.Append(':');
+            instruction.Append(' ');
+            instruction.Append(opcode.Name);
+
+            if (operand == null)
+                return instruction.ToString();
+
+            instruction.Append(' ');
+
+            switch (opcode.OperandType)
+            {
+                case OperandType.ShortInlineBrTarget:
+                case OperandType.InlineBrTarget:
+                    AppendLabel(instruction, (Instruction)operand);
+                    break;
+                case OperandType.InlineSwitch:
+                    Instruction[] labels = (Instruction[])operand;
+                    for (int i = 0; i < labels.Length; i++)
+                    {
+                        if (i > 0)
+                            instruction.Append(',');
+
+                        AppendLabel(instruction, labels[i]);
+                    }
+                    break;
+                case OperandType.InlineString:
+                    instruction.Append('\"');
+                    instruction.Append(operand);
+                    instruction.Append('\"');
+                    break;
+                default:
+                    instruction.Append(operand);
+                    break;
+            }
+
+            return instruction.ToString();
+        }
+
+        private static void AppendLabel(StringBuilder builder, Instruction instruction)
+        {
+            builder.Append("IL_");
+            builder.Append(instruction.offset.ToString("x4"));
+        }
+
+        public static Instruction Create(OpCode opcode)
+        {
+            if (opcode.OperandType != OperandType.InlineNone)
+                throw new ArgumentException("opcode");
+
+            return new(opcode, null);
+        }
+
+        public static Instruction Create(OpCode opcode, TypeReference type)
+        {
+            if (type == null)
+                throw new ArgumentNullException("type");
+            if (opcode.OperandType != OperandType.InlineType && opcode.OperandType != OperandType.InlineTok)
+                throw new ArgumentException("opcode");
+
+            return new(opcode, type);
+        }
+
+        public static Instruction Create(OpCode opcode, CallSite site)
+        {
+            if (site == null)
+                throw new ArgumentNullException("site");
+            if (opcode.Code != Code.Calli)
+                throw new ArgumentException("code");
+
+            return new(opcode, site);
+        }
+
+        public static Instruction Create(OpCode opcode, MethodReference method)
+        {
+            if (method == null)
+                throw new ArgumentNullException("method");
+            if (opcode.OperandType != OperandType.InlineMethod && opcode.OperandType != OperandType.InlineTok)
+                throw new ArgumentException("opcode");
+
+            return new(opcode, method);
+        }
+
+        public static Instruction Create(OpCode opcode, FieldReference field)
+        {
+            if (field == null)
+                throw new ArgumentNullException("field");
+            if (opcode.OperandType != OperandType.InlineField && opcode.OperandType != OperandType.InlineTok)
+                throw new ArgumentException("opcode");
+
+            return new(opcode, field);
+        }
+
+        public static Instruction Create(OpCode opcode, string value)
+        {
+            if (value == null)
+                throw new ArgumentNullException("value");
+            if (opcode.OperandType != OperandType.InlineString)
+                throw new ArgumentException("opcode");
+
+            return new(opcode, value);
+        }
+
+        public static Instruction Create(OpCode opcode, sbyte value)
+        {
+            if (opcode.OperandType != OperandType.ShortInlineI && opcode != OpCodes.Ldc_I4_S)
+                throw new ArgumentException("opcode");
+
+            return new(opcode, value);
+        }
+
+        public static Instruction Create(OpCode opcode, byte value)
+        {
+            if (opcode.OperandType != OperandType.ShortInlineI || opcode == OpCodes.Ldc_I4_S)
+                throw new ArgumentException("opcode");
+
+            return new(opcode, value);
+        }
+
+        public static Instruction Create(OpCode opcode, int value)
+        {
+            if (opcode.OperandType != OperandType.InlineI)
+                throw new ArgumentException("opcode");
+
+            return new(opcode, value);
+        }
+
+        public static Instruction Create(OpCode opcode, long value)
+        {
+            if (opcode.OperandType != OperandType.InlineI8)
+                throw new ArgumentException("opcode");
+
+            return new(opcode, value);
+        }
+
+        public static Instruction Create(OpCode opcode, float value)
+        {
+            if (opcode.OperandType != OperandType.ShortInlineR)
+                throw new ArgumentException("opcode");
+
+            return new(opcode, value);
+        }
+
+        public static Instruction Create(OpCode opcode, double value)
+        {
+            if (opcode.OperandType != OperandType.InlineR)
+                throw new ArgumentException("opcode");
+
+            return new(opcode, value);
+        }
+
+        public static Instruction Create(OpCode opcode, Instruction target)
+        {
+            if (target == null)
+                throw new ArgumentNullException("target");
+            if (opcode.OperandType != OperandType.InlineBrTarget && opcode.OperandType != OperandType.ShortInlineBrTarget)
+                throw new ArgumentException("opcode");
+
+            return new(opcode, target);
+        }
+
+        public static Instruction Create(OpCode opcode, Instruction[] targets)
+        {
+            if (targets == null)
+                throw new ArgumentNullException("targets");
+            if (opcode.OperandType != OperandType.InlineSwitch)
+                throw new ArgumentException("opcode");
+
+            return new(opcode, targets);
+        }
+
+        public static Instruction Create(OpCode opcode, VariableDefinition variable)
+        {
+            if (variable == null)
+                throw new ArgumentNullException("variable");
+            if (opcode.OperandType != OperandType.ShortInlineVar && opcode.OperandType != OperandType.InlineVar)
+                throw new ArgumentException("opcode");
+
+            return new(opcode, variable);
+        }
+
+        public static Instruction Create(OpCode opcode, ParameterDefinition parameter)
+        {
+            if (parameter == null)
+                throw new ArgumentNullException("parameter");
+            if (opcode.OperandType != OperandType.ShortInlineArg && opcode.OperandType != OperandType.InlineArg)
+                throw new ArgumentException("opcode");
+
+            return new(opcode, parameter);
+        }
+    }
+}

Assets/FishNet/CodeGenerating/cecil-0.11.4/Mono.Cecil.Cil/Instruction.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 2d1536adbd2ca174abbd624473e722c3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/CodeGenerating/cecil-0.11.4/Mono.Cecil.Cil/Instruction.cs
+  uploadId: 866910

Assets/FishNet/CodeGenerating/cecil-0.11.4/Mono.Cecil.Cil/MethodBody.cs

@@ -0,0 +1,441 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using MonoFN.Collections.Generic;
+using System;
+using System.Threading;
+
+namespace MonoFN.Cecil.Cil
+{
+    public sealed class MethodBody
+    {
+        internal readonly MethodDefinition method;
+        internal ParameterDefinition this_parameter;
+        internal int max_stack_size;
+        internal int code_size;
+        internal bool init_locals;
+        internal MetadataToken local_var_token;
+        internal Collection<Instruction> instructions;
+        internal Collection<ExceptionHandler> exceptions;
+        internal Collection<VariableDefinition> variables;
+        public MethodDefinition Method
+        {
+            get { return method; }
+        }
+        public int MaxStackSize
+        {
+            get { return max_stack_size; }
+            set { max_stack_size = value; }
+        }
+        public int CodeSize
+        {
+            get { return code_size; }
+        }
+        public bool InitLocals
+        {
+            get { return init_locals; }
+            set { init_locals = value; }
+        }
+        public MetadataToken LocalVarToken
+        {
+            get { return local_var_token; }
+            set { local_var_token = value; }
+        }
+        public Collection<Instruction> Instructions
+        {
+            get
+            {
+                if (instructions == null)
+                    Interlocked.CompareExchange(ref instructions, new InstructionCollection(method), null);
+
+                return instructions;
+            }
+        }
+        public bool HasExceptionHandlers
+        {
+            get { return !exceptions.IsNullOrEmpty(); }
+        }
+        public Collection<ExceptionHandler> ExceptionHandlers
+        {
+            get
+            {
+                if (exceptions == null)
+                    Interlocked.CompareExchange(ref exceptions, new(), null);
+
+                return exceptions;
+            }
+        }
+        public bool HasVariables
+        {
+            get { return !variables.IsNullOrEmpty(); }
+        }
+        public Collection<VariableDefinition> Variables
+        {
+            get
+            {
+                if (variables == null)
+                    Interlocked.CompareExchange(ref variables, new VariableDefinitionCollection(method), null);
+
+                return variables;
+            }
+        }
+        public ParameterDefinition ThisParameter
+        {
+            get
+            {
+                if (method == null || method.DeclaringType == null)
+                    throw new NotSupportedException();
+
+                if (!method.HasThis)
+                    return null;
+
+                if (this_parameter == null)
+                    Interlocked.CompareExchange(ref this_parameter, CreateThisParameter(method), null);
+
+                return this_parameter;
+            }
+        }
+
+        private static ParameterDefinition CreateThisParameter(MethodDefinition method)
+        {
+            TypeReference parameter_type = method.DeclaringType as TypeReference;
+
+            if (parameter_type.HasGenericParameters)
+            {
+                GenericInstanceType instance = new(parameter_type, parameter_type.GenericParameters.Count);
+                for (int i = 0; i < parameter_type.GenericParameters.Count; i++)
+                    instance.GenericArguments.Add(parameter_type.GenericParameters[i]);
+
+                parameter_type = instance;
+            }
+
+            if (parameter_type.IsValueType || parameter_type.IsPrimitive)
+                parameter_type = new ByReferenceType(parameter_type);
+
+            return new(parameter_type, method);
+        }
+
+        public MethodBody(MethodDefinition method)
+        {
+            this.method = method;
+        }
+
+        public ILProcessor GetILProcessor()
+        {
+            return new(this);
+        }
+    }
+
+    internal sealed class VariableDefinitionCollection : Collection<VariableDefinition>
+    {
+        private readonly MethodDefinition method;
+
+        internal VariableDefinitionCollection(MethodDefinition method)
+        {
+            this.method = method;
+        }
+
+        internal VariableDefinitionCollection(MethodDefinition method, int capacity) : base(capacity)
+        {
+            this.method = method;
+        }
+
+        protected override void OnAdd(VariableDefinition item, int index)
+        {
+            item.index = index;
+        }
+
+        protected override void OnInsert(VariableDefinition item, int index)
+        {
+            item.index = index;
+            UpdateVariableIndices(index, 1);
+        }
+
+        protected override void OnSet(VariableDefinition item, int index)
+        {
+            item.index = index;
+        }
+
+        protected override void OnRemove(VariableDefinition item, int index)
+        {
+            UpdateVariableIndices(index + 1, -1, item);
+            item.index = -1;
+        }
+
+        private void UpdateVariableIndices(int startIndex, int offset, VariableDefinition variableToRemove = null)
+        {
+            for (int i = startIndex; i < size; i++)
+                items[i].index = i + offset;
+
+            MethodDebugInformation debug_info = method == null ? null : method.debug_info;
+            if (debug_info == null || debug_info.Scope == null)
+                return;
+
+            foreach (ScopeDebugInformation scope in debug_info.GetScopes())
+            {
+                if (!scope.HasVariables)
+                    continue;
+
+                Collection<VariableDebugInformation> variables = scope.Variables;
+                int variableDebugInfoIndexToRemove = -1;
+                for (int i = 0; i < variables.Count; i++)
+                {
+                    VariableDebugInformation variable = variables[i];
+
+                    // If a variable is being removed detect if it has debug info counterpart, if so remove that as well.
+                    // Note that the debug info can be either resolved (has direct reference to the VariableDefinition)
+                    // or unresolved (has only the number index of the variable) - this needs to handle both cases.
+                    if (variableToRemove != null && ((variable.index.IsResolved && variable.index.ResolvedVariable == variableToRemove) || (!variable.index.IsResolved && variable.Index == variableToRemove.Index)))
+                    {
+                        variableDebugInfoIndexToRemove = i;
+                        continue;
+                    }
+
+                    // For unresolved debug info updates indeces to keep them pointing to the same variable.
+                    if (!variable.index.IsResolved && variable.Index >= startIndex)
+                    {
+                        variable.index = new(variable.Index + offset);
+                    }
+                }
+
+                if (variableDebugInfoIndexToRemove >= 0)
+                    variables.RemoveAt(variableDebugInfoIndexToRemove);
+            }
+        }
+    }
+
+    internal class InstructionCollection : Collection<Instruction>
+    {
+        private readonly MethodDefinition method;
+
+        internal InstructionCollection(MethodDefinition method)
+        {
+            this.method = method;
+        }
+
+        internal InstructionCollection(MethodDefinition method, int capacity) : base(capacity)
+        {
+            this.method = method;
+        }
+
+        protected override void OnAdd(Instruction item, int index)
+        {
+            if (index == 0)
+                return;
+
+            Instruction previous = items[index - 1];
+            previous.next = item;
+            item.previous = previous;
+        }
+
+        protected override void OnInsert(Instruction item, int index)
+        {
+            int startOffset = 0;
+            if (size != 0)
+            {
+                Instruction current = items[index];
+                if (current == null)
+                {
+                    Instruction last = items[index - 1];
+                    last.next = item;
+                    item.previous = last;
+                    return;
+                }
+
+                startOffset = current.Offset;
+
+                Instruction previous = current.previous;
+                if (previous != null)
+                {
+                    previous.next = item;
+                    item.previous = previous;
+                }
+
+                current.previous = item;
+                item.next = current;
+            }
+
+            UpdateLocalScopes(null, null);
+        }
+
+        protected override void OnSet(Instruction item, int index)
+        {
+            Instruction current = items[index];
+
+            item.previous = current.previous;
+            item.next = current.next;
+
+            current.previous = null;
+            current.next = null;
+
+            UpdateLocalScopes(item, current);
+        }
+
+        protected override void OnRemove(Instruction item, int index)
+        {
+            Instruction previous = item.previous;
+            if (previous != null)
+                previous.next = item.next;
+
+            Instruction next = item.next;
+            if (next != null)
+                next.previous = item.previous;
+
+            RemoveSequencePoint(item);
+            UpdateLocalScopes(item, next ?? previous);
+
+            item.previous = null;
+            item.next = null;
+        }
+
+        private void RemoveSequencePoint(Instruction instruction)
+        {
+            MethodDebugInformation debug_info = method.debug_info;
+            if (debug_info == null || !debug_info.HasSequencePoints)
+                return;
+
+            Collection<SequencePoint> sequence_points = debug_info.sequence_points;
+            for (int i = 0; i < sequence_points.Count; i++)
+            {
+                if (sequence_points[i].Offset == instruction.offset)
+                {
+                    sequence_points.RemoveAt(i);
+                    return;
+                }
+            }
+        }
+
+        private void UpdateLocalScopes(Instruction removedInstruction, Instruction existingInstruction)
+        {
+            MethodDebugInformation debug_info = method.debug_info;
+            if (debug_info == null)
+                return;
+
+            // Local scopes store start/end pair of "instruction offsets". Instruction offset can be either resolved, in which case it 
+            // has a reference to Instruction, or unresolved in which case it stores numerical offset (instruction offset in the body).
+            // Typically local scopes loaded from PE/PDB files will be resolved, but it's not a requirement.
+            // Each instruction has its own offset, which is populated on load, but never updated (this would be pretty expensive to do).
+            // Instructions created during the editting will typically have offset 0 (so incorrect).
+            // Local scopes created during editing will also likely be resolved (so no numerical offsets).
+            // So while local scopes which are unresolved are relatively rare if they appear, manipulating them based
+            // on the offsets allone is pretty hard (since we can't rely on correct offsets of instructions).
+            // On the other hand resolved local scopes are easy to maintain, since they point to instructions and thus inserting
+            // instructions is basically a no-op and removing instructions is as easy as changing the pointer.
+            // For this reason the algorithm here is:
+            //  - First make sure that all instruction offsets are resolved - if not - resolve them
+            //     - First time this will be relatively expensinve as it will walk the entire method body to convert offsets to instruction pointers
+            //       Almost all local scopes are stored in the "right" order (sequentially per start offsets), so the code uses a simple one-item
+            //       cache instruction<->offset to avoid walking instructions multiple times (that would only happen for scopes which are out of order).
+            //     - Subsequent calls should be cheap as it will only walk all local scopes without doing anything
+            //     - If there was an edit on local scope which makes some of them unresolved, the cost is proportional
+            //  - Then update as necessary by manipulaitng instruction references alone
+
+            InstructionOffsetCache cache = new()
+            {
+                Offset = 0,
+                Index = 0,
+                Instruction = items[0]
+            };
+
+            UpdateLocalScope(debug_info.Scope, removedInstruction, existingInstruction, ref cache);
+        }
+
+        private void UpdateLocalScope(ScopeDebugInformation scope, Instruction removedInstruction, Instruction existingInstruction, ref InstructionOffsetCache cache)
+        {
+            if (scope == null)
+                return;
+
+            if (!scope.Start.IsResolved)
+                scope.Start = ResolveInstructionOffset(scope.Start, ref cache);
+
+            if (!scope.Start.IsEndOfMethod && scope.Start.ResolvedInstruction == removedInstruction)
+                scope.Start = new(existingInstruction);
+
+            if (scope.HasScopes)
+            {
+                foreach (ScopeDebugInformation subScope in scope.Scopes)
+                    UpdateLocalScope(subScope, removedInstruction, existingInstruction, ref cache);
+            }
+
+            if (!scope.End.IsResolved)
+                scope.End = ResolveInstructionOffset(scope.End, ref cache);
+
+            if (!scope.End.IsEndOfMethod && scope.End.ResolvedInstruction == removedInstruction)
+                scope.End = new(existingInstruction);
+        }
+
+        private struct InstructionOffsetCache
+        {
+            public int Offset;
+            public int Index;
+            public Instruction Instruction;
+        }
+
+        private InstructionOffset ResolveInstructionOffset(InstructionOffset inputOffset, ref InstructionOffsetCache cache)
+        {
+            if (inputOffset.IsResolved)
+                return inputOffset;
+
+            int offset = inputOffset.Offset;
+
+            if (cache.Offset == offset)
+                return new(cache.Instruction);
+
+            if (cache.Offset > offset)
+            {
+                // This should be rare - we're resolving offset pointing to a place before the current cache position
+                // resolve by walking the instructions from start and don't cache the result.
+                int size = 0;
+                for (int i = 0; i < items.Length; i++)
+                {
+                    if (size == offset)
+                        return new(items[i]);
+
+                    if (size > offset)
+                        return new(items[i - 1]);
+
+                    size += items[i].GetSize();
+                }
+
+                // Offset is larger than the size of the body - so it points after the end
+                return new();
+            }
+            else
+            {
+                // The offset points after the current cache position - so continue counting and update the cache
+                int size = cache.Offset;
+                for (int i = cache.Index; i < items.Length; i++)
+                {
+                    cache.Index = i;
+                    cache.Offset = size;
+
+                    Instruction item = items[i];
+
+                    // Allow for trailing null values in the case of
+                    // instructions.Size < instructions.Capacity
+                    if (item == null)
+                        break;
+
+                    cache.Instruction = item;
+
+                    if (cache.Offset == offset)
+                        return new(cache.Instruction);
+
+                    if (cache.Offset > offset)
+                        return new(items[i - 1]);
+
+                    size += item.GetSize();
+                }
+
+                return new();
+            }
+        }
+    }
+}

Assets/FishNet/CodeGenerating/cecil-0.11.4/Mono.Cecil.Cil/MethodBody.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 4be4045de2c6a0e428e5910f4e76cfac
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/CodeGenerating/cecil-0.11.4/Mono.Cecil.Cil/MethodBody.cs
+  uploadId: 866910

Assets/FishNet/CodeGenerating/cecil-0.11.4/Mono.Cecil.Cil/OpCode.cs

@@ -0,0 +1,437 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+namespace MonoFN.Cecil.Cil
+{
+    public enum FlowControl
+    {
+        Branch,
+        Break,
+        Call,
+        Cond_Branch,
+        Meta,
+        Next,
+        Phi,
+        Return,
+        Throw
+    }
+
+    public enum OpCodeType
+    {
+        Annotation,
+        Macro,
+        Nternal,
+        Objmodel,
+        Prefix,
+        Primitive
+    }
+
+    public enum OperandType
+    {
+        InlineBrTarget,
+        InlineField,
+        InlineI,
+        InlineI8,
+        InlineMethod,
+        InlineNone,
+        InlinePhi,
+        InlineR,
+        InlineSig,
+        InlineString,
+        InlineSwitch,
+        InlineTok,
+        InlineType,
+        InlineVar,
+        InlineArg,
+        ShortInlineBrTarget,
+        ShortInlineI,
+        ShortInlineR,
+        ShortInlineVar,
+        ShortInlineArg
+    }
+
+    public enum StackBehaviour
+    {
+        Pop0,
+        Pop1,
+        Pop1_pop1,
+        Popi,
+        Popi_pop1,
+        Popi_popi,
+        Popi_popi8,
+        Popi_popi_popi,
+        Popi_popr4,
+        Popi_popr8,
+        Popref,
+        Popref_pop1,
+        Popref_popi,
+        Popref_popi_popi,
+        Popref_popi_popi8,
+        Popref_popi_popr4,
+        Popref_popi_popr8,
+        Popref_popi_popref,
+        PopAll,
+        Push0,
+        Push1,
+        Push1_push1,
+        Pushi,
+        Pushi8,
+        Pushr4,
+        Pushr8,
+        Pushref,
+        Varpop,
+        Varpush
+    }
+
+    public struct OpCode : IEquatable<OpCode>
+    {
+        private readonly byte code;
+        private readonly byte flow_control;
+        private readonly byte opcode_type;
+        private readonly byte operand_type;
+        private readonly byte stack_behavior_pop;
+        private readonly byte stack_behavior_push;
+        public string Name
+        {
+            get { return OpCodeNames.names[(int)Code]; }
+        }
+        public int Size
+        {
+            get { return Op1 == 0xff ? 1 : 2; }
+        }
+        public byte Op1 { get; }
+        public byte Op2 { get; }
+        public short Value
+        {
+            get { return Op1 == 0xff ? Op2 : (short)((Op1 << 8) | Op2); }
+        }
+        public Code Code
+        {
+            get { return (Code)code; }
+        }
+        public FlowControl FlowControl
+        {
+            get { return (FlowControl)flow_control; }
+        }
+        public OpCodeType OpCodeType
+        {
+            get { return (OpCodeType)opcode_type; }
+        }
+        public OperandType OperandType
+        {
+            get { return (OperandType)operand_type; }
+        }
+        public StackBehaviour StackBehaviourPop
+        {
+            get { return (StackBehaviour)stack_behavior_pop; }
+        }
+        public StackBehaviour StackBehaviourPush
+        {
+            get { return (StackBehaviour)stack_behavior_push; }
+        }
+
+        internal OpCode(int x, int y)
+        {
+            Op1 = (byte)((x >> 0) & 0xff);
+            Op2 = (byte)((x >> 8) & 0xff);
+            code = (byte)((x >> 16) & 0xff);
+            flow_control = (byte)((x >> 24) & 0xff);
+
+            opcode_type = (byte)((y >> 0) & 0xff);
+            operand_type = (byte)((y >> 8) & 0xff);
+            stack_behavior_pop = (byte)((y >> 16) & 0xff);
+            stack_behavior_push = (byte)((y >> 24) & 0xff);
+
+            if (Op1 == 0xff)
+                OpCodes.OneByteOpCode[Op2] = this;
+            else
+                OpCodes.TwoBytesOpCode[Op2] = this;
+        }
+
+        public override int GetHashCode()
+        {
+            return Value;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (!(obj is OpCode))
+                return false;
+
+            OpCode opcode = (OpCode)obj;
+            return Op1 == opcode.Op1 && Op2 == opcode.Op2;
+        }
+
+        public bool Equals(OpCode opcode)
+        {
+            return Op1 == opcode.Op1 && Op2 == opcode.Op2;
+        }
+
+        public static bool operator ==(OpCode one, OpCode other)
+        {
+            return one.Op1 == other.Op1 && one.Op2 == other.Op2;
+        }
+
+        public static bool operator !=(OpCode one, OpCode other)
+        {
+            return one.Op1 != other.Op1 || one.Op2 != other.Op2;
+        }
+
+        public override string ToString()
+        {
+            return Name;
+        }
+    }
+
+    internal static class OpCodeNames
+    {
+        internal static readonly string[] names;
+
+        static OpCodeNames()
+        {
+            byte[] table = new byte[]
+            {
+                3, 110, 111, 112,
+                5, 98, 114, 101, 97, 107,
+                7, 108, 100, 97, 114, 103, 46, 48,
+                7, 108, 100, 97, 114, 103, 46, 49,
+                7, 108, 100, 97, 114, 103, 46, 50,
+                7, 108, 100, 97, 114, 103, 46, 51,
+                7, 108, 100, 108, 111, 99, 46, 48,
+                7, 108, 100, 108, 111, 99, 46, 49,
+                7, 108, 100, 108, 111, 99, 46, 50,
+                7, 108, 100, 108, 111, 99, 46, 51,
+                7, 115, 116, 108, 111, 99, 46, 48,
+                7, 115, 116, 108, 111, 99, 46, 49,
+                7, 115, 116, 108, 111, 99, 46, 50,
+                7, 115, 116, 108, 111, 99, 46, 51,
+                7, 108, 100, 97, 114, 103, 46, 115,
+                8, 108, 100, 97, 114, 103, 97, 46, 115,
+                7, 115, 116, 97, 114, 103, 46, 115,
+                7, 108, 100, 108, 111, 99, 46, 115,
+                8, 108, 100, 108, 111, 99, 97, 46, 115,
+                7, 115, 116, 108, 111, 99, 46, 115,
+                6, 108, 100, 110, 117, 108, 108,
+                9, 108, 100, 99, 46, 105, 52, 46, 109, 49,
+                8, 108, 100, 99, 46, 105, 52, 46, 48,
+                8, 108, 100, 99, 46, 105, 52, 46, 49,
+                8, 108, 100, 99, 46, 105, 52, 46, 50,
+                8, 108, 100, 99, 46, 105, 52, 46, 51,
+                8, 108, 100, 99, 46, 105, 52, 46, 52,
+                8, 108, 100, 99, 46, 105, 52, 46, 53,
+                8, 108, 100, 99, 46, 105, 52, 46, 54,
+                8, 108, 100, 99, 46, 105, 52, 46, 55,
+                8, 108, 100, 99, 46, 105, 52, 46, 56,
+                8, 108, 100, 99, 46, 105, 52, 46, 115,
+                6, 108, 100, 99, 46, 105, 52,
+                6, 108, 100, 99, 46, 105, 56,
+                6, 108, 100, 99, 46, 114, 52,
+                6, 108, 100, 99, 46, 114, 56,
+                3, 100, 117, 112,
+                3, 112, 111, 112,
+                3, 106, 109, 112,
+                4, 99, 97, 108, 108,
+                5, 99, 97, 108, 108, 105,
+                3, 114, 101, 116,
+                4, 98, 114, 46, 115,
+                9, 98, 114, 102, 97, 108, 115, 101, 46, 115,
+                8, 98, 114, 116, 114, 117, 101, 46, 115,
+                5, 98, 101, 113, 46, 115,
+                5, 98, 103, 101, 46, 115,
+                5, 98, 103, 116, 46, 115,
+                5, 98, 108, 101, 46, 115,
+                5, 98, 108, 116, 46, 115,
+                8, 98, 110, 101, 46, 117, 110, 46, 115,
+                8, 98, 103, 101, 46, 117, 110, 46, 115,
+                8, 98, 103, 116, 46, 117, 110, 46, 115,
+                8, 98, 108, 101, 46, 117, 110, 46, 115,
+                8, 98, 108, 116, 46, 117, 110, 46, 115,
+                2, 98, 114,
+                7, 98, 114, 102, 97, 108, 115, 101,
+                6, 98, 114, 116, 114, 117, 101,
+                3, 98, 101, 113,
+                3, 98, 103, 101,
+                3, 98, 103, 116,
+                3, 98, 108, 101,
+                3, 98, 108, 116,
+                6, 98, 110, 101, 46, 117, 110,
+                6, 98, 103, 101, 46, 117, 110,
+                6, 98, 103, 116, 46, 117, 110,
+                6, 98, 108, 101, 46, 117, 110,
+                6, 98, 108, 116, 46, 117, 110,
+                6, 115, 119, 105, 116, 99, 104,
+                8, 108, 100, 105, 110, 100, 46, 105, 49,
+                8, 108, 100, 105, 110, 100, 46, 117, 49,
+                8, 108, 100, 105, 110, 100, 46, 105, 50,
+                8, 108, 100, 105, 110, 100, 46, 117, 50,
+                8, 108, 100, 105, 110, 100, 46, 105, 52,
+                8, 108, 100, 105, 110, 100, 46, 117, 52,
+                8, 108, 100, 105, 110, 100, 46, 105, 56,
+                7, 108, 100, 105, 110, 100, 46, 105,
+                8, 108, 100, 105, 110, 100, 46, 114, 52,
+                8, 108, 100, 105, 110, 100, 46, 114, 56,
+                9, 108, 100, 105, 110, 100, 46, 114, 101, 102,
+                9, 115, 116, 105, 110, 100, 46, 114, 101, 102,
+                8, 115, 116, 105, 110, 100, 46, 105, 49,
+                8, 115, 116, 105, 110, 100, 46, 105, 50,
+                8, 115, 116, 105, 110, 100, 46, 105, 52,
+                8, 115, 116, 105, 110, 100, 46, 105, 56,
+                8, 115, 116, 105, 110, 100, 46, 114, 52,
+                8, 115, 116, 105, 110, 100, 46, 114, 56,
+                3, 97, 100, 100,
+                3, 115, 117, 98,
+                3, 109, 117, 108,
+                3, 100, 105, 118,
+                6, 100, 105, 118, 46, 117, 110,
+                3, 114, 101, 109,
+                6, 114, 101, 109, 46, 117, 110,
+                3, 97, 110, 100,
+                2, 111, 114,
+                3, 120, 111, 114,
+                3, 115, 104, 108,
+                3, 115, 104, 114,
+                6, 115, 104, 114, 46, 117, 110,
+                3, 110, 101, 103,
+                3, 110, 111, 116,
+                7, 99, 111, 110, 118, 46, 105, 49,
+                7, 99, 111, 110, 118, 46, 105, 50,
+                7, 99, 111, 110, 118, 46, 105, 52,
+                7, 99, 111, 110, 118, 46, 105, 56,
+                7, 99, 111, 110, 118, 46, 114, 52,
+                7, 99, 111, 110, 118, 46, 114, 56,
+                7, 99, 111, 110, 118, 46, 117, 52,
+                7, 99, 111, 110, 118, 46, 117, 56,
+                8, 99, 97, 108, 108, 118, 105, 114, 116,
+                5, 99, 112, 111, 98, 106,
+                5, 108, 100, 111, 98, 106,
+                5, 108, 100, 115, 116, 114,
+                6, 110, 101, 119, 111, 98, 106,
+                9, 99, 97, 115, 116, 99, 108, 97, 115, 115,
+                6, 105, 115, 105, 110, 115, 116,
+                9, 99, 111, 110, 118, 46, 114, 46, 117, 110,
+                5, 117, 110, 98, 111, 120,
+                5, 116, 104, 114, 111, 119,
+                5, 108, 100, 102, 108, 100,
+                6, 108, 100, 102, 108, 100, 97,
+                5, 115, 116, 102, 108, 100,
+                6, 108, 100, 115, 102, 108, 100,
+                7, 108, 100, 115, 102, 108, 100, 97,
+                6, 115, 116, 115, 102, 108, 100,
+                5, 115, 116, 111, 98, 106,
+                14, 99, 111, 110, 118, 46, 111, 118, 102, 46, 105, 49, 46, 117, 110,
+                14, 99, 111, 110, 118, 46, 111, 118, 102, 46, 105, 50, 46, 117, 110,
+                14, 99, 111, 110, 118, 46, 111, 118, 102, 46, 105, 52, 46, 117, 110,
+                14, 99, 111, 110, 118, 46, 111, 118, 102, 46, 105, 56, 46, 117, 110,
+                14, 99, 111, 110, 118, 46, 111, 118, 102, 46, 117, 49, 46, 117, 110,
+                14, 99, 111, 110, 118, 46, 111, 118, 102, 46, 117, 50, 46, 117, 110,
+                14, 99, 111, 110, 118, 46, 111, 118, 102, 46, 117, 52, 46, 117, 110,
+                14, 99, 111, 110, 118, 46, 111, 118, 102, 46, 117, 56, 46, 117, 110,
+                13, 99, 111, 110, 118, 46, 111, 118, 102, 46, 105, 46, 117, 110,
+                13, 99, 111, 110, 118, 46, 111, 118, 102, 46, 117, 46, 117, 110,
+                3, 98, 111, 120,
+                6, 110, 101, 119, 97, 114, 114,
+                5, 108, 100, 108, 101, 110,
+                7, 108, 100, 101, 108, 101, 109, 97,
+                9, 108, 100, 101, 108, 101, 109, 46, 105, 49,
+                9, 108, 100, 101, 108, 101, 109, 46, 117, 49,
+                9, 108, 100, 101, 108, 101, 109, 46, 105, 50,
+                9, 108, 100, 101, 108, 101, 109, 46, 117, 50,
+                9, 108, 100, 101, 108, 101, 109, 46, 105, 52,
+                9, 108, 100, 101, 108, 101, 109, 46, 117, 52,
+                9, 108, 100, 101, 108, 101, 109, 46, 105, 56,
+                8, 108, 100, 101, 108, 101, 109, 46, 105,
+                9, 108, 100, 101, 108, 101, 109, 46, 114, 52,
+                9, 108, 100, 101, 108, 101, 109, 46, 114, 56,
+                10, 108, 100, 101, 108, 101, 109, 46, 114, 101, 102,
+                8, 115, 116, 101, 108, 101, 109, 46, 105,
+                9, 115, 116, 101, 108, 101, 109, 46, 105, 49,
+                9, 115, 116, 101, 108, 101, 109, 46, 105, 50,
+                9, 115, 116, 101, 108, 101, 109, 46, 105, 52,
+                9, 115, 116, 101, 108, 101, 109, 46, 105, 56,
+                9, 115, 116, 101, 108, 101, 109, 46, 114, 52,
+                9, 115, 116, 101, 108, 101, 109, 46, 114, 56,
+                10, 115, 116, 101, 108, 101, 109, 46, 114, 101, 102,
+                10, 108, 100, 101, 108, 101, 109, 46, 97, 110, 121,
+                10, 115, 116, 101, 108, 101, 109, 46, 97, 110, 121,
+                9, 117, 110, 98, 111, 120, 46, 97, 110, 121,
+                11, 99, 111, 110, 118, 46, 111, 118, 102, 46, 105, 49,
+                11, 99, 111, 110, 118, 46, 111, 118, 102, 46, 117, 49,
+                11, 99, 111, 110, 118, 46, 111, 118, 102, 46, 105, 50,
+                11, 99, 111, 110, 118, 46, 111, 118, 102, 46, 117, 50,
+                11, 99, 111, 110, 118, 46, 111, 118, 102, 46, 105, 52,
+                11, 99, 111, 110, 118, 46, 111, 118, 102, 46, 117, 52,
+                11, 99, 111, 110, 118, 46, 111, 118, 102, 46, 105, 56,
+                11, 99, 111, 110, 118, 46, 111, 118, 102, 46, 117, 56,
+                9, 114, 101, 102, 97, 110, 121, 118, 97, 108,
+                8, 99, 107, 102, 105, 110, 105, 116, 101,
+                8, 109, 107, 114, 101, 102, 97, 110, 121,
+                7, 108, 100, 116, 111, 107, 101, 110,
+                7, 99, 111, 110, 118, 46, 117, 50,
+                7, 99, 111, 110, 118, 46, 117, 49,
+                6, 99, 111, 110, 118, 46, 105,
+                10, 99, 111, 110, 118, 46, 111, 118, 102, 46, 105,
+                10, 99, 111, 110, 118, 46, 111, 118, 102, 46, 117,
+                7, 97, 100, 100, 46, 111, 118, 102,
+                10, 97, 100, 100, 46, 111, 118, 102, 46, 117, 110,
+                7, 109, 117, 108, 46, 111, 118, 102,
+                10, 109, 117, 108, 46, 111, 118, 102, 46, 117, 110,
+                7, 115, 117, 98, 46, 111, 118, 102,
+                10, 115, 117, 98, 46, 111, 118, 102, 46, 117, 110,
+                10, 101, 110, 100, 102, 105, 110, 97, 108, 108, 121,
+                5, 108, 101, 97, 118, 101,
+                7, 108, 101, 97, 118, 101, 46, 115,
+                7, 115, 116, 105, 110, 100, 46, 105,
+                6, 99, 111, 110, 118, 46, 117,
+                7, 97, 114, 103, 108, 105, 115, 116,
+                3, 99, 101, 113,
+                3, 99, 103, 116,
+                6, 99, 103, 116, 46, 117, 110,
+                3, 99, 108, 116,
+                6, 99, 108, 116, 46, 117, 110,
+                5, 108, 100, 102, 116, 110,
+                9, 108, 100, 118, 105, 114, 116, 102, 116, 110,
+                5, 108, 100, 97, 114, 103,
+                6, 108, 100, 97, 114, 103, 97,
+                5, 115, 116, 97, 114, 103,
+                5, 108, 100, 108, 111, 99,
+                6, 108, 100, 108, 111, 99, 97,
+                5, 115, 116, 108, 111, 99,
+                8, 108, 111, 99, 97, 108, 108, 111, 99,
+                9, 101, 110, 100, 102, 105, 108, 116, 101, 114,
+                10, 117, 110, 97, 108, 105, 103, 110, 101, 100, 46,
+                9, 118, 111, 108, 97, 116, 105, 108, 101, 46,
+                5, 116, 97, 105, 108, 46,
+                7, 105, 110, 105, 116, 111, 98, 106,
+                12, 99, 111, 110, 115, 116, 114, 97, 105, 110, 101, 100, 46,
+                5, 99, 112, 98, 108, 107,
+                7, 105, 110, 105, 116, 98, 108, 107,
+                3, 110, 111, 46,
+                7, 114, 101, 116, 104, 114, 111, 119,
+                6, 115, 105, 122, 101, 111, 102,
+                10, 114, 101, 102, 97, 110, 121, 116, 121, 112, 101,
+                9, 114, 101, 97, 100, 111, 110, 108, 121, 46
+            };
+
+            names = new string [219];
+
+            for (int i = 0, p = 0; i < names.Length; i++)
+            {
+                char[] buffer = new char [table[p++]];
+
+                for (int j = 0; j < buffer.Length; j++)
+                    buffer[j] = (char)table[p++];
+
+                names[i] = new(buffer);
+            }
+        }
+    }
+}

Assets/FishNet/CodeGenerating/cecil-0.11.4/Mono.Cecil.Cil/OpCode.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 5d8b234c106529441912c10b87502175
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/CodeGenerating/cecil-0.11.4/Mono.Cecil.Cil/OpCode.cs
+  uploadId: 866910

Assets/FishNet/CodeGenerating/cecil-0.11.4/Mono.Cecil.Cil/OpCodes.cs

@@ -0,0 +1,237 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+namespace MonoFN.Cecil.Cil
+{
+    public static class OpCodes
+    {
+        internal static readonly OpCode[] OneByteOpCode = new OpCode [0xe0 + 1];
+        internal static readonly OpCode[] TwoBytesOpCode = new OpCode [0x1e + 1];
+        public static readonly OpCode Nop = new((0xff << 0) | (0x00 << 8) | ((byte)Code.Nop << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Break = new((0xff << 0) | (0x01 << 8) | ((byte)Code.Break << 16) | ((byte)FlowControl.Break << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Ldarg_0 = new((0xff << 0) | (0x02 << 8) | ((byte)Code.Ldarg_0 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Push1 << 24));
+        public static readonly OpCode Ldarg_1 = new((0xff << 0) | (0x03 << 8) | ((byte)Code.Ldarg_1 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Push1 << 24));
+        public static readonly OpCode Ldarg_2 = new((0xff << 0) | (0x04 << 8) | ((byte)Code.Ldarg_2 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Push1 << 24));
+        public static readonly OpCode Ldarg_3 = new((0xff << 0) | (0x05 << 8) | ((byte)Code.Ldarg_3 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Push1 << 24));
+        public static readonly OpCode Ldloc_0 = new((0xff << 0) | (0x06 << 8) | ((byte)Code.Ldloc_0 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Push1 << 24));
+        public static readonly OpCode Ldloc_1 = new((0xff << 0) | (0x07 << 8) | ((byte)Code.Ldloc_1 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Push1 << 24));
+        public static readonly OpCode Ldloc_2 = new((0xff << 0) | (0x08 << 8) | ((byte)Code.Ldloc_2 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Push1 << 24));
+        public static readonly OpCode Ldloc_3 = new((0xff << 0) | (0x09 << 8) | ((byte)Code.Ldloc_3 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Push1 << 24));
+        public static readonly OpCode Stloc_0 = new((0xff << 0) | (0x0a << 8) | ((byte)Code.Stloc_0 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Stloc_1 = new((0xff << 0) | (0x0b << 8) | ((byte)Code.Stloc_1 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Stloc_2 = new((0xff << 0) | (0x0c << 8) | ((byte)Code.Stloc_2 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Stloc_3 = new((0xff << 0) | (0x0d << 8) | ((byte)Code.Stloc_3 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Ldarg_S = new((0xff << 0) | (0x0e << 8) | ((byte)Code.Ldarg_S << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.ShortInlineArg << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Push1 << 24));
+        public static readonly OpCode Ldarga_S = new((0xff << 0) | (0x0f << 8) | ((byte)Code.Ldarga_S << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.ShortInlineArg << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Starg_S = new((0xff << 0) | (0x10 << 8) | ((byte)Code.Starg_S << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.ShortInlineArg << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Ldloc_S = new((0xff << 0) | (0x11 << 8) | ((byte)Code.Ldloc_S << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.ShortInlineVar << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Push1 << 24));
+        public static readonly OpCode Ldloca_S = new((0xff << 0) | (0x12 << 8) | ((byte)Code.Ldloca_S << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.ShortInlineVar << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Stloc_S = new((0xff << 0) | (0x13 << 8) | ((byte)Code.Stloc_S << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.ShortInlineVar << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Ldnull = new((0xff << 0) | (0x14 << 8) | ((byte)Code.Ldnull << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Pushref << 24));
+        public static readonly OpCode Ldc_I4_M1 = new((0xff << 0) | (0x15 << 8) | ((byte)Code.Ldc_I4_M1 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Ldc_I4_0 = new((0xff << 0) | (0x16 << 8) | ((byte)Code.Ldc_I4_0 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Ldc_I4_1 = new((0xff << 0) | (0x17 << 8) | ((byte)Code.Ldc_I4_1 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Ldc_I4_2 = new((0xff << 0) | (0x18 << 8) | ((byte)Code.Ldc_I4_2 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Ldc_I4_3 = new((0xff << 0) | (0x19 << 8) | ((byte)Code.Ldc_I4_3 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Ldc_I4_4 = new((0xff << 0) | (0x1a << 8) | ((byte)Code.Ldc_I4_4 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Ldc_I4_5 = new((0xff << 0) | (0x1b << 8) | ((byte)Code.Ldc_I4_5 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Ldc_I4_6 = new((0xff << 0) | (0x1c << 8) | ((byte)Code.Ldc_I4_6 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Ldc_I4_7 = new((0xff << 0) | (0x1d << 8) | ((byte)Code.Ldc_I4_7 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Ldc_I4_8 = new((0xff << 0) | (0x1e << 8) | ((byte)Code.Ldc_I4_8 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Ldc_I4_S = new((0xff << 0) | (0x1f << 8) | ((byte)Code.Ldc_I4_S << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.ShortInlineI << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Ldc_I4 = new((0xff << 0) | (0x20 << 8) | ((byte)Code.Ldc_I4 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineI << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Ldc_I8 = new((0xff << 0) | (0x21 << 8) | ((byte)Code.Ldc_I8 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineI8 << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Pushi8 << 24));
+        public static readonly OpCode Ldc_R4 = new((0xff << 0) | (0x22 << 8) | ((byte)Code.Ldc_R4 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.ShortInlineR << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Pushr4 << 24));
+        public static readonly OpCode Ldc_R8 = new((0xff << 0) | (0x23 << 8) | ((byte)Code.Ldc_R8 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineR << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Pushr8 << 24));
+        public static readonly OpCode Dup = new((0xff << 0) | (0x25 << 8) | ((byte)Code.Dup << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Push1_push1 << 24));
+        public static readonly OpCode Pop = new((0xff << 0) | (0x26 << 8) | ((byte)Code.Pop << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Jmp = new((0xff << 0) | (0x27 << 8) | ((byte)Code.Jmp << 16) | ((byte)FlowControl.Call << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineMethod << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Call = new((0xff << 0) | (0x28 << 8) | ((byte)Code.Call << 16) | ((byte)FlowControl.Call << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineMethod << 8) | ((byte)StackBehaviour.Varpop << 16) | ((byte)StackBehaviour.Varpush << 24));
+        public static readonly OpCode Calli = new((0xff << 0) | (0x29 << 8) | ((byte)Code.Calli << 16) | ((byte)FlowControl.Call << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineSig << 8) | ((byte)StackBehaviour.Varpop << 16) | ((byte)StackBehaviour.Varpush << 24));
+        public static readonly OpCode Ret = new((0xff << 0) | (0x2a << 8) | ((byte)Code.Ret << 16) | ((byte)FlowControl.Return << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Varpop << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Br_S = new((0xff << 0) | (0x2b << 8) | ((byte)Code.Br_S << 16) | ((byte)FlowControl.Branch << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.ShortInlineBrTarget << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Brfalse_S = new((0xff << 0) | (0x2c << 8) | ((byte)Code.Brfalse_S << 16) | ((byte)FlowControl.Cond_Branch << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.ShortInlineBrTarget << 8) | ((byte)StackBehaviour.Popi << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Brtrue_S = new((0xff << 0) | (0x2d << 8) | ((byte)Code.Brtrue_S << 16) | ((byte)FlowControl.Cond_Branch << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.ShortInlineBrTarget << 8) | ((byte)StackBehaviour.Popi << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Beq_S = new((0xff << 0) | (0x2e << 8) | ((byte)Code.Beq_S << 16) | ((byte)FlowControl.Cond_Branch << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.ShortInlineBrTarget << 8) | ((byte)StackBehaviour.Pop1_pop1 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Bge_S = new((0xff << 0) | (0x2f << 8) | ((byte)Code.Bge_S << 16) | ((byte)FlowControl.Cond_Branch << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.ShortInlineBrTarget << 8) | ((byte)StackBehaviour.Pop1_pop1 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Bgt_S = new((0xff << 0) | (0x30 << 8) | ((byte)Code.Bgt_S << 16) | ((byte)FlowControl.Cond_Branch << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.ShortInlineBrTarget << 8) | ((byte)StackBehaviour.Pop1_pop1 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Ble_S = new((0xff << 0) | (0x31 << 8) | ((byte)Code.Ble_S << 16) | ((byte)FlowControl.Cond_Branch << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.ShortInlineBrTarget << 8) | ((byte)StackBehaviour.Pop1_pop1 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Blt_S = new((0xff << 0) | (0x32 << 8) | ((byte)Code.Blt_S << 16) | ((byte)FlowControl.Cond_Branch << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.ShortInlineBrTarget << 8) | ((byte)StackBehaviour.Pop1_pop1 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Bne_Un_S = new((0xff << 0) | (0x33 << 8) | ((byte)Code.Bne_Un_S << 16) | ((byte)FlowControl.Cond_Branch << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.ShortInlineBrTarget << 8) | ((byte)StackBehaviour.Pop1_pop1 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Bge_Un_S = new((0xff << 0) | (0x34 << 8) | ((byte)Code.Bge_Un_S << 16) | ((byte)FlowControl.Cond_Branch << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.ShortInlineBrTarget << 8) | ((byte)StackBehaviour.Pop1_pop1 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Bgt_Un_S = new((0xff << 0) | (0x35 << 8) | ((byte)Code.Bgt_Un_S << 16) | ((byte)FlowControl.Cond_Branch << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.ShortInlineBrTarget << 8) | ((byte)StackBehaviour.Pop1_pop1 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Ble_Un_S = new((0xff << 0) | (0x36 << 8) | ((byte)Code.Ble_Un_S << 16) | ((byte)FlowControl.Cond_Branch << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.ShortInlineBrTarget << 8) | ((byte)StackBehaviour.Pop1_pop1 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Blt_Un_S = new((0xff << 0) | (0x37 << 8) | ((byte)Code.Blt_Un_S << 16) | ((byte)FlowControl.Cond_Branch << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.ShortInlineBrTarget << 8) | ((byte)StackBehaviour.Pop1_pop1 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Br = new((0xff << 0) | (0x38 << 8) | ((byte)Code.Br << 16) | ((byte)FlowControl.Branch << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineBrTarget << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Brfalse = new((0xff << 0) | (0x39 << 8) | ((byte)Code.Brfalse << 16) | ((byte)FlowControl.Cond_Branch << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineBrTarget << 8) | ((byte)StackBehaviour.Popi << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Brtrue = new((0xff << 0) | (0x3a << 8) | ((byte)Code.Brtrue << 16) | ((byte)FlowControl.Cond_Branch << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineBrTarget << 8) | ((byte)StackBehaviour.Popi << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Beq = new((0xff << 0) | (0x3b << 8) | ((byte)Code.Beq << 16) | ((byte)FlowControl.Cond_Branch << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.InlineBrTarget << 8) | ((byte)StackBehaviour.Pop1_pop1 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Bge = new((0xff << 0) | (0x3c << 8) | ((byte)Code.Bge << 16) | ((byte)FlowControl.Cond_Branch << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.InlineBrTarget << 8) | ((byte)StackBehaviour.Pop1_pop1 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Bgt = new((0xff << 0) | (0x3d << 8) | ((byte)Code.Bgt << 16) | ((byte)FlowControl.Cond_Branch << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.InlineBrTarget << 8) | ((byte)StackBehaviour.Pop1_pop1 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Ble = new((0xff << 0) | (0x3e << 8) | ((byte)Code.Ble << 16) | ((byte)FlowControl.Cond_Branch << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.InlineBrTarget << 8) | ((byte)StackBehaviour.Pop1_pop1 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Blt = new((0xff << 0) | (0x3f << 8) | ((byte)Code.Blt << 16) | ((byte)FlowControl.Cond_Branch << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.InlineBrTarget << 8) | ((byte)StackBehaviour.Pop1_pop1 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Bne_Un = new((0xff << 0) | (0x40 << 8) | ((byte)Code.Bne_Un << 16) | ((byte)FlowControl.Cond_Branch << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.InlineBrTarget << 8) | ((byte)StackBehaviour.Pop1_pop1 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Bge_Un = new((0xff << 0) | (0x41 << 8) | ((byte)Code.Bge_Un << 16) | ((byte)FlowControl.Cond_Branch << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.InlineBrTarget << 8) | ((byte)StackBehaviour.Pop1_pop1 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Bgt_Un = new((0xff << 0) | (0x42 << 8) | ((byte)Code.Bgt_Un << 16) | ((byte)FlowControl.Cond_Branch << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.InlineBrTarget << 8) | ((byte)StackBehaviour.Pop1_pop1 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Ble_Un = new((0xff << 0) | (0x43 << 8) | ((byte)Code.Ble_Un << 16) | ((byte)FlowControl.Cond_Branch << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.InlineBrTarget << 8) | ((byte)StackBehaviour.Pop1_pop1 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Blt_Un = new((0xff << 0) | (0x44 << 8) | ((byte)Code.Blt_Un << 16) | ((byte)FlowControl.Cond_Branch << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.InlineBrTarget << 8) | ((byte)StackBehaviour.Pop1_pop1 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Switch = new((0xff << 0) | (0x45 << 8) | ((byte)Code.Switch << 16) | ((byte)FlowControl.Cond_Branch << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineSwitch << 8) | ((byte)StackBehaviour.Popi << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Ldind_I1 = new((0xff << 0) | (0x46 << 8) | ((byte)Code.Ldind_I1 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Popi << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Ldind_U1 = new((0xff << 0) | (0x47 << 8) | ((byte)Code.Ldind_U1 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Popi << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Ldind_I2 = new((0xff << 0) | (0x48 << 8) | ((byte)Code.Ldind_I2 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Popi << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Ldind_U2 = new((0xff << 0) | (0x49 << 8) | ((byte)Code.Ldind_U2 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Popi << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Ldind_I4 = new((0xff << 0) | (0x4a << 8) | ((byte)Code.Ldind_I4 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Popi << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Ldind_U4 = new((0xff << 0) | (0x4b << 8) | ((byte)Code.Ldind_U4 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Popi << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Ldind_I8 = new((0xff << 0) | (0x4c << 8) | ((byte)Code.Ldind_I8 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Popi << 16) | ((byte)StackBehaviour.Pushi8 << 24));
+        public static readonly OpCode Ldind_I = new((0xff << 0) | (0x4d << 8) | ((byte)Code.Ldind_I << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Popi << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Ldind_R4 = new((0xff << 0) | (0x4e << 8) | ((byte)Code.Ldind_R4 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Popi << 16) | ((byte)StackBehaviour.Pushr4 << 24));
+        public static readonly OpCode Ldind_R8 = new((0xff << 0) | (0x4f << 8) | ((byte)Code.Ldind_R8 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Popi << 16) | ((byte)StackBehaviour.Pushr8 << 24));
+        public static readonly OpCode Ldind_Ref = new((0xff << 0) | (0x50 << 8) | ((byte)Code.Ldind_Ref << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Popi << 16) | ((byte)StackBehaviour.Pushref << 24));
+        public static readonly OpCode Stind_Ref = new((0xff << 0) | (0x51 << 8) | ((byte)Code.Stind_Ref << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Popi_popi << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Stind_I1 = new((0xff << 0) | (0x52 << 8) | ((byte)Code.Stind_I1 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Popi_popi << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Stind_I2 = new((0xff << 0) | (0x53 << 8) | ((byte)Code.Stind_I2 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Popi_popi << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Stind_I4 = new((0xff << 0) | (0x54 << 8) | ((byte)Code.Stind_I4 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Popi_popi << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Stind_I8 = new((0xff << 0) | (0x55 << 8) | ((byte)Code.Stind_I8 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Popi_popi8 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Stind_R4 = new((0xff << 0) | (0x56 << 8) | ((byte)Code.Stind_R4 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Popi_popr4 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Stind_R8 = new((0xff << 0) | (0x57 << 8) | ((byte)Code.Stind_R8 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Popi_popr8 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Add = new((0xff << 0) | (0x58 << 8) | ((byte)Code.Add << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1_pop1 << 16) | ((byte)StackBehaviour.Push1 << 24));
+        public static readonly OpCode Sub = new((0xff << 0) | (0x59 << 8) | ((byte)Code.Sub << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1_pop1 << 16) | ((byte)StackBehaviour.Push1 << 24));
+        public static readonly OpCode Mul = new((0xff << 0) | (0x5a << 8) | ((byte)Code.Mul << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1_pop1 << 16) | ((byte)StackBehaviour.Push1 << 24));
+        public static readonly OpCode Div = new((0xff << 0) | (0x5b << 8) | ((byte)Code.Div << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1_pop1 << 16) | ((byte)StackBehaviour.Push1 << 24));
+        public static readonly OpCode Div_Un = new((0xff << 0) | (0x5c << 8) | ((byte)Code.Div_Un << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1_pop1 << 16) | ((byte)StackBehaviour.Push1 << 24));
+        public static readonly OpCode Rem = new((0xff << 0) | (0x5d << 8) | ((byte)Code.Rem << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1_pop1 << 16) | ((byte)StackBehaviour.Push1 << 24));
+        public static readonly OpCode Rem_Un = new((0xff << 0) | (0x5e << 8) | ((byte)Code.Rem_Un << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1_pop1 << 16) | ((byte)StackBehaviour.Push1 << 24));
+        public static readonly OpCode And = new((0xff << 0) | (0x5f << 8) | ((byte)Code.And << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1_pop1 << 16) | ((byte)StackBehaviour.Push1 << 24));
+        public static readonly OpCode Or = new((0xff << 0) | (0x60 << 8) | ((byte)Code.Or << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1_pop1 << 16) | ((byte)StackBehaviour.Push1 << 24));
+        public static readonly OpCode Xor = new((0xff << 0) | (0x61 << 8) | ((byte)Code.Xor << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1_pop1 << 16) | ((byte)StackBehaviour.Push1 << 24));
+        public static readonly OpCode Shl = new((0xff << 0) | (0x62 << 8) | ((byte)Code.Shl << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1_pop1 << 16) | ((byte)StackBehaviour.Push1 << 24));
+        public static readonly OpCode Shr = new((0xff << 0) | (0x63 << 8) | ((byte)Code.Shr << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1_pop1 << 16) | ((byte)StackBehaviour.Push1 << 24));
+        public static readonly OpCode Shr_Un = new((0xff << 0) | (0x64 << 8) | ((byte)Code.Shr_Un << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1_pop1 << 16) | ((byte)StackBehaviour.Push1 << 24));
+        public static readonly OpCode Neg = new((0xff << 0) | (0x65 << 8) | ((byte)Code.Neg << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Push1 << 24));
+        public static readonly OpCode Not = new((0xff << 0) | (0x66 << 8) | ((byte)Code.Not << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Push1 << 24));
+        public static readonly OpCode Conv_I1 = new((0xff << 0) | (0x67 << 8) | ((byte)Code.Conv_I1 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Conv_I2 = new((0xff << 0) | (0x68 << 8) | ((byte)Code.Conv_I2 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Conv_I4 = new((0xff << 0) | (0x69 << 8) | ((byte)Code.Conv_I4 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Conv_I8 = new((0xff << 0) | (0x6a << 8) | ((byte)Code.Conv_I8 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Pushi8 << 24));
+        public static readonly OpCode Conv_R4 = new((0xff << 0) | (0x6b << 8) | ((byte)Code.Conv_R4 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Pushr4 << 24));
+        public static readonly OpCode Conv_R8 = new((0xff << 0) | (0x6c << 8) | ((byte)Code.Conv_R8 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Pushr8 << 24));
+        public static readonly OpCode Conv_U4 = new((0xff << 0) | (0x6d << 8) | ((byte)Code.Conv_U4 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Conv_U8 = new((0xff << 0) | (0x6e << 8) | ((byte)Code.Conv_U8 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Pushi8 << 24));
+        public static readonly OpCode Callvirt = new((0xff << 0) | (0x6f << 8) | ((byte)Code.Callvirt << 16) | ((byte)FlowControl.Call << 24), ((byte)OpCodeType.Objmodel << 0) | ((byte)OperandType.InlineMethod << 8) | ((byte)StackBehaviour.Varpop << 16) | ((byte)StackBehaviour.Varpush << 24));
+        public static readonly OpCode Cpobj = new((0xff << 0) | (0x70 << 8) | ((byte)Code.Cpobj << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Objmodel << 0) | ((byte)OperandType.InlineType << 8) | ((byte)StackBehaviour.Popi_popi << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Ldobj = new((0xff << 0) | (0x71 << 8) | ((byte)Code.Ldobj << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Objmodel << 0) | ((byte)OperandType.InlineType << 8) | ((byte)StackBehaviour.Popi << 16) | ((byte)StackBehaviour.Push1 << 24));
+        public static readonly OpCode Ldstr = new((0xff << 0) | (0x72 << 8) | ((byte)Code.Ldstr << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Objmodel << 0) | ((byte)OperandType.InlineString << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Pushref << 24));
+        public static readonly OpCode Newobj = new((0xff << 0) | (0x73 << 8) | ((byte)Code.Newobj << 16) | ((byte)FlowControl.Call << 24), ((byte)OpCodeType.Objmodel << 0) | ((byte)OperandType.InlineMethod << 8) | ((byte)StackBehaviour.Varpop << 16) | ((byte)StackBehaviour.Pushref << 24));
+        public static readonly OpCode Castclass = new((0xff << 0) | (0x74 << 8) | ((byte)Code.Castclass << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Objmodel << 0) | ((byte)OperandType.InlineType << 8) | ((byte)StackBehaviour.Popref << 16) | ((byte)StackBehaviour.Pushref << 24));
+        public static readonly OpCode Isinst = new((0xff << 0) | (0x75 << 8) | ((byte)Code.Isinst << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Objmodel << 0) | ((byte)OperandType.InlineType << 8) | ((byte)StackBehaviour.Popref << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Conv_R_Un = new((0xff << 0) | (0x76 << 8) | ((byte)Code.Conv_R_Un << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Pushr8 << 24));
+        public static readonly OpCode Unbox = new((0xff << 0) | (0x79 << 8) | ((byte)Code.Unbox << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineType << 8) | ((byte)StackBehaviour.Popref << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Throw = new((0xff << 0) | (0x7a << 8) | ((byte)Code.Throw << 16) | ((byte)FlowControl.Throw << 24), ((byte)OpCodeType.Objmodel << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Popref << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Ldfld = new((0xff << 0) | (0x7b << 8) | ((byte)Code.Ldfld << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Objmodel << 0) | ((byte)OperandType.InlineField << 8) | ((byte)StackBehaviour.Popref << 16) | ((byte)StackBehaviour.Push1 << 24));
+        public static readonly OpCode Ldflda = new((0xff << 0) | (0x7c << 8) | ((byte)Code.Ldflda << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Objmodel << 0) | ((byte)OperandType.InlineField << 8) | ((byte)StackBehaviour.Popref << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Stfld = new((0xff << 0) | (0x7d << 8) | ((byte)Code.Stfld << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Objmodel << 0) | ((byte)OperandType.InlineField << 8) | ((byte)StackBehaviour.Popref_pop1 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Ldsfld = new((0xff << 0) | (0x7e << 8) | ((byte)Code.Ldsfld << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Objmodel << 0) | ((byte)OperandType.InlineField << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Push1 << 24));
+        public static readonly OpCode Ldsflda = new((0xff << 0) | (0x7f << 8) | ((byte)Code.Ldsflda << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Objmodel << 0) | ((byte)OperandType.InlineField << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Stsfld = new((0xff << 0) | (0x80 << 8) | ((byte)Code.Stsfld << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Objmodel << 0) | ((byte)OperandType.InlineField << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Stobj = new((0xff << 0) | (0x81 << 8) | ((byte)Code.Stobj << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Objmodel << 0) | ((byte)OperandType.InlineType << 8) | ((byte)StackBehaviour.Popi_pop1 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Conv_Ovf_I1_Un = new((0xff << 0) | (0x82 << 8) | ((byte)Code.Conv_Ovf_I1_Un << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Conv_Ovf_I2_Un = new((0xff << 0) | (0x83 << 8) | ((byte)Code.Conv_Ovf_I2_Un << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Conv_Ovf_I4_Un = new((0xff << 0) | (0x84 << 8) | ((byte)Code.Conv_Ovf_I4_Un << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Conv_Ovf_I8_Un = new((0xff << 0) | (0x85 << 8) | ((byte)Code.Conv_Ovf_I8_Un << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Pushi8 << 24));
+        public static readonly OpCode Conv_Ovf_U1_Un = new((0xff << 0) | (0x86 << 8) | ((byte)Code.Conv_Ovf_U1_Un << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Conv_Ovf_U2_Un = new((0xff << 0) | (0x87 << 8) | ((byte)Code.Conv_Ovf_U2_Un << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Conv_Ovf_U4_Un = new((0xff << 0) | (0x88 << 8) | ((byte)Code.Conv_Ovf_U4_Un << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Conv_Ovf_U8_Un = new((0xff << 0) | (0x89 << 8) | ((byte)Code.Conv_Ovf_U8_Un << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Pushi8 << 24));
+        public static readonly OpCode Conv_Ovf_I_Un = new((0xff << 0) | (0x8a << 8) | ((byte)Code.Conv_Ovf_I_Un << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Conv_Ovf_U_Un = new((0xff << 0) | (0x8b << 8) | ((byte)Code.Conv_Ovf_U_Un << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Box = new((0xff << 0) | (0x8c << 8) | ((byte)Code.Box << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineType << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Pushref << 24));
+        public static readonly OpCode Newarr = new((0xff << 0) | (0x8d << 8) | ((byte)Code.Newarr << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Objmodel << 0) | ((byte)OperandType.InlineType << 8) | ((byte)StackBehaviour.Popi << 16) | ((byte)StackBehaviour.Pushref << 24));
+        public static readonly OpCode Ldlen = new((0xff << 0) | (0x8e << 8) | ((byte)Code.Ldlen << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Objmodel << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Popref << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Ldelema = new((0xff << 0) | (0x8f << 8) | ((byte)Code.Ldelema << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Objmodel << 0) | ((byte)OperandType.InlineType << 8) | ((byte)StackBehaviour.Popref_popi << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Ldelem_I1 = new((0xff << 0) | (0x90 << 8) | ((byte)Code.Ldelem_I1 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Objmodel << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Popref_popi << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Ldelem_U1 = new((0xff << 0) | (0x91 << 8) | ((byte)Code.Ldelem_U1 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Objmodel << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Popref_popi << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Ldelem_I2 = new((0xff << 0) | (0x92 << 8) | ((byte)Code.Ldelem_I2 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Objmodel << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Popref_popi << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Ldelem_U2 = new((0xff << 0) | (0x93 << 8) | ((byte)Code.Ldelem_U2 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Objmodel << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Popref_popi << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Ldelem_I4 = new((0xff << 0) | (0x94 << 8) | ((byte)Code.Ldelem_I4 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Objmodel << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Popref_popi << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Ldelem_U4 = new((0xff << 0) | (0x95 << 8) | ((byte)Code.Ldelem_U4 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Objmodel << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Popref_popi << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Ldelem_I8 = new((0xff << 0) | (0x96 << 8) | ((byte)Code.Ldelem_I8 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Objmodel << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Popref_popi << 16) | ((byte)StackBehaviour.Pushi8 << 24));
+        public static readonly OpCode Ldelem_I = new((0xff << 0) | (0x97 << 8) | ((byte)Code.Ldelem_I << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Objmodel << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Popref_popi << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Ldelem_R4 = new((0xff << 0) | (0x98 << 8) | ((byte)Code.Ldelem_R4 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Objmodel << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Popref_popi << 16) | ((byte)StackBehaviour.Pushr4 << 24));
+        public static readonly OpCode Ldelem_R8 = new((0xff << 0) | (0x99 << 8) | ((byte)Code.Ldelem_R8 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Objmodel << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Popref_popi << 16) | ((byte)StackBehaviour.Pushr8 << 24));
+        public static readonly OpCode Ldelem_Ref = new((0xff << 0) | (0x9a << 8) | ((byte)Code.Ldelem_Ref << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Objmodel << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Popref_popi << 16) | ((byte)StackBehaviour.Pushref << 24));
+        public static readonly OpCode Stelem_I = new((0xff << 0) | (0x9b << 8) | ((byte)Code.Stelem_I << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Objmodel << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Popref_popi_popi << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Stelem_I1 = new((0xff << 0) | (0x9c << 8) | ((byte)Code.Stelem_I1 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Objmodel << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Popref_popi_popi << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Stelem_I2 = new((0xff << 0) | (0x9d << 8) | ((byte)Code.Stelem_I2 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Objmodel << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Popref_popi_popi << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Stelem_I4 = new((0xff << 0) | (0x9e << 8) | ((byte)Code.Stelem_I4 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Objmodel << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Popref_popi_popi << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Stelem_I8 = new((0xff << 0) | (0x9f << 8) | ((byte)Code.Stelem_I8 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Objmodel << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Popref_popi_popi8 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Stelem_R4 = new((0xff << 0) | (0xa0 << 8) | ((byte)Code.Stelem_R4 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Objmodel << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Popref_popi_popr4 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Stelem_R8 = new((0xff << 0) | (0xa1 << 8) | ((byte)Code.Stelem_R8 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Objmodel << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Popref_popi_popr8 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Stelem_Ref = new((0xff << 0) | (0xa2 << 8) | ((byte)Code.Stelem_Ref << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Objmodel << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Popref_popi_popref << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Ldelem_Any = new((0xff << 0) | (0xa3 << 8) | ((byte)Code.Ldelem_Any << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Objmodel << 0) | ((byte)OperandType.InlineType << 8) | ((byte)StackBehaviour.Popref_popi << 16) | ((byte)StackBehaviour.Push1 << 24));
+        public static readonly OpCode Stelem_Any = new((0xff << 0) | (0xa4 << 8) | ((byte)Code.Stelem_Any << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Objmodel << 0) | ((byte)OperandType.InlineType << 8) | ((byte)StackBehaviour.Popref_popi_popref << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Unbox_Any = new((0xff << 0) | (0xa5 << 8) | ((byte)Code.Unbox_Any << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Objmodel << 0) | ((byte)OperandType.InlineType << 8) | ((byte)StackBehaviour.Popref << 16) | ((byte)StackBehaviour.Push1 << 24));
+        public static readonly OpCode Conv_Ovf_I1 = new((0xff << 0) | (0xb3 << 8) | ((byte)Code.Conv_Ovf_I1 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Conv_Ovf_U1 = new((0xff << 0) | (0xb4 << 8) | ((byte)Code.Conv_Ovf_U1 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Conv_Ovf_I2 = new((0xff << 0) | (0xb5 << 8) | ((byte)Code.Conv_Ovf_I2 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Conv_Ovf_U2 = new((0xff << 0) | (0xb6 << 8) | ((byte)Code.Conv_Ovf_U2 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Conv_Ovf_I4 = new((0xff << 0) | (0xb7 << 8) | ((byte)Code.Conv_Ovf_I4 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Conv_Ovf_U4 = new((0xff << 0) | (0xb8 << 8) | ((byte)Code.Conv_Ovf_U4 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Conv_Ovf_I8 = new((0xff << 0) | (0xb9 << 8) | ((byte)Code.Conv_Ovf_I8 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Pushi8 << 24));
+        public static readonly OpCode Conv_Ovf_U8 = new((0xff << 0) | (0xba << 8) | ((byte)Code.Conv_Ovf_U8 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Pushi8 << 24));
+        public static readonly OpCode Refanyval = new((0xff << 0) | (0xc2 << 8) | ((byte)Code.Refanyval << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineType << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Ckfinite = new((0xff << 0) | (0xc3 << 8) | ((byte)Code.Ckfinite << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Pushr8 << 24));
+        public static readonly OpCode Mkrefany = new((0xff << 0) | (0xc6 << 8) | ((byte)Code.Mkrefany << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineType << 8) | ((byte)StackBehaviour.Popi << 16) | ((byte)StackBehaviour.Push1 << 24));
+        public static readonly OpCode Ldtoken = new((0xff << 0) | (0xd0 << 8) | ((byte)Code.Ldtoken << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineTok << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Conv_U2 = new((0xff << 0) | (0xd1 << 8) | ((byte)Code.Conv_U2 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Conv_U1 = new((0xff << 0) | (0xd2 << 8) | ((byte)Code.Conv_U1 << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Conv_I = new((0xff << 0) | (0xd3 << 8) | ((byte)Code.Conv_I << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Conv_Ovf_I = new((0xff << 0) | (0xd4 << 8) | ((byte)Code.Conv_Ovf_I << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Conv_Ovf_U = new((0xff << 0) | (0xd5 << 8) | ((byte)Code.Conv_Ovf_U << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Add_Ovf = new((0xff << 0) | (0xd6 << 8) | ((byte)Code.Add_Ovf << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1_pop1 << 16) | ((byte)StackBehaviour.Push1 << 24));
+        public static readonly OpCode Add_Ovf_Un = new((0xff << 0) | (0xd7 << 8) | ((byte)Code.Add_Ovf_Un << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1_pop1 << 16) | ((byte)StackBehaviour.Push1 << 24));
+        public static readonly OpCode Mul_Ovf = new((0xff << 0) | (0xd8 << 8) | ((byte)Code.Mul_Ovf << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1_pop1 << 16) | ((byte)StackBehaviour.Push1 << 24));
+        public static readonly OpCode Mul_Ovf_Un = new((0xff << 0) | (0xd9 << 8) | ((byte)Code.Mul_Ovf_Un << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1_pop1 << 16) | ((byte)StackBehaviour.Push1 << 24));
+        public static readonly OpCode Sub_Ovf = new((0xff << 0) | (0xda << 8) | ((byte)Code.Sub_Ovf << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1_pop1 << 16) | ((byte)StackBehaviour.Push1 << 24));
+        public static readonly OpCode Sub_Ovf_Un = new((0xff << 0) | (0xdb << 8) | ((byte)Code.Sub_Ovf_Un << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1_pop1 << 16) | ((byte)StackBehaviour.Push1 << 24));
+        public static readonly OpCode Endfinally = new((0xff << 0) | (0xdc << 8) | ((byte)Code.Endfinally << 16) | ((byte)FlowControl.Return << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Leave = new((0xff << 0) | (0xdd << 8) | ((byte)Code.Leave << 16) | ((byte)FlowControl.Branch << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineBrTarget << 8) | ((byte)StackBehaviour.PopAll << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Leave_S = new((0xff << 0) | (0xde << 8) | ((byte)Code.Leave_S << 16) | ((byte)FlowControl.Branch << 24), ((byte)OpCodeType.Macro << 0) | ((byte)OperandType.ShortInlineBrTarget << 8) | ((byte)StackBehaviour.PopAll << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Stind_I = new((0xff << 0) | (0xdf << 8) | ((byte)Code.Stind_I << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Popi_popi << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Conv_U = new((0xff << 0) | (0xe0 << 8) | ((byte)Code.Conv_U << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Arglist = new((0xfe << 0) | (0x00 << 8) | ((byte)Code.Arglist << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Ceq = new((0xfe << 0) | (0x01 << 8) | ((byte)Code.Ceq << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1_pop1 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Cgt = new((0xfe << 0) | (0x02 << 8) | ((byte)Code.Cgt << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1_pop1 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Cgt_Un = new((0xfe << 0) | (0x03 << 8) | ((byte)Code.Cgt_Un << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1_pop1 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Clt = new((0xfe << 0) | (0x04 << 8) | ((byte)Code.Clt << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1_pop1 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Clt_Un = new((0xfe << 0) | (0x05 << 8) | ((byte)Code.Clt_Un << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1_pop1 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Ldftn = new((0xfe << 0) | (0x06 << 8) | ((byte)Code.Ldftn << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineMethod << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Ldvirtftn = new((0xfe << 0) | (0x07 << 8) | ((byte)Code.Ldvirtftn << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineMethod << 8) | ((byte)StackBehaviour.Popref << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Ldarg = new((0xfe << 0) | (0x09 << 8) | ((byte)Code.Ldarg << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineArg << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Push1 << 24));
+        public static readonly OpCode Ldarga = new((0xfe << 0) | (0x0a << 8) | ((byte)Code.Ldarga << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineArg << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Starg = new((0xfe << 0) | (0x0b << 8) | ((byte)Code.Starg << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineArg << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Ldloc = new((0xfe << 0) | (0x0c << 8) | ((byte)Code.Ldloc << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineVar << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Push1 << 24));
+        public static readonly OpCode Ldloca = new((0xfe << 0) | (0x0d << 8) | ((byte)Code.Ldloca << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineVar << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Stloc = new((0xfe << 0) | (0x0e << 8) | ((byte)Code.Stloc << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineVar << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Localloc = new((0xfe << 0) | (0x0f << 8) | ((byte)Code.Localloc << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Popi << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Endfilter = new((0xfe << 0) | (0x11 << 8) | ((byte)Code.Endfilter << 16) | ((byte)FlowControl.Return << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Popi << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Unaligned = new((0xfe << 0) | (0x12 << 8) | ((byte)Code.Unaligned << 16) | ((byte)FlowControl.Meta << 24), ((byte)OpCodeType.Prefix << 0) | ((byte)OperandType.ShortInlineI << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Volatile = new((0xfe << 0) | (0x13 << 8) | ((byte)Code.Volatile << 16) | ((byte)FlowControl.Meta << 24), ((byte)OpCodeType.Prefix << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Tail = new((0xfe << 0) | (0x14 << 8) | ((byte)Code.Tail << 16) | ((byte)FlowControl.Meta << 24), ((byte)OpCodeType.Prefix << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Initobj = new((0xfe << 0) | (0x15 << 8) | ((byte)Code.Initobj << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Objmodel << 0) | ((byte)OperandType.InlineType << 8) | ((byte)StackBehaviour.Popi << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Constrained = new((0xfe << 0) | (0x16 << 8) | ((byte)Code.Constrained << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Prefix << 0) | ((byte)OperandType.InlineType << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Cpblk = new((0xfe << 0) | (0x17 << 8) | ((byte)Code.Cpblk << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Popi_popi_popi << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Initblk = new((0xfe << 0) | (0x18 << 8) | ((byte)Code.Initblk << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Popi_popi_popi << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode No = new((0xfe << 0) | (0x19 << 8) | ((byte)Code.No << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Prefix << 0) | ((byte)OperandType.ShortInlineI << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Rethrow = new((0xfe << 0) | (0x1a << 8) | ((byte)Code.Rethrow << 16) | ((byte)FlowControl.Throw << 24), ((byte)OpCodeType.Objmodel << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Push0 << 24));
+        public static readonly OpCode Sizeof = new((0xfe << 0) | (0x1c << 8) | ((byte)Code.Sizeof << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineType << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Refanytype = new((0xfe << 0) | (0x1d << 8) | ((byte)Code.Refanytype << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Primitive << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop1 << 16) | ((byte)StackBehaviour.Pushi << 24));
+        public static readonly OpCode Readonly = new((0xfe << 0) | (0x1e << 8) | ((byte)Code.Readonly << 16) | ((byte)FlowControl.Next << 24), ((byte)OpCodeType.Prefix << 0) | ((byte)OperandType.InlineNone << 8) | ((byte)StackBehaviour.Pop0 << 16) | ((byte)StackBehaviour.Push0 << 24));
+    }
+}

Assets/FishNet/CodeGenerating/cecil-0.11.4/Mono.Cecil.Cil/OpCodes.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 52c19a62321778c438d2f6b483f18e73
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/CodeGenerating/cecil-0.11.4/Mono.Cecil.Cil/OpCodes.cs
+  uploadId: 866910

Assets/FishNet/CodeGenerating/cecil-0.11.4/Mono.Cecil.Cil/PortablePdb.cs

@@ -0,0 +1,600 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using MonoFN.Cecil.Metadata;
+using MonoFN.Cecil.PE;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.IO.Compression;
+
+namespace MonoFN.Cecil.Cil
+{
+    public sealed class PortablePdbReaderProvider : ISymbolReaderProvider
+    {
+        public ISymbolReader GetSymbolReader(ModuleDefinition module, string fileName)
+        {
+            Mixin.CheckModule(module);
+            Mixin.CheckFileName(fileName);
+
+            FileStream file = File.OpenRead(Mixin.GetPdbFileName(fileName));
+            return GetSymbolReader(module, Disposable.Owned(file as Stream), file.Name);
+        }
+
+        public ISymbolReader GetSymbolReader(ModuleDefinition module, Stream symbolStream)
+        {
+            Mixin.CheckModule(module);
+            Mixin.CheckStream(symbolStream);
+
+            return GetSymbolReader(module, Disposable.NotOwned(symbolStream), symbolStream.GetFileName());
+        }
+
+        private ISymbolReader GetSymbolReader(ModuleDefinition module, Disposable<Stream> symbolStream, string fileName)
+        {
+            return new PortablePdbReader(ImageReader.ReadPortablePdb(symbolStream, fileName), module);
+        }
+    }
+
+    public sealed class PortablePdbReader : ISymbolReader
+    {
+        private readonly Image image;
+        private readonly ModuleDefinition module;
+        private readonly MetadataReader reader;
+        private readonly MetadataReader debug_reader;
+        private bool IsEmbedded
+        {
+            get { return reader.image == debug_reader.image; }
+        }
+
+        internal PortablePdbReader(Image image, ModuleDefinition module)
+        {
+            this.image = image;
+            this.module = module;
+            reader = module.reader;
+            debug_reader = new(image, module, reader);
+        }
+
+        public ISymbolWriterProvider GetWriterProvider()
+        {
+            return new PortablePdbWriterProvider();
+        }
+
+        public bool ProcessDebugHeader(ImageDebugHeader header)
+        {
+            if (image == module.Image)
+                return true;
+
+            foreach (ImageDebugHeaderEntry entry in header.Entries)
+            {
+                if (!IsMatchingEntry(image.PdbHeap, entry))
+                    continue;
+
+                ReadModule();
+                return true;
+            }
+
+            return false;
+        }
+
+        private static bool IsMatchingEntry(PdbHeap heap, ImageDebugHeaderEntry entry)
+        {
+            if (entry.Directory.Type != ImageDebugType.CodeView)
+                return false;
+
+            byte[] data = entry.Data;
+
+            if (data.Length < 24)
+                return false;
+
+            int magic = ReadInt32(data, 0);
+            if (magic != 0x53445352)
+                return false;
+
+            byte[] buffer = new byte [16];
+            Buffer.BlockCopy(data, 4, buffer, 0, 16);
+
+            Guid module_guid = new(buffer);
+
+            Buffer.BlockCopy(heap.Id, 0, buffer, 0, 16);
+
+            Guid pdb_guid = new(buffer);
+
+            return module_guid == pdb_guid;
+        }
+
+        private static int ReadInt32(byte[] bytes, int start)
+        {
+            return bytes[start] | (bytes[start + 1] << 8) | (bytes[start + 2] << 16) | (bytes[start + 3] << 24);
+        }
+
+        private void ReadModule()
+        {
+            module.custom_infos = debug_reader.GetCustomDebugInformation(module);
+        }
+
+        public MethodDebugInformation Read(MethodDefinition method)
+        {
+            MethodDebugInformation info = new(method);
+            ReadSequencePoints(info);
+            ReadScope(info);
+            ReadStateMachineKickOffMethod(info);
+            ReadCustomDebugInformations(info);
+            return info;
+        }
+
+        private void ReadSequencePoints(MethodDebugInformation method_info)
+        {
+            method_info.sequence_points = debug_reader.ReadSequencePoints(method_info.method);
+        }
+
+        private void ReadScope(MethodDebugInformation method_info)
+        {
+            method_info.scope = debug_reader.ReadScope(method_info.method);
+        }
+
+        private void ReadStateMachineKickOffMethod(MethodDebugInformation method_info)
+        {
+            method_info.kickoff_method = debug_reader.ReadStateMachineKickoffMethod(method_info.method);
+        }
+
+        private void ReadCustomDebugInformations(MethodDebugInformation info)
+        {
+            info.method.custom_infos = debug_reader.GetCustomDebugInformation(info.method);
+        }
+
+        public void Dispose()
+        {
+            if (IsEmbedded)
+                return;
+
+            image.Dispose();
+        }
+    }
+
+    public sealed class EmbeddedPortablePdbReaderProvider : ISymbolReaderProvider
+    {
+        public ISymbolReader GetSymbolReader(ModuleDefinition module, string fileName)
+        {
+            Mixin.CheckModule(module);
+
+            ImageDebugHeader header = module.GetDebugHeader();
+            ImageDebugHeaderEntry entry = header.GetEmbeddedPortablePdbEntry();
+            if (entry == null)
+                throw new InvalidOperationException();
+
+            return new EmbeddedPortablePdbReader((PortablePdbReader)new PortablePdbReaderProvider().GetSymbolReader(module, GetPortablePdbStream(entry)));
+        }
+
+        private static Stream GetPortablePdbStream(ImageDebugHeaderEntry entry)
+        {
+            MemoryStream compressed_stream = new(entry.Data);
+            BinaryStreamReader reader = new(compressed_stream);
+            reader.ReadInt32(); // signature
+            int length = reader.ReadInt32();
+            MemoryStream decompressed_stream = new(length);
+
+            using (DeflateStream deflate_stream = new(compressed_stream, CompressionMode.Decompress, leaveOpen: true))
+            {
+                deflate_stream.CopyTo(decompressed_stream);
+            }
+
+            return decompressed_stream;
+        }
+
+        public ISymbolReader GetSymbolReader(ModuleDefinition module, Stream symbolStream)
+        {
+            throw new NotSupportedException();
+        }
+    }
+
+    public sealed class EmbeddedPortablePdbReader : ISymbolReader
+    {
+        private readonly PortablePdbReader reader;
+
+        internal EmbeddedPortablePdbReader(PortablePdbReader reader)
+        {
+            if (reader == null)
+                throw new ArgumentNullException();
+
+            this.reader = reader;
+        }
+
+        public ISymbolWriterProvider GetWriterProvider()
+        {
+            return new EmbeddedPortablePdbWriterProvider();
+        }
+
+        public bool ProcessDebugHeader(ImageDebugHeader header)
+        {
+            return reader.ProcessDebugHeader(header);
+        }
+
+        public MethodDebugInformation Read(MethodDefinition method)
+        {
+            return reader.Read(method);
+        }
+
+        public void Dispose()
+        {
+            reader.Dispose();
+        }
+    }
+
+    public sealed class PortablePdbWriterProvider : ISymbolWriterProvider
+    {
+        public ISymbolWriter GetSymbolWriter(ModuleDefinition module, string fileName)
+        {
+            Mixin.CheckModule(module);
+            Mixin.CheckFileName(fileName);
+
+            FileStream file = File.OpenWrite(Mixin.GetPdbFileName(fileName));
+            return GetSymbolWriter(module, Disposable.Owned(file as Stream));
+        }
+
+        public ISymbolWriter GetSymbolWriter(ModuleDefinition module, Stream symbolStream)
+        {
+            Mixin.CheckModule(module);
+            Mixin.CheckStream(symbolStream);
+
+            return GetSymbolWriter(module, Disposable.NotOwned(symbolStream));
+        }
+
+        private ISymbolWriter GetSymbolWriter(ModuleDefinition module, Disposable<Stream> stream)
+        {
+            MetadataBuilder metadata = new(module, this);
+            ImageWriter writer = ImageWriter.CreateDebugWriter(module, metadata, stream);
+
+            return new PortablePdbWriter(metadata, module, writer);
+        }
+    }
+
+    public sealed class PortablePdbWriter : ISymbolWriter
+    {
+        private readonly MetadataBuilder pdb_metadata;
+        private readonly ModuleDefinition module;
+        private readonly ImageWriter writer;
+        private MetadataBuilder module_metadata;
+        private bool IsEmbedded
+        {
+            get { return writer == null; }
+        }
+
+        internal PortablePdbWriter(MetadataBuilder pdb_metadata, ModuleDefinition module)
+        {
+            this.pdb_metadata = pdb_metadata;
+            this.module = module;
+
+            module_metadata = module.metadata_builder;
+
+            if (module_metadata != pdb_metadata)
+                this.pdb_metadata.metadata_builder = module_metadata;
+
+            pdb_metadata.AddCustomDebugInformations(module);
+        }
+
+        internal PortablePdbWriter(MetadataBuilder pdb_metadata, ModuleDefinition module, ImageWriter writer) : this(pdb_metadata, module)
+        {
+            this.writer = writer;
+        }
+
+        public ISymbolReaderProvider GetReaderProvider()
+        {
+            return new PortablePdbReaderProvider();
+        }
+
+        public ImageDebugHeader GetDebugHeader()
+        {
+            if (IsEmbedded)
+                return new();
+
+            ImageDebugDirectory directory = new()
+            {
+                MajorVersion = 256,
+                MinorVersion = 20557,
+                Type = ImageDebugType.CodeView,
+                TimeDateStamp = (int)module.timestamp
+            };
+
+            ByteBuffer buffer = new();
+            // RSDS
+            buffer.WriteUInt32(0x53445352);
+            // Module ID
+            buffer.WriteBytes(module.Mvid.ToByteArray());
+            // PDB Age
+            buffer.WriteUInt32(1);
+            // PDB Path
+            string fileName = writer.BaseStream.GetFileName();
+            if (string.IsNullOrEmpty(fileName))
+            {
+                fileName = module.Assembly.Name.Name + ".pdb";
+            }
+            buffer.WriteBytes(System.Text.Encoding.UTF8.GetBytes(fileName));
+            buffer.WriteByte(0);
+
+            byte[] data = new byte [buffer.length];
+            Buffer.BlockCopy(buffer.buffer, 0, data, 0, buffer.length);
+            directory.SizeOfData = data.Length;
+
+            return new(new ImageDebugHeaderEntry(directory, data));
+        }
+
+        public void Write(MethodDebugInformation info)
+        {
+            CheckMethodDebugInformationTable();
+
+            pdb_metadata.AddMethodDebugInformation(info);
+        }
+
+        private void CheckMethodDebugInformationTable()
+        {
+            MethodDebugInformationTable mdi = pdb_metadata.table_heap.GetTable<MethodDebugInformationTable>(Table.MethodDebugInformation);
+            if (mdi.length > 0)
+                return;
+
+            // The MethodDebugInformation table has the same length as the Method table
+            mdi.rows = new Row<uint, uint> [module_metadata.method_rid - 1];
+            mdi.length = mdi.rows.Length;
+        }
+
+        public void Dispose()
+        {
+            if (IsEmbedded)
+                return;
+
+            WritePdbFile();
+        }
+
+        private void WritePdbFile()
+        {
+            WritePdbHeap();
+
+            WriteTableHeap();
+
+            writer.BuildMetadataTextMap();
+            writer.WriteMetadataHeader();
+            writer.WriteMetadata();
+
+            writer.Flush();
+            writer.stream.Dispose();
+        }
+
+        private void WritePdbHeap()
+        {
+            PdbHeapBuffer pdb_heap = pdb_metadata.pdb_heap;
+
+            pdb_heap.WriteBytes(module.Mvid.ToByteArray());
+            pdb_heap.WriteUInt32(module_metadata.timestamp);
+
+            pdb_heap.WriteUInt32(module_metadata.entry_point.ToUInt32());
+
+            TableHeapBuffer table_heap = module_metadata.table_heap;
+            MetadataTable[] tables = table_heap.tables;
+
+            ulong valid = 0;
+            for (int i = 0; i < tables.Length; i++)
+            {
+                if (tables[i] == null || tables[i].Length == 0)
+                    continue;
+
+                valid |= 1UL << i;
+            }
+
+            pdb_heap.WriteUInt64(valid);
+
+            for (int i = 0; i < tables.Length; i++)
+            {
+                if (tables[i] == null || tables[i].Length == 0)
+                    continue;
+
+                pdb_heap.WriteUInt32((uint)tables[i].Length);
+            }
+        }
+
+        private void WriteTableHeap()
+        {
+            pdb_metadata.table_heap.string_offsets = pdb_metadata.string_heap.WriteStrings();
+            pdb_metadata.table_heap.ComputeTableInformations();
+            pdb_metadata.table_heap.WriteTableHeap();
+        }
+    }
+
+    public sealed class EmbeddedPortablePdbWriterProvider : ISymbolWriterProvider
+    {
+        public ISymbolWriter GetSymbolWriter(ModuleDefinition module, string fileName)
+        {
+            Mixin.CheckModule(module);
+            Mixin.CheckFileName(fileName);
+
+            MemoryStream stream = new();
+            PortablePdbWriter pdb_writer = (PortablePdbWriter)new PortablePdbWriterProvider().GetSymbolWriter(module, stream);
+            return new EmbeddedPortablePdbWriter(stream, pdb_writer);
+        }
+
+        public ISymbolWriter GetSymbolWriter(ModuleDefinition module, Stream symbolStream)
+        {
+            throw new NotSupportedException();
+        }
+    }
+
+    public sealed class EmbeddedPortablePdbWriter : ISymbolWriter
+    {
+        private readonly Stream stream;
+        private readonly PortablePdbWriter writer;
+
+        internal EmbeddedPortablePdbWriter(Stream stream, PortablePdbWriter writer)
+        {
+            this.stream = stream;
+            this.writer = writer;
+        }
+
+        public ISymbolReaderProvider GetReaderProvider()
+        {
+            return new EmbeddedPortablePdbReaderProvider();
+        }
+
+        public ImageDebugHeader GetDebugHeader()
+        {
+            writer.Dispose();
+
+            ImageDebugDirectory directory = new()
+            {
+                Type = ImageDebugType.EmbeddedPortablePdb,
+                MajorVersion = 0x0100,
+                MinorVersion = 0x0100
+            };
+
+            MemoryStream data = new();
+
+            BinaryStreamWriter w = new(data);
+            w.WriteByte(0x4d);
+            w.WriteByte(0x50);
+            w.WriteByte(0x44);
+            w.WriteByte(0x42);
+
+            w.WriteInt32((int)stream.Length);
+
+            stream.Position = 0;
+
+            using (DeflateStream compress_stream = new(data, CompressionMode.Compress, leaveOpen: true))
+            {
+                stream.CopyTo(compress_stream);
+            }
+
+            directory.SizeOfData = (int)data.Length;
+
+            return new(new[]
+            {
+                writer.GetDebugHeader().Entries[0],
+                new ImageDebugHeaderEntry(directory, data.ToArray())
+            });
+        }
+
+        public void Write(MethodDebugInformation info)
+        {
+            writer.Write(info);
+        }
+
+        public void Dispose() { }
+    }
+
+    internal static class PdbGuidMapping
+    {
+        private static readonly Dictionary<Guid, DocumentLanguage> guid_language = new();
+        private static readonly Dictionary<DocumentLanguage, Guid> language_guid = new();
+
+        static PdbGuidMapping()
+        {
+            AddMapping(DocumentLanguage.C, new("63a08714-fc37-11d2-904c-00c04fa302a1"));
+            AddMapping(DocumentLanguage.Cpp, new("3a12d0b7-c26c-11d0-b442-00a0244a1dd2"));
+            AddMapping(DocumentLanguage.CSharp, new("3f5162f8-07c6-11d3-9053-00c04fa302a1"));
+            AddMapping(DocumentLanguage.Basic, new("3a12d0b8-c26c-11d0-b442-00a0244a1dd2"));
+            AddMapping(DocumentLanguage.Java, new("3a12d0b4-c26c-11d0-b442-00a0244a1dd2"));
+            AddMapping(DocumentLanguage.Cobol, new("af046cd1-d0e1-11d2-977c-00a0c9b4d50c"));
+            AddMapping(DocumentLanguage.Pascal, new("af046cd2-d0e1-11d2-977c-00a0c9b4d50c"));
+            AddMapping(DocumentLanguage.Cil, new("af046cd3-d0e1-11d2-977c-00a0c9b4d50c"));
+            AddMapping(DocumentLanguage.JScript, new("3a12d0b6-c26c-11d0-b442-00a0244a1dd2"));
+            AddMapping(DocumentLanguage.Smc, new("0d9b9f7b-6611-11d3-bd2a-0000f80849bd"));
+            AddMapping(DocumentLanguage.MCpp, new("4b35fde8-07c6-11d3-9053-00c04fa302a1"));
+            AddMapping(DocumentLanguage.FSharp, new("ab4f38c9-b6e6-43ba-be3b-58080b2ccce3"));
+        }
+
+        private static void AddMapping(DocumentLanguage language, Guid guid)
+        {
+            guid_language.Add(guid, language);
+            language_guid.Add(language, guid);
+        }
+
+        private static readonly Guid type_text = new("5a869d0b-6611-11d3-bd2a-0000f80849bd");
+
+        public static DocumentType ToType(this Guid guid)
+        {
+            if (guid == type_text)
+                return DocumentType.Text;
+
+            return DocumentType.Other;
+        }
+
+        public static Guid ToGuid(this DocumentType type)
+        {
+            if (type == DocumentType.Text)
+                return type_text;
+
+            return new();
+        }
+
+        private static readonly Guid hash_md5 = new("406ea660-64cf-4c82-b6f0-42d48172a799");
+        private static readonly Guid hash_sha1 = new("ff1816ec-aa5e-4d10-87f7-6f4963833460");
+        private static readonly Guid hash_sha256 = new("8829d00f-11b8-4213-878b-770e8597ac16");
+
+        public static DocumentHashAlgorithm ToHashAlgorithm(this Guid guid)
+        {
+            if (guid == hash_md5)
+                return DocumentHashAlgorithm.MD5;
+
+            if (guid == hash_sha1)
+                return DocumentHashAlgorithm.SHA1;
+
+            if (guid == hash_sha256)
+                return DocumentHashAlgorithm.SHA256;
+
+            return DocumentHashAlgorithm.None;
+        }
+
+        public static Guid ToGuid(this DocumentHashAlgorithm hash_algo)
+        {
+            if (hash_algo == DocumentHashAlgorithm.MD5)
+                return hash_md5;
+
+            if (hash_algo == DocumentHashAlgorithm.SHA1)
+                return hash_sha1;
+
+            if (hash_algo == DocumentHashAlgorithm.SHA256)
+                return hash_sha256;
+
+            return new();
+        }
+
+        public static DocumentLanguage ToLanguage(this Guid guid)
+        {
+            DocumentLanguage language;
+            if (!guid_language.TryGetValue(guid, out language))
+                return DocumentLanguage.Other;
+
+            return language;
+        }
+
+        public static Guid ToGuid(this DocumentLanguage language)
+        {
+            Guid guid;
+            if (!language_guid.TryGetValue(language, out guid))
+                return new();
+
+            return guid;
+        }
+
+        private static readonly Guid vendor_ms = new("994b45c4-e6e9-11d2-903f-00c04fa302a1");
+
+        public static DocumentLanguageVendor ToVendor(this Guid guid)
+        {
+            if (guid == vendor_ms)
+                return DocumentLanguageVendor.Microsoft;
+
+            return DocumentLanguageVendor.Other;
+        }
+
+        public static Guid ToGuid(this DocumentLanguageVendor vendor)
+        {
+            if (vendor == DocumentLanguageVendor.Microsoft)
+                return vendor_ms;
+
+            return new();
+        }
+    }
+}

Assets/FishNet/CodeGenerating/cecil-0.11.4/Mono.Cecil.Cil/PortablePdb.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 34e2f5d4b9b9ea542bec15f2d9acc3ed
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/CodeGenerating/cecil-0.11.4/Mono.Cecil.Cil/PortablePdb.cs
+  uploadId: 866910

Assets/FishNet/CodeGenerating/cecil-0.11.4/Mono.Cecil.Cil/SequencePoint.cs

@@ -0,0 +1,50 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+using System;
+
+namespace MonoFN.Cecil.Cil
+{
+    public sealed class SequencePoint
+    {
+        internal InstructionOffset offset;
+        public int Offset
+        {
+            get { return offset.Offset; }
+        }
+        public int StartLine { get; set; }
+        public int StartColumn { get; set; }
+        public int EndLine { get; set; }
+        public int EndColumn { get; set; }
+        public bool IsHidden
+        {
+            get { return StartLine == 0xfeefee && StartLine == EndLine; }
+        }
+        public Document Document { get; set; }
+
+        internal SequencePoint(int offset, Document document)
+        {
+            if (document == null)
+                throw new ArgumentNullException("document");
+
+            this.offset = new(offset);
+            this.Document = document;
+        }
+
+        public SequencePoint(Instruction instruction, Document document)
+        {
+            if (document == null)
+                throw new ArgumentNullException("document");
+
+            offset = new(instruction);
+            this.Document = document;
+        }
+    }
+}

Assets/FishNet/CodeGenerating/cecil-0.11.4/Mono.Cecil.Cil/SequencePoint.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 612e6675dca63a84b9e8aaeb3e3b9ec6
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/CodeGenerating/cecil-0.11.4/Mono.Cecil.Cil/SequencePoint.cs
+  uploadId: 866910

Assets/FishNet/CodeGenerating/cecil-0.11.4/Mono.Cecil.Cil/Symbols.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: de9ae158807f471449a81d9b8b3e3c4e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/CodeGenerating/cecil-0.11.4/Mono.Cecil.Cil/Symbols.cs
+  uploadId: 866910

Assets/FishNet/CodeGenerating/cecil-0.11.4/Mono.Cecil.Cil/VariableDefinition.cs

@@ -0,0 +1,26 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+namespace MonoFN.Cecil.Cil
+{
+    public sealed class VariableDefinition : VariableReference
+    {
+        public bool IsPinned
+        {
+            get { return variable_type.IsPinned; }
+        }
+        public VariableDefinition(TypeReference variableType) : base(variableType) { }
+
+        public override VariableDefinition Resolve()
+        {
+            return this;
+        }
+    }
+}

Assets/FishNet/CodeGenerating/cecil-0.11.4/Mono.Cecil.Cil/VariableDefinition.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 1346fa5ba8ac9e8418cc20d2d7d0ad21
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/CodeGenerating/cecil-0.11.4/Mono.Cecil.Cil/VariableDefinition.cs
+  uploadId: 866910

Assets/FishNet/CodeGenerating/cecil-0.11.4/Mono.Cecil.Cil/VariableReference.cs

@@ -0,0 +1,42 @@
+//
+// Author:
+//   Jb Evain (jbevain@gmail.com)
+//
+// Copyright (c) 2008 - 2015 Jb Evain
+// Copyright (c) 2008 - 2011 Novell, Inc.
+//
+// Licensed under the MIT/X11 license.
+//
+
+namespace MonoFN.Cecil.Cil
+{
+    public abstract class VariableReference
+    {
+        internal int index = -1;
+        protected TypeReference variable_type;
+        public TypeReference VariableType
+        {
+            get { return variable_type; }
+            set { variable_type = value; }
+        }
+        public int Index
+        {
+            get { return index; }
+        }
+
+        internal VariableReference(TypeReference variable_type)
+        {
+            this.variable_type = variable_type;
+        }
+
+        public abstract VariableDefinition Resolve();
+
+        public override string ToString()
+        {
+            if (index >= 0)
+                return "V_" + index;
+
+            return string.Empty;
+        }
+    }
+}

Assets/FishNet/CodeGenerating/cecil-0.11.4/Mono.Cecil.Cil/VariableReference.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: b5dca1eaac23bfd4ba8e881302a72e33
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 207815
+  packageName: 'FishNet: Networking Evolved'
+  packageVersion: 4.6.22R
+  assetPath: Assets/FishNet/CodeGenerating/cecil-0.11.4/Mono.Cecil.Cil/VariableReference.cs
+  uploadId: 866910