Add StickGame Assets

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

@@ -0,0 +1,234 @@
+//
+// 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,
+	}
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2619210c5ef352b4aac70d8e5fab7a43
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -0,0 +1,663 @@
+//
+// 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 {
+
+	sealed class CodeReader : BinaryStreamReader {
+
+		readonly internal MetadataReader reader;
+
+		int start;
+
+		MethodDefinition method;
+		MethodBody body;
+
+		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;
+			this.reader.context = method;
+			var position = this.Position;
+			this.Position = (int)reader.image.ResolveVirtualAddress ((uint)method.RVA);
+			return position;
+		}
+
+		public void MoveBackTo (int position)
+		{
+			this.reader.context = null;
+			this.Position = position;
+		}
+
+		public MethodBody ReadMethodBody (MethodDefinition method)
+		{
+			var position = MoveTo (method);
+			this.body = new MethodBody (method);
+
+			ReadMethodBody ();
+
+			MoveBackTo (position);
+			return this.body;
+		}
+
+		public int ReadCodeSize (MethodDefinition method)
+		{
+			var position = MoveTo (method);
+
+			var code_size = ReadCodeSize ();
+
+			MoveBackTo (position);
+			return code_size;
+		}
+
+		int ReadCodeSize ()
+		{
+			var 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 ();
+			}
+		}
+
+		void ReadMethodBody ()
+		{
+			var 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 ();
+			}
+
+			var 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 ();
+		}
+
+		void ReadFatMethod ()
+		{
+			var flags = ReadUInt16 ();
+			body.max_stack_size = ReadUInt16 ();
+			body.code_size = (int)ReadUInt32 ();
+			body.local_var_token = new MetadataToken (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)
+		{
+			var position = reader.position;
+			var variables = reader.ReadVariables (local_var_token, method);
+			reader.position = position;
+
+			return variables;
+		}
+
+		void ReadCode ()
+		{
+			start = Position;
+			var code_size = body.code_size;
+
+			if (code_size < 0 || Length <= (uint)(code_size + Position))
+				code_size = 0;
+
+			var end = start + code_size;
+			var instructions = body.instructions = new InstructionCollection (method, (code_size + 1) / 2);
+
+			while (Position < end) {
+				var offset = Position - start;
+				var opcode = ReadOpCode ();
+				var current = new Instruction (offset, opcode);
+
+				if (opcode.OperandType != OperandType.InlineNone)
+					current.operand = ReadOperand (current);
+
+				instructions.Add (current);
+			}
+
+			ResolveBranches (instructions);
+		}
+
+		OpCode ReadOpCode ()
+		{
+			var il_opcode = ReadByte ();
+			return il_opcode != 0xfe
+				? OpCodes.OneByteOpCode [il_opcode]
+				: OpCodes.TwoBytesOpCode [ReadByte ()];
+		}
+
+		object ReadOperand (Instruction instruction)
+		{
+			switch (instruction.opcode.OperandType) {
+			case OperandType.InlineSwitch:
+				var length = ReadInt32 ();
+				var base_offset = Offset + (4 * length);
+				var 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);
+		}
+
+		void ResolveBranches (Collection<Instruction> instructions)
+		{
+			var items = instructions.items;
+			var size = instructions.size;
+
+			for (int i = 0; i < size; i++) {
+				var instruction = items [i];
+				switch (instruction.opcode.OperandType) {
+				case OperandType.ShortInlineBrTarget:
+				case OperandType.InlineBrTarget:
+					instruction.operand = GetInstruction ((int)instruction.operand);
+					break;
+				case OperandType.InlineSwitch:
+					var offsets = (int [])instruction.operand;
+					var branches = new Instruction [offsets.Length];
+					for (int j = 0; j < offsets.Length; j++)
+						branches [j] = GetInstruction (offsets [j]);
+
+					instruction.operand = branches;
+					break;
+				}
+			}
+		}
+
+		Instruction GetInstruction (int offset)
+		{
+			return GetInstruction (body.Instructions, offset);
+		}
+
+		static Instruction GetInstruction (Collection<Instruction> instructions, int offset)
+		{
+			var size = instructions.size;
+			var 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);
+				var instruction = items [mid];
+				var instruction_offset = instruction.offset;
+
+				if (offset == instruction_offset)
+					return instruction;
+
+				if (offset < instruction_offset)
+					max = mid - 1;
+				else
+					min = mid + 1;
+			}
+
+			return null;
+		}
+
+		void ReadSection ()
+		{
+			Align (4);
+
+			const byte fat_format = 0x40;
+			const byte more_sects = 0x80;
+
+			var flags = ReadByte ();
+			if ((flags & fat_format) == 0)
+				ReadSmallSection ();
+			else
+				ReadFatSection ();
+
+			if ((flags & more_sects) != 0)
+				ReadSection ();
+		}
+
+		void ReadSmallSection ()
+		{
+			var count = ReadByte () / 12;
+			Advance (2);
+
+			ReadExceptionHandlers (
+				count,
+				() => (int)ReadUInt16 (),
+				() => (int)ReadByte ());
+		}
+
+		void ReadFatSection ()
+		{
+			Advance (-1);
+			var count = (ReadInt32 () >> 8) / 24;
+
+			ReadExceptionHandlers (
+				count,
+				ReadInt32,
+				ReadInt32);
+		}
+
+		// inline ?
+		void ReadExceptionHandlers (int count, Func<int> read_entry, Func<int> read_length)
+		{
+			for (int i = 0; i < count; i++) {
+				var handler = new ExceptionHandler (
+					(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);
+
+				this.body.ExceptionHandlers.Add (handler);
+			}
+		}
+
+		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 MetadataToken (ReadUInt32 ());
+		}
+
+		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);
+		}
+
+		void ReadCustomDebugInformations (MethodDefinition method)
+		{
+			var custom_infos = method.custom_infos;
+
+			for (int i = 0; i < custom_infos.Count; i++) {
+				var state_machine_scope = custom_infos [i] as StateMachineScopeDebugInformation;
+				if (state_machine_scope != null)
+					ReadStateMachineScope (state_machine_scope);
+
+				var async_method = custom_infos [i] as AsyncMethodBodyDebugInformation;
+				if (async_method != null)
+					ReadAsyncMethodBody (async_method);
+			}
+		}
+
+		void ReadAsyncMethodBody (AsyncMethodBodyDebugInformation async_method)
+		{
+			if (async_method.catch_handler.Offset > -1)
+				async_method.catch_handler = new InstructionOffset (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 InstructionOffset (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 InstructionOffset (GetInstruction (async_method.resumes [i].Offset));
+		}
+
+		void ReadStateMachineScope (StateMachineScopeDebugInformation state_machine_scope)
+		{
+			if (state_machine_scope.scopes.IsNullOrEmpty ())
+				return;
+
+			foreach (var scope in state_machine_scope.scopes) {
+				scope.start = new InstructionOffset (GetInstruction (scope.start.Offset));
+
+				var end_instruction = GetInstruction (scope.end.Offset);
+				scope.end = end_instruction == null
+					? new InstructionOffset ()
+					: new InstructionOffset (end_instruction);
+			}
+		}
+
+		void ReadSequencePoints ()
+		{
+			var symbol = method.debug_info;
+
+			for (int i = 0; i < symbol.sequence_points.Count; i++) {
+				var sequence_point = symbol.sequence_points [i];
+				var instruction = GetInstruction (sequence_point.Offset);
+				if (instruction != null)
+					sequence_point.offset = new InstructionOffset (instruction);
+			}
+		}
+
+		void ReadScopes (Collection<ScopeDebugInformation> scopes)
+		{
+			for (int i = 0; i < scopes.Count; i++)
+				ReadScope (scopes [i]);
+		}
+
+		void ReadScope (ScopeDebugInformation scope)
+		{
+			var start_instruction = GetInstruction (scope.Start.Offset);
+			if (start_instruction != null)
+				scope.Start = new InstructionOffset (start_instruction);
+
+			var end_instruction = GetInstruction (scope.End.Offset);
+			scope.End = end_instruction != null
+				? new InstructionOffset (end_instruction)
+				: new InstructionOffset ();
+
+			if (!scope.variables.IsNullOrEmpty ()) {
+				for (int i = 0; i < scope.variables.Count; i++) {
+					var variable_info = scope.variables [i];
+					var variable = GetVariable (variable_info.Index);
+					if (variable != null)
+						variable_info.index = new VariableIndex (variable);
+				}
+			}
+
+			if (!scope.scopes.IsNullOrEmpty ())
+				ReadScopes (scope.scopes);
+		}
+
+		public ByteBuffer PatchRawMethodBody (MethodDefinition method, CodeWriter writer, out int code_size, out MetadataToken local_var_token)
+		{
+			var position = MoveTo (method);
+
+			var buffer = new ByteBuffer ();
+
+			var 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;
+		}
+
+		void PatchRawFatMethod (ByteBuffer buffer, CodeWriter writer, out int code_size, out MetadataToken local_var_token)
+		{
+			var 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) {
+				var 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);
+		}
+
+		void PatchRawCode (ByteBuffer buffer, int code_size, CodeWriter writer)
+		{
+			var metadata = writer.metadata;
+			buffer.WriteBytes (ReadBytes (code_size));
+			var end = buffer.position;
+			buffer.position -= code_size;
+
+			while (buffer.position < end) {
+				OpCode opcode;
+				var il_opcode = buffer.ReadByte ();
+				if (il_opcode != 0xfe) {
+					opcode = OpCodes.OneByteOpCode [il_opcode];
+				} else {
+					var 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:
+					var length = buffer.ReadInt32 ();
+					buffer.position += length * 4;
+					break;
+				case OperandType.InlineString:
+					var @string = GetString (new MetadataToken (buffer.ReadUInt32 ()));
+					buffer.position -= 4;
+					buffer.WriteUInt32 (
+						new MetadataToken (
+							TokenType.String,
+							metadata.user_string_heap.GetStringIndex (@string)).ToUInt32 ());
+					break;
+				case OperandType.InlineSig:
+					var call_site = GetCallSite (new MetadataToken (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:
+					var provider = reader.LookupToken (new MetadataToken (buffer.ReadUInt32 ()));
+					buffer.position -= 4;
+					buffer.WriteUInt32 (metadata.LookupToken (provider).ToUInt32 ());
+					break;
+				}
+			}
+		}
+
+		void PatchRawSection (ByteBuffer buffer, MetadataBuilder metadata)
+		{
+			var position = Position;
+			Align (4);
+			buffer.WriteBytes (Position - position);
+
+			const byte fat_format = 0x40;
+			const byte more_sects = 0x80;
+
+			var 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);
+		}
+
+		void PatchRawSmallSection (ByteBuffer buffer, MetadataBuilder metadata)
+		{
+			var length = ReadByte ();
+			buffer.WriteByte (length);
+			Advance (2);
+
+			buffer.WriteUInt16 (0);
+
+			var count = length / 12;
+
+			PatchRawExceptionHandlers (buffer, metadata, count, false);
+		}
+
+		void PatchRawFatSection (ByteBuffer buffer, MetadataBuilder metadata)
+		{
+			Advance (-1);
+			var length = ReadInt32 ();
+			buffer.WriteInt32 (length);
+
+			var count = (length >> 8) / 24;
+
+			PatchRawExceptionHandlers (buffer, metadata, count, true);
+		}
+
+		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) {
+					var type = ReadUInt32 ();
+					handler_type = (ExceptionHandlerType)(type & 0x7);
+					buffer.WriteUInt32 (type);
+				} else {
+					var 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:
+					var exception = reader.LookupToken (ReadToken ());
+					buffer.WriteUInt32 (metadata.LookupToken (exception).ToUInt32 ());
+					break;
+				default:
+					buffer.WriteUInt32 (ReadUInt32 ());
+					break;
+				}
+			}
+		}
+	}
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 451f6a2407c53554f9a16eeb62d806ce
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -0,0 +1,651 @@
+//
+// 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 {
+
+	sealed class CodeWriter : ByteBuffer {
+
+		readonly RVA code_base;
+		internal readonly MetadataBuilder metadata;
+		readonly Dictionary<uint, MetadataToken> standalone_signatures;
+		readonly Dictionary<ByteBuffer, RVA> tiny_method_bodies;
+
+		MethodBody body;
+
+		public CodeWriter (MetadataBuilder metadata)
+			: base (0)
+		{
+			this.code_base = metadata.text_map.GetNextRVA (TextSegment.CLIHeader);
+			this.metadata = metadata;
+			this.standalone_signatures = new Dictionary<uint, MetadataToken> ();
+			this.tiny_method_bodies = new Dictionary<ByteBuffer, RVA> (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;
+		}
+
+		static bool IsEmptyMethodBody (MethodBody body)
+		{
+			return body.instructions.IsNullOrEmpty ()
+				&& body.variables.IsNullOrEmpty ();
+		}
+
+		static bool IsUnresolved (MethodDefinition method)
+		{
+			return method.HasBody && method.HasImage && method.body == null;
+		}
+
+		RVA WriteUnresolvedMethodBody (MethodDefinition method)
+		{
+			var code_reader = metadata.module.reader.code;
+
+			int code_size;
+			MetadataToken local_var_token;
+			var raw_body = code_reader.PatchRawMethodBody (method, this, out code_size, out local_var_token);
+			var fat_header = (raw_body.buffer [0] & 0x3) == 0x3;
+			if (fat_header)
+				Align (4);
+
+			var rva = BeginMethod ();
+
+			if (fat_header || !GetOrMapTinyMethodBody (raw_body, ref rva)) {
+				WriteBytes (raw_body);
+			}
+
+			if (method.debug_info == null)
+				return rva;
+
+			var 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;
+		}
+
+		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 ();
+
+				var start_position = (int)(rva - code_base);
+				var body_size = position - start_position;
+				var body_bytes = new byte [body_size];
+
+				Array.Copy (buffer, start_position, body_bytes, 0, body_size);
+
+				if (GetOrMapTinyMethodBody (new ByteBuffer (body_bytes), ref rva))
+					position = start_position;
+			}
+
+			var 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;
+		}
+
+		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;
+		}
+
+		void WriteFatHeader ()
+		{
+			var 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);
+		}
+
+		void WriteInstructions ()
+		{
+			var instructions = body.Instructions;
+			var items = instructions.items;
+			var size = instructions.size;
+
+			for (int i = 0; i < size; i++) {
+				var instruction = items [i];
+				WriteOpCode (instruction.opcode);
+				WriteOperand (instruction);
+			}
+		}
+
+		void WriteOpCode (OpCode opcode)
+		{
+			if (opcode.Size == 1) {
+				WriteByte (opcode.Op2);
+			} else {
+				WriteByte (opcode.Op1);
+				WriteByte (opcode.Op2);
+			}
+		}
+
+		void WriteOperand (Instruction instruction)
+		{
+			var opcode = instruction.opcode;
+			var operand_type = opcode.OperandType;
+			if (operand_type == OperandType.InlineNone)
+				return;
+
+			var operand = instruction.operand;
+			if (operand == null && !(operand_type == OperandType.InlineBrTarget || operand_type == OperandType.ShortInlineBrTarget)) {
+				throw new ArgumentException ();
+			}
+
+			switch (operand_type) {
+			case OperandType.InlineSwitch: {
+					var targets = (Instruction [])operand;
+					WriteInt32 (targets.Length);
+					var 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: {
+					var target = (Instruction)operand;
+					var offset = target != null ? GetTargetOffset (target) : body.code_size;
+					WriteSByte ((sbyte)(offset - (instruction.Offset + opcode.Size + 1)));
+					break;
+				}
+			case OperandType.InlineBrTarget: {
+					var target = (Instruction)operand;
+					var 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 MetadataToken (
+						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 ();
+			}
+		}
+
+		int GetTargetOffset (Instruction instruction)
+		{
+			if (instruction == null) {
+				var last = body.instructions [body.instructions.size - 1];
+				return last.offset + last.GetSize ();
+			}
+
+			return instruction.offset;
+		}
+
+		uint GetUserStringIndex (string @string)
+		{
+			if (@string == null)
+				return 0;
+
+			return metadata.user_string_heap.GetStringIndex (@string);
+		}
+
+		static int GetVariableIndex (VariableDefinition variable)
+		{
+			return variable.Index;
+		}
+
+		int GetParameterIndex (ParameterDefinition parameter)
+		{
+			if (body.method.HasThis) {
+				if (parameter == body.this_parameter)
+					return 0;
+
+				return parameter.Index + 1;
+			}
+
+			return parameter.Index;
+		}
+
+		bool RequiresFatHeader ()
+		{
+			var body = this.body;
+			return body.CodeSize >= 64
+				|| body.InitLocals
+				|| body.HasVariables
+				|| body.HasExceptionHandlers
+				|| body.MaxStackSize > 8;
+		}
+
+		void ComputeHeader ()
+		{
+			int offset = 0;
+			var instructions = body.instructions;
+			var items = instructions.items;
+			var count = instructions.size;
+			var stack_size = 0;
+			var max_stack = 0;
+			Dictionary<Instruction, int> stack_sizes = null;
+
+			if (body.HasExceptionHandlers)
+				ComputeExceptionHandlerStackSize (ref stack_sizes);
+
+			for (int i = 0; i < count; i++) {
+				var 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;
+		}
+
+		void ComputeExceptionHandlerStackSize (ref Dictionary<Instruction, int> stack_sizes)
+		{
+			var exception_handlers = body.ExceptionHandlers;
+
+			for (int i = 0; i < exception_handlers.Count; i++) {
+				var 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;
+				}
+			}
+		}
+
+		static void AddExceptionStackSize (Instruction handler_start, ref Dictionary<Instruction, int> stack_sizes)
+		{
+			if (handler_start == null)
+				return;
+
+			if (stack_sizes == null)
+				stack_sizes = new Dictionary<Instruction, int> ();
+
+			stack_sizes [handler_start] = 1;
+		}
+
+		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 = System.Math.Max (max_stack, stack_size);
+			ComputeStackDelta (instruction, ref stack_size);
+			max_stack = System.Math.Max (max_stack, stack_size);
+
+			CopyBranchStackSize (instruction, ref stack_sizes, stack_size);
+			ComputeStackSize (instruction, ref stack_size);
+		}
+
+		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:
+				var targets = (Instruction [])instruction.operand;
+				for (int i = 0; i < targets.Length; i++)
+					CopyBranchStackSize (ref stack_sizes, targets [i], stack_size);
+				break;
+			}
+		}
+
+		static void CopyBranchStackSize (ref Dictionary<Instruction, int> stack_sizes, Instruction target, int stack_size)
+		{
+			if (stack_sizes == null)
+				stack_sizes = new Dictionary<Instruction, int> ();
+
+			int branch_stack_size = stack_size;
+
+			int computed_size;
+			if (stack_sizes.TryGetValue (target, out computed_size))
+				branch_stack_size = System.Math.Max (branch_stack_size, computed_size);
+
+			stack_sizes [target] = branch_stack_size;
+		}
+
+		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;
+			}
+		}
+
+		static void ComputeStackDelta (Instruction instruction, ref int stack_size)
+		{
+			switch (instruction.opcode.FlowControl) {
+			case FlowControl.Call: {
+					var 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;
+			}
+		}
+
+		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;
+			}
+		}
+
+		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;
+			}
+		}
+
+		void WriteExceptionHandlers ()
+		{
+			Align (4);
+
+			var handlers = body.ExceptionHandlers;
+
+			if (handlers.Count < 0x15 && !RequiresFatSection (handlers))
+				WriteSmallSection (handlers);
+			else
+				WriteFatSection (handlers);
+		}
+
+		static bool RequiresFatSection (Collection<ExceptionHandler> handlers)
+		{
+			for (int i = 0; i < handlers.Count; i++) {
+				var 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;
+		}
+
+		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;
+		}
+
+		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));
+		}
+
+		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);
+		}
+
+		void WriteExceptionHandlers (Collection<ExceptionHandler> handlers, Action<int> write_entry, Action<int> write_length)
+		{
+			for (int i = 0; i < handlers.Count; i++) {
+				var 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);
+			}
+		}
+
+		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)
+		{
+			var signature = metadata.GetLocalVariableBlobIndex (variables);
+
+			return GetStandAloneSignatureToken (signature);
+		}
+
+		public MetadataToken GetStandAloneSignature (CallSite call_site)
+		{
+			var signature = metadata.GetCallSiteBlobIndex (call_site);
+			var token = GetStandAloneSignatureToken (signature);
+			call_site.MetadataToken = token;
+			return token;
+		}
+
+		MetadataToken GetStandAloneSignatureToken (uint signature)
+		{
+			MetadataToken token;
+			if (standalone_signatures.TryGetValue (signature, out token))
+				return token;
+
+			token = new MetadataToken (TokenType.Signature, metadata.AddStandAloneSignature (signature));
+			standalone_signatures.Add (signature, token);
+			return token;
+		}
+
+		RVA BeginMethod ()
+		{
+			return (RVA)(code_base + position);
+		}
+
+		void WriteMetadataToken (MetadataToken token)
+		{
+			WriteUInt32 (token.ToUInt32 ());
+		}
+
+		void Align (int align)
+		{
+			align--;
+			WriteBytes (((position + align) & ~align) - position);
+		}
+	}
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 278f89c983a1bc6429c65a1d49dff091
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -0,0 +1,123 @@
+//
+// 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 {
+
+		string url;
+
+		Guid type;
+		Guid hash_algorithm;
+		Guid language;
+		Guid language_vendor;
+
+		byte [] hash;
+		byte [] embedded_source;
+
+		public string Url {
+			get { return url; }
+			set { url = value; }
+		}
+
+		public DocumentType Type {
+			get { return type.ToType (); }
+			set { type = value.ToGuid (); }
+		}
+
+		public Guid TypeGuid {
+			get { return type; }
+			set { type = value; }
+		}
+
+		public DocumentHashAlgorithm HashAlgorithm {
+			get { return hash_algorithm.ToHashAlgorithm (); }
+			set { hash_algorithm = value.ToGuid (); }
+		}
+
+		public Guid HashAlgorithmGuid {
+			get { return hash_algorithm; }
+			set { hash_algorithm = value; }
+		}
+
+		public DocumentLanguage Language {
+			get { return language.ToLanguage (); }
+			set { language = value.ToGuid (); }
+		}
+
+		public Guid LanguageGuid {
+			get { return language; }
+			set { language = value; }
+		}
+
+		public DocumentLanguageVendor LanguageVendor {
+			get { return language_vendor.ToVendor (); }
+			set { language_vendor = value.ToGuid (); }
+		}
+
+		public Guid LanguageVendorGuid {
+			get { return language_vendor; }
+			set { language_vendor = value; }
+		}
+
+		public byte [] Hash {
+			get { return hash; }
+			set { hash = value; }
+		}
+
+		public byte [] EmbeddedSource {
+			get { return embedded_source; }
+			set { embedded_source = value; }
+		}
+
+		public Document (string url)
+		{
+			this.url = url;
+			this.hash = Empty<byte>.Array;
+			this.embedded_source = Empty<byte>.Array;
+			this.token = new MetadataToken (TokenType.Document);
+		}
+	}
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 86b3083301304a341b6059ea8c29be7a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -0,0 +1,71 @@
+//
+// 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 {
+
+		Instruction try_start;
+		Instruction try_end;
+		Instruction filter_start;
+		Instruction handler_start;
+		Instruction handler_end;
+
+		TypeReference catch_type;
+		ExceptionHandlerType handler_type;
+
+		public Instruction TryStart {
+			get { return try_start; }
+			set { try_start = value; }
+		}
+
+		public Instruction TryEnd {
+			get { return try_end; }
+			set { try_end = value; }
+		}
+
+		public Instruction FilterStart {
+			get { return filter_start; }
+			set { filter_start = value; }
+		}
+
+		public Instruction HandlerStart {
+			get { return handler_start; }
+			set { handler_start = value; }
+		}
+
+		public Instruction HandlerEnd {
+			get { return handler_end; }
+			set { handler_end = value; }
+		}
+
+		public TypeReference CatchType {
+			get { return catch_type; }
+			set { catch_type = value; }
+		}
+
+		public ExceptionHandlerType HandlerType {
+			get { return handler_type; }
+			set { handler_type = value; }
+		}
+
+		public ExceptionHandler (ExceptionHandlerType handlerType)
+		{
+			this.handler_type = handlerType;
+		}
+	}
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: eb17bcae1a67ec344b65d6ed78ffb704
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -0,0 +1,291 @@
+//
+// 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 {
+
+		readonly MethodBody body;
+		readonly Collection<Instruction> instructions;
+
+		public MethodBody Body {
+			get { return body; }
+		}
+
+		internal ILProcessor (MethodBody body)
+		{
+			this.body = body;
+			this.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");
+
+			var 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");
+
+			var 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 ();
+		}
+	}
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 26902ea42064c624d82727d9ef9a8f5e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -0,0 +1,296 @@
+//
+// 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;
+			this.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 ()
+		{
+			var instruction = new StringBuilder ();
+
+			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:
+				var 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 ();
+		}
+
+		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 Instruction (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 Instruction (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 Instruction (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 Instruction (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 Instruction (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 Instruction (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 Instruction (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 Instruction (opcode, value);
+		}
+
+		public static Instruction Create (OpCode opcode, int value)
+		{
+			if (opcode.OperandType != OperandType.InlineI)
+				throw new ArgumentException ("opcode");
+
+			return new Instruction (opcode, value);
+		}
+
+		public static Instruction Create (OpCode opcode, long value)
+		{
+			if (opcode.OperandType != OperandType.InlineI8)
+				throw new ArgumentException ("opcode");
+
+			return new Instruction (opcode, value);
+		}
+
+		public static Instruction Create (OpCode opcode, float value)
+		{
+			if (opcode.OperandType != OperandType.ShortInlineR)
+				throw new ArgumentException ("opcode");
+
+			return new Instruction (opcode, value);
+		}
+
+		public static Instruction Create (OpCode opcode, double value)
+		{
+			if (opcode.OperandType != OperandType.InlineR)
+				throw new ArgumentException ("opcode");
+
+			return new Instruction (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 Instruction (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 Instruction (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 Instruction (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 Instruction (opcode, parameter);
+		}
+	}
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2d1536adbd2ca174abbd624473e722c3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -0,0 +1,426 @@
+//
+// 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 {
+
+		readonly internal 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 Collection<ExceptionHandler> (), null);
+
+				return exceptions;
+			}
+		}
+
+		public bool HasVariables {
+			get { return !variables.IsNullOrEmpty (); }
+		}
+
+		public Collection<VariableDefinition> Variables {
+			get {
+				if (variables == null)
+					Interlocked.CompareExchange (ref variables, new VariableDefinitionCollection (this.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;
+			}
+		}
+
+		static ParameterDefinition CreateThisParameter (MethodDefinition method)
+		{
+			var parameter_type = method.DeclaringType as TypeReference;
+
+			if (parameter_type.HasGenericParameters) {
+				var instance = new GenericInstanceType (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 ParameterDefinition (parameter_type, method);
+		}
+
+		public MethodBody (MethodDefinition method)
+		{
+			this.method = method;
+		}
+
+		public ILProcessor GetILProcessor ()
+		{
+			return new ILProcessor (this);
+		}
+	}
+
+	sealed class VariableDefinitionCollection : Collection<VariableDefinition> {
+
+		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;
+		}
+
+		void UpdateVariableIndices (int startIndex, int offset, VariableDefinition variableToRemove = null)
+		{
+			for (int i = startIndex; i < size; i++)
+				items [i].index = i + offset;
+
+			var debug_info = method == null ? null : method.debug_info;
+			if (debug_info == null || debug_info.Scope == null)
+				return;
+
+			foreach (var scope in debug_info.GetScopes ()) {
+				if (!scope.HasVariables)
+					continue;
+
+				var variables = scope.Variables;
+				int variableDebugInfoIndexToRemove = -1;
+				for (int i = 0; i < variables.Count; i++) {
+					var 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 VariableIndex (variable.Index + offset);
+					}
+				}
+
+				if (variableDebugInfoIndexToRemove >= 0)
+					variables.RemoveAt (variableDebugInfoIndexToRemove);
+			}
+		}
+	}
+
+	class InstructionCollection : Collection<Instruction> {
+
+		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;
+
+			var previous = items [index - 1];
+			previous.next = item;
+			item.previous = previous;
+		}
+
+		protected override void OnInsert (Instruction item, int index)
+		{
+			int startOffset = 0;
+			if (size != 0) {
+				var current = items [index];
+				if (current == null) {
+					var last = items [index - 1];
+					last.next = item;
+					item.previous = last;
+					return;
+				}
+
+				startOffset = current.Offset;
+
+				var 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)
+		{
+			var 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)
+		{
+			var previous = item.previous;
+			if (previous != null)
+				previous.next = item.next;
+
+			var next = item.next;
+			if (next != null)
+				next.previous = item.previous;
+
+			RemoveSequencePoint (item);
+			UpdateLocalScopes (item, next ?? previous);
+
+			item.previous = null;
+			item.next = null;
+		}
+
+		void RemoveSequencePoint (Instruction instruction)
+		{
+			var debug_info = method.debug_info;
+			if (debug_info == null || !debug_info.HasSequencePoints)
+				return;
+
+			var 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;
+				}
+			}
+		}
+
+		void UpdateLocalScopes (Instruction removedInstruction, Instruction existingInstruction)
+		{
+			var 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 InstructionOffsetCache () {
+				Offset = 0,
+				Index = 0,
+				Instruction = items [0]
+			};
+
+			UpdateLocalScope (debug_info.Scope, removedInstruction, existingInstruction, ref cache);
+		}
+
+		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 InstructionOffset (existingInstruction);
+
+			if (scope.HasScopes) {
+				foreach (var 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 InstructionOffset (existingInstruction);
+		}
+
+		struct InstructionOffsetCache {
+			public int Offset;
+			public int Index;
+			public Instruction Instruction;
+		}
+
+		InstructionOffset ResolveInstructionOffset (InstructionOffset inputOffset, ref InstructionOffsetCache cache)
+		{
+			if (inputOffset.IsResolved)
+				return inputOffset;
+
+			int offset = inputOffset.Offset;
+
+			if (cache.Offset == offset)
+				return new InstructionOffset (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 InstructionOffset (items [i]);
+
+					if (size > offset)
+						return new InstructionOffset (items [i - 1]);
+
+					size += items [i].GetSize ();
+				}
+
+				// Offset is larger than the size of the body - so it points after the end
+				return new InstructionOffset ();
+			} 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;
+
+					var 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 InstructionOffset (cache.Instruction);
+
+					if (cache.Offset > offset)
+						return new InstructionOffset (items [i - 1]);
+
+					size += item.GetSize ();
+				}
+
+				return new InstructionOffset ();
+			}
+		}
+	}
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4be4045de2c6a0e428e5910f4e76cfac
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -0,0 +1,439 @@
+//
+// 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> {
+
+		readonly byte op1;
+		readonly byte op2;
+		readonly byte code;
+		readonly byte flow_control;
+		readonly byte opcode_type;
+		readonly byte operand_type;
+		readonly byte stack_behavior_pop;
+		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 { return op1; }
+		}
+
+		public byte Op2 {
+			get { return op2; }
+		}
+
+		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)
+		{
+			this.op1 = (byte)((x >> 0) & 0xff);
+			this.op2 = (byte)((x >> 8) & 0xff);
+			this.code = (byte)((x >> 16) & 0xff);
+			this.flow_control = (byte)((x >> 24) & 0xff);
+
+			this.opcode_type = (byte)((y >> 0) & 0xff);
+			this.operand_type = (byte)((y >> 8) & 0xff);
+			this.stack_behavior_pop = (byte)((y >> 16) & 0xff);
+			this.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;
+
+			var 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;
+		}
+	}
+
+	static class OpCodeNames {
+
+		internal static readonly string [] names;
+
+		static OpCodeNames ()
+		{
+			var 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++) {
+				var buffer = new char [table [p++]];
+
+				for (int j = 0; j < buffer.Length; j++)
+					buffer [j] = (char)table [p++];
+
+				names [i] = new string (buffer);
+			}
+		}
+	}
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5d8b234c106529441912c10b87502175
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -0,0 +1,894 @@
+//
+// 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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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 OpCode (
+			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);
+	}
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 52c19a62321778c438d2f6b483f18e73
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -0,0 +1,591 @@
+//
+// 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);
+
+			var 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 ());
+		}
+
+		ISymbolReader GetSymbolReader (ModuleDefinition module, Disposable<Stream> symbolStream, string fileName)
+		{
+			return new PortablePdbReader (ImageReader.ReadPortablePdb (symbolStream, fileName), module);
+		}
+	}
+
+	public sealed class PortablePdbReader : ISymbolReader {
+
+		readonly Image image;
+		readonly ModuleDefinition module;
+		readonly MetadataReader reader;
+		readonly MetadataReader debug_reader;
+
+		bool IsEmbedded { get { return reader.image == debug_reader.image; } }
+
+		internal PortablePdbReader (Image image, ModuleDefinition module)
+		{
+			this.image = image;
+			this.module = module;
+			this.reader = module.reader;
+			this.debug_reader = new MetadataReader (image, module, this.reader);
+		}
+
+		public ISymbolWriterProvider GetWriterProvider ()
+		{
+			return new PortablePdbWriterProvider ();
+		}
+
+		public bool ProcessDebugHeader (ImageDebugHeader header)
+		{
+			if (image == module.Image)
+				return true;
+
+			foreach (var entry in header.Entries) {
+				if (!IsMatchingEntry (image.PdbHeap, entry))
+					continue;
+
+				ReadModule ();
+				return true;
+			}
+
+			return false;
+		}
+
+		static bool IsMatchingEntry (PdbHeap heap, ImageDebugHeaderEntry entry)
+		{
+			if (entry.Directory.Type != ImageDebugType.CodeView)
+				return false;
+
+			var data = entry.Data;
+
+			if (data.Length < 24)
+				return false;
+
+			var magic = ReadInt32 (data, 0);
+			if (magic != 0x53445352)
+				return false;
+
+			var buffer = new byte [16];
+			Buffer.BlockCopy (data, 4, buffer, 0, 16);
+
+			var module_guid = new Guid (buffer);
+
+			Buffer.BlockCopy (heap.Id, 0, buffer, 0, 16);
+
+			var pdb_guid = new Guid (buffer);
+
+			return module_guid == pdb_guid;
+		}
+
+		static int ReadInt32 (byte [] bytes, int start)
+		{
+			return (bytes [start]
+				| (bytes [start + 1] << 8)
+				| (bytes [start + 2] << 16)
+				| (bytes [start + 3] << 24));
+		}
+
+		void ReadModule ()
+		{
+			module.custom_infos = debug_reader.GetCustomDebugInformation (module);
+		}
+
+		public MethodDebugInformation Read (MethodDefinition method)
+		{
+			var info = new MethodDebugInformation (method);
+			ReadSequencePoints (info);
+			ReadScope (info);
+			ReadStateMachineKickOffMethod (info);
+			ReadCustomDebugInformations (info);
+			return info;
+		}
+
+		void ReadSequencePoints (MethodDebugInformation method_info)
+		{
+			method_info.sequence_points = debug_reader.ReadSequencePoints (method_info.method);
+		}
+
+		void ReadScope (MethodDebugInformation method_info)
+		{
+			method_info.scope = debug_reader.ReadScope (method_info.method);
+		}
+
+		void ReadStateMachineKickOffMethod (MethodDebugInformation method_info)
+		{
+			method_info.kickoff_method = debug_reader.ReadStateMachineKickoffMethod (method_info.method);
+		}
+
+		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);
+
+			var header = module.GetDebugHeader ();
+			var entry = header.GetEmbeddedPortablePdbEntry ();
+			if (entry == null)
+				throw new InvalidOperationException ();
+
+			return new EmbeddedPortablePdbReader (
+				(PortablePdbReader)new PortablePdbReaderProvider ().GetSymbolReader (module, GetPortablePdbStream (entry)));
+		}
+
+		static Stream GetPortablePdbStream (ImageDebugHeaderEntry entry)
+		{
+			var compressed_stream = new MemoryStream (entry.Data);
+			var reader = new BinaryStreamReader (compressed_stream);
+			reader.ReadInt32 (); // signature
+			var length = reader.ReadInt32 ();
+			var decompressed_stream = new MemoryStream (length);
+
+			using (var deflate_stream = new DeflateStream (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);
+
+			var 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));
+		}
+
+		ISymbolWriter GetSymbolWriter (ModuleDefinition module, Disposable<Stream> stream)
+		{
+			var metadata = new MetadataBuilder (module, this);
+			var writer = ImageWriter.CreateDebugWriter (module, metadata, stream);
+
+			return new PortablePdbWriter (metadata, module, writer);
+		}
+	}
+
+	public sealed class PortablePdbWriter : ISymbolWriter {
+
+		readonly MetadataBuilder pdb_metadata;
+		readonly ModuleDefinition module;
+		readonly ImageWriter writer;
+
+		MetadataBuilder module_metadata;
+
+		bool IsEmbedded { get { return writer == null; } }
+
+		internal PortablePdbWriter (MetadataBuilder pdb_metadata, ModuleDefinition module)
+		{
+			this.pdb_metadata = pdb_metadata;
+			this.module = module;
+
+			this.module_metadata = module.metadata_builder;
+
+			if (module_metadata != pdb_metadata)
+				this.pdb_metadata.metadata_builder = this.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 ImageDebugHeader ();
+
+			var directory = new ImageDebugDirectory () {
+				MajorVersion = 256,
+				MinorVersion = 20557,
+				Type = ImageDebugType.CodeView,
+				TimeDateStamp = (int)module.timestamp,
+			};
+
+			var buffer = new ByteBuffer ();
+			// RSDS
+			buffer.WriteUInt32 (0x53445352);
+			// Module ID
+			buffer.WriteBytes (module.Mvid.ToByteArray ());
+			// PDB Age
+			buffer.WriteUInt32 (1);
+			// PDB Path
+			var 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);
+
+			var data = new byte [buffer.length];
+			Buffer.BlockCopy (buffer.buffer, 0, data, 0, buffer.length);
+			directory.SizeOfData = data.Length;
+
+			return new ImageDebugHeader (new ImageDebugHeaderEntry (directory, data));
+		}
+
+		public void Write (MethodDebugInformation info)
+		{
+			CheckMethodDebugInformationTable ();
+
+			pdb_metadata.AddMethodDebugInformation (info);
+		}
+
+		void CheckMethodDebugInformationTable ()
+		{
+			var 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 ();
+		}
+
+		void WritePdbFile ()
+		{
+			WritePdbHeap ();
+
+			WriteTableHeap ();
+
+			writer.BuildMetadataTextMap ();
+			writer.WriteMetadataHeader ();
+			writer.WriteMetadata ();
+
+			writer.Flush ();
+			writer.stream.Dispose ();
+		}
+
+		void WritePdbHeap ()
+		{
+			var 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 ());
+
+			var table_heap = module_metadata.table_heap;
+			var 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);
+			}
+		}
+
+		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);
+
+			var stream = new MemoryStream ();
+			var 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 {
+
+		readonly Stream stream;
+		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 ();
+
+			var directory = new ImageDebugDirectory {
+				Type = ImageDebugType.EmbeddedPortablePdb,
+				MajorVersion = 0x0100,
+				MinorVersion = 0x0100,
+			};
+
+			var data = new MemoryStream ();
+
+			var w = new BinaryStreamWriter (data);
+			w.WriteByte (0x4d);
+			w.WriteByte (0x50);
+			w.WriteByte (0x44);
+			w.WriteByte (0x42);
+
+			w.WriteInt32 ((int)stream.Length);
+
+			stream.Position = 0;
+
+			using (var compress_stream = new DeflateStream (data, CompressionMode.Compress, leaveOpen: true))
+				stream.CopyTo (compress_stream);
+
+			directory.SizeOfData = (int)data.Length;
+
+			return new ImageDebugHeader (new [] {
+				writer.GetDebugHeader ().Entries [0],
+				new ImageDebugHeaderEntry (directory, data.ToArray ())
+			});
+		}
+
+		public void Write (MethodDebugInformation info)
+		{
+			writer.Write (info);
+		}
+
+		public void Dispose ()
+		{
+		}
+	}
+
+	static class PdbGuidMapping {
+
+		static readonly Dictionary<Guid, DocumentLanguage> guid_language = new Dictionary<Guid, DocumentLanguage> ();
+		static readonly Dictionary<DocumentLanguage, Guid> language_guid = new Dictionary<DocumentLanguage, Guid> ();
+
+		static PdbGuidMapping ()
+		{
+			AddMapping (DocumentLanguage.C, new Guid ("63a08714-fc37-11d2-904c-00c04fa302a1"));
+			AddMapping (DocumentLanguage.Cpp, new Guid ("3a12d0b7-c26c-11d0-b442-00a0244a1dd2"));
+			AddMapping (DocumentLanguage.CSharp, new Guid ("3f5162f8-07c6-11d3-9053-00c04fa302a1"));
+			AddMapping (DocumentLanguage.Basic, new Guid ("3a12d0b8-c26c-11d0-b442-00a0244a1dd2"));
+			AddMapping (DocumentLanguage.Java, new Guid ("3a12d0b4-c26c-11d0-b442-00a0244a1dd2"));
+			AddMapping (DocumentLanguage.Cobol, new Guid ("af046cd1-d0e1-11d2-977c-00a0c9b4d50c"));
+			AddMapping (DocumentLanguage.Pascal, new Guid ("af046cd2-d0e1-11d2-977c-00a0c9b4d50c"));
+			AddMapping (DocumentLanguage.Cil, new Guid ("af046cd3-d0e1-11d2-977c-00a0c9b4d50c"));
+			AddMapping (DocumentLanguage.JScript, new Guid ("3a12d0b6-c26c-11d0-b442-00a0244a1dd2"));
+			AddMapping (DocumentLanguage.Smc, new Guid ("0d9b9f7b-6611-11d3-bd2a-0000f80849bd"));
+			AddMapping (DocumentLanguage.MCpp, new Guid ("4b35fde8-07c6-11d3-9053-00c04fa302a1"));
+			AddMapping (DocumentLanguage.FSharp, new Guid ("ab4f38c9-b6e6-43ba-be3b-58080b2ccce3"));
+		}
+
+		static void AddMapping (DocumentLanguage language, Guid guid)
+		{
+			guid_language.Add (guid, language);
+			language_guid.Add (language, guid);
+		}
+
+		static readonly Guid type_text = new Guid ("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 Guid ();
+		}
+
+		static readonly Guid hash_md5 = new Guid ("406ea660-64cf-4c82-b6f0-42d48172a799");
+		static readonly Guid hash_sha1 = new Guid ("ff1816ec-aa5e-4d10-87f7-6f4963833460");
+		static readonly Guid hash_sha256 = new Guid ("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 Guid ();
+		}
+
+		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 Guid ();
+
+			return guid;
+		}
+
+		static readonly Guid vendor_ms = new Guid ("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 Guid ();
+		}
+	}
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 34e2f5d4b9b9ea542bec15f2d9acc3ed
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -0,0 +1,76 @@
+//
+// 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;
+		Document document;
+
+		int start_line;
+		int start_column;
+		int end_line;
+		int end_column;
+
+		public int Offset {
+			get { return offset.Offset; }
+		}
+
+		public int StartLine {
+			get { return start_line; }
+			set { start_line = value; }
+		}
+
+		public int StartColumn {
+			get { return start_column; }
+			set { start_column = value; }
+		}
+
+		public int EndLine {
+			get { return end_line; }
+			set { end_line = value; }
+		}
+
+		public int EndColumn {
+			get { return end_column; }
+			set { end_column = value; }
+		}
+
+		public bool IsHidden {
+			get { return start_line == 0xfeefee && start_line == end_line; }
+		}
+
+		public Document Document {
+			get { return document; }
+			set { document = value; }
+		}
+
+		internal SequencePoint (int offset, Document document)
+		{
+			if (document == null)
+				throw new ArgumentNullException ("document");
+
+			this.offset = new InstructionOffset (offset);
+			this.document = document;
+		}
+
+		public SequencePoint (Instruction instruction, Document document)
+		{
+			if (document == null)
+				throw new ArgumentNullException ("document");
+
+			this.offset = new InstructionOffset (instruction);
+			this.document = document;
+		}
+	}
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 612e6675dca63a84b9e8aaeb3e3b9ec6
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: de9ae158807f471449a81d9b8b3e3c4e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -0,0 +1,29 @@
+//
+// 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;
+		}
+	}
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1346fa5ba8ac9e8418cc20d2d7d0ad21
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

phr/StickGame/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;
+		}
+	}
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b5dca1eaac23bfd4ba8e881302a72e33
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: