public void Clear()
 {
     instructions = new List<Instruction>();
     branchOrRet = new List<Instruction>();
     afterInstr = null;
     fakeBranches = new List<Instruction>();
 }

 public void EmulateUntil(Instruction instruction, CilBody body, Instruction starter)
 {
     Snapshots.Add(new Snapshot(new Stack<StackEntry>(Stack), new Dictionary<int, LocalEntry>(_locals),
                                instruction, _methodBody, null));
     _instructionPointer = starter.GetInstructionIndex(body.Instructions) - 1;
     Trace(() => _methodBody.Instructions[_instructionPointer] != instruction);
 }

 public static bool FollowsPattern(
     this Instruction instr,
     CilBody body,
     out Instruction ender,
     List<Predicate<Instruction>> preds,
     int minPatternSize,
     out int patternSize)
 {
     var curInstr = instr;
     ender = null;
     var correct = 0;
     patternSize = 0;
     while (curInstr.Next(body) != null && preds.Any(p => p(curInstr.Next(body))))
     {
         curInstr = curInstr.Next(body);
         correct++;
     }
     if (correct >= minPatternSize)
     {
         patternSize = correct + 1;
         ender = curInstr;
         return true;
     }
     return false;
 }

 static Instruction getInstruction(IList<Instruction> instrs, Instruction source, int displ)
 {
     int sourceIndex = instrs.IndexOf(source);
     if (sourceIndex < 0)
         throw new ApplicationException("Could not find source instruction");
     return instrs[sourceIndex + displ];
 }

		protected override Instruction OnAfterLoadArg(MethodDef methodToInline, Instruction instr, ref int instrIndex) {
			if (instr.OpCode.Code != Code.Box)
				return instr;
			if (methodToInline.MethodSig.GetGenParamCount() == 0)
				return instr;
			return DotNetUtils.GetInstruction(methodToInline.Body.Instructions, ref instrIndex);
		}

		void MarkAsBranchTarget(Instruction instr) {
			if (instr == null)
				return;

			int index = instrToIndex[instr];
			GetBranchTargetList(index);	// Just create the list
		}

		public bool Emulate(Instruction instr) {
			switch (instr.OpCode.Code) {
			case Code.Br:
			case Code.Br_S:		return Emulate_Br();
			case Code.Beq:
			case Code.Beq_S:	return Emulate_Beq();
			case Code.Bge:
			case Code.Bge_S:	return Emulate_Bge();
			case Code.Bge_Un:
			case Code.Bge_Un_S:	return Emulate_Bge_Un();
			case Code.Bgt:
			case Code.Bgt_S:	return Emulate_Bgt();
			case Code.Bgt_Un:
			case Code.Bgt_Un_S:	return Emulate_Bgt_Un();
			case Code.Ble:
			case Code.Ble_S:	return Emulate_Ble();
			case Code.Ble_Un:
			case Code.Ble_Un_S:	return Emulate_Ble_Un();
			case Code.Blt:
			case Code.Blt_S:	return Emulate_Blt();
			case Code.Blt_Un:
			case Code.Blt_Un_S:	return Emulate_Blt_Un();
			case Code.Bne_Un:
			case Code.Bne_Un_S:	return Emulate_Bne_Un();
			case Code.Brfalse:
			case Code.Brfalse_S:return Emulate_Brfalse();
			case Code.Brtrue:
			case Code.Brtrue_S:	return Emulate_Brtrue();
			case Code.Switch:	return Emulate_Switch();

			default:
				return false;
			}
		}

		public Instruction[] EmitDecode(MethodDef init, RPContext ctx, Instruction[] arg) {
			Tuple<Expression, Func<int, int>> key = GetKey(ctx, init);

			var invCompiled = new List<Instruction>();
			new CodeGen(arg, ctx.Method, invCompiled).GenerateCIL(key.Item1);
			init.Body.MaxStack += (ushort)ctx.Depth;
			return invCompiled.ToArray();
		}

		protected override ITokenOperand ReadInlineTok(Instruction instr) {
			switch (reader.ReadByte()) {
			case 0: return imageReader.ReadTypeSig().ToTypeDefOrRef();
			case 1: return imageReader.ReadFieldRef();
			case 2: return imageReader.ReadMethodRef();
			default: throw new ApplicationException("Unknown token type");
			}
		}

		public Instruction[] EmitDecode(MethodDef init, RPContext ctx, Instruction[] arg) {
			Tuple<MethodDef, Func<int, int>> key = GetKey(ctx, init);

			var repl = new List<Instruction>();
			repl.AddRange(arg);
			repl.Add(Instruction.Create(OpCodes.Call, key.Item1));
			return repl.ToArray();
		}

 ExInfo getExInfo(Instruction instruction)
 {
     if (instruction == null)
         return lastExInfo;
     ExInfo exInfo;
     if (!exInfos.TryGetValue(instruction, out exInfo))
         exInfos[instruction] = exInfo = new ExInfo();
     return exInfo;
 }

 static bool checkInvokeCall(Instruction instr, string returnType, string parameters)
 {
     var method = instr.Operand as MethodDef;
     if (method == null)
         return false;
     if (method.Name != "Invoke")
         return false;
     return DotNetUtils.isMethod(method, returnType, parameters);
 }

 protected static int GetInstructionSize(Instruction instr)
 {
     var opcode = instr.OpCode;
     if (opcode == null)
         return 5;	// Load store/field
     var op = instr.Operand as SwitchTargetDisplOperand;
     if (op == null)
         return instr.GetSize();
     return instr.OpCode.Size + (op.TargetDisplacements.Length + 1) * 4;
 }

		/// <summary>
		/// Gets the offset of an instruction
		/// </summary>
		/// <param name="instr">The instruction</param>
		/// <returns>The offset or <c>0</c> if <paramref name="instr"/> is <c>null</c> or not
		/// present in the list of all instructions.</returns>
		protected uint GetOffset(Instruction instr) {
			if (instr == null) {
				Error("Instruction is null");
				return 0;
			}
			uint offset;
			if (offsets.TryGetValue(instr, out offset))
				return offset;
			Error("Found some other method's instruction or a removed instruction. You probably removed an instruction that is the target of a branch instruction or an instruction that's the first/last instruction in an exception handler.");
			return 0;
		}

		protected bool InlineLoadMethod(int patchIndex, MethodDef methodToInline, Instruction loadInstr, int instrIndex) {
			if (!IsReturn(methodToInline, instrIndex))
				return false;

			int methodArgsCount = DotNetUtils.GetArgsCount(methodToInline);
			for (int i = 0; i < methodArgsCount; i++)
				block.Insert(patchIndex++, OpCodes.Pop.ToInstruction());

			block.Instructions[patchIndex] = new Instr(loadInstr.Clone());
			return true;
		}

        private bool ReplaceFormText(Instruction currentInstruction, string replacementText)
        {
            if (currentInstruction.Operand == null)
                return false;

            if (currentInstruction.Operand.ToString() != "ReplaceMe1")
                return false;

            currentInstruction.Operand = replacementText;
            return true;
        }

		/// <summary>
		/// Converts an instruction to a string
		/// </summary>
		/// <param name="instr">The instruction</param>
		/// <returns>The result</returns>
		public static string ToString(Instruction instr) {
			if (instr == null)
				return string.Empty;

			var sb = new StringBuilder();

			sb.Append(string.Format("IL_{0:X4}: ", instr.Offset));
			sb.Append(instr.OpCode.Name);
			AddOperandString(sb, instr, " ");

			return sb.ToString();
		}

 public static IEnumerable<Instruction> GetInstructionsBetween(this CilBody body,
                                                         Instruction init, Instruction ender)
 {
     var curInstr = init;
     while (curInstr.Next(body) != null && curInstr.Next(body) != ender)
     {
         yield return curInstr;
         curInstr = curInstr.Next(body);
     }
     yield return curInstr;
     yield return curInstr.Next(body);
 }

		public Instruction[] EmitDecode(MethodDef init, RPContext ctx, Instruction[] arg) {
			Tuple<int, int> key = GetKey(ctx.Random, init);
			var ret = new List<Instruction>();
			if (ctx.Random.NextBoolean()) {
				ret.Add(Instruction.Create(OpCodes.Ldc_I4, key.Item1));
				ret.AddRange(arg);
			}
			else {
				ret.AddRange(arg);
				ret.Add(Instruction.Create(OpCodes.Ldc_I4, key.Item1));
			}
			ret.Add(Instruction.Create(OpCodes.Mul));
			return ret.ToArray();
		}

		/// <summary>
		/// Removes all nodes from start to end (exclusive) from this ControlStructure and moves them to the target structure.
		/// </summary>
		static HashSet<ControlFlowNode> FindNodes(ControlStructure current, Instruction startInst, Instruction endInst)
		{
			HashSet<ControlFlowNode> result = new HashSet<ControlFlowNode>();
			if (startInst == null || endInst == null)
				return result;
			uint start = startInst.Offset;
			uint end = endInst.Offset;
			foreach (var node in current.Nodes.ToArray()) {
				if (node.Start != null && start <= node.Start.Value.Offset && node.Start.Value.Offset < end) {
					result.Add(node);
				}
			}
			return result;
		}