public CompiledInstruction(Instruction Instr, int MemSize, int InputSize)
 {
     InAdrA = ConvertMemAdrToInt(Instr.InAdrA, MemSize, InputSize);
     HyAdrB = ConvertMemAdrToInt(Instr.HyAdrB, MemSize, InputSize);
     OutAdr = ConvertMemAdrToInt(Instr.OutAdr, MemSize, InputSize);
     Instuct = Instr.Instuct;
 }

        void ICilCompilerAware.ImplementInCil(CompilerState state, Instruction ins)
        {
            var argc = ins.Arguments;

            if (argc < 2)
            {
                state.EmitLoadNullAsPValue();
            }
            else
            {
                //pop excessive arguments
                for (var i = 2; i < argc; i++)
                    state.Il.Emit(OpCodes.Pop);

                //make pvkvp
                state.Il.Emit(OpCodes.Newobj, Compiler.Cil.Compiler.NewPValueKeyValuePair);

                //save pvkvp in temporary variable
                state.EmitStoreTemp(0);

                //PType.Object.CreatePValue(temp)
                state.Il.EmitCall(OpCodes.Call, Compiler.Cil.Compiler.GetObjectPTypeSelector, null);
                state.EmitLoadTemp(0);
                state.Il.EmitCall(OpCodes.Call, Compiler.Cil.Compiler.CreatePValueAsObject, null);
            }
        }

 void ICilCompilerAware.ImplementInCil(CompilerState state, Instruction ins)
 {
     state.EmitIgnoreArguments(ins.Arguments);
     state.Il.Emit(OpCodes.Newobj, _channelCtor);
     PType.PrexoniteObjectTypeProxy._ImplementInCil(state, typeof (Channel));
     state.Il.Emit(OpCodes.Newobj, _newPValue);
 }

 /// <summary>
 /// Run a simple check on a list of instructions to check if it evaluates to a constant
 /// value.
 /// </summary>
 /// <param name="expression"></param>
 /// <returns></returns>
 public static bool IsSimpleConstant(Instruction[] expression)
 {
     // First pass, check basic instructions.
     foreach (Instruction instruction in expression)
     {
         // These are "constant" instructions which can be evaluated without any
         // context (no locals, globals, instance, or system required).
         if (
             !(instruction is LoadConstant) &&
             !(instruction is CallFunction) &&
             !(instruction is BinaryAdd) &&
             !(instruction is BinaryDiv) &&
             !(instruction is BinaryMod) &&
             !(instruction is BinaryMul) &&
             !(instruction is BinaryPow) &&
             !(instruction is BinarySub) &&
             !(instruction is UnaryAbs) &&
             !(instruction is UnaryNeg)
             )
             return false;
     }
     // Second pass, check for pure functions.
     for (int i = 0; i < expression.Length; i++)
     {
         if (expression[i] is CallFunction)
         {
             var previous = ((LoadConstant)expression[i - 1]).constant;
             if (!((DmlFunction)previous.Value).IsPure)
                 return false;
         }
     }
     return true;
 }

 public Instruction(Instruction i)
 {
     InAdrA = i.InAdrA;
     HyAdrB = i.HyAdrB;
     OutAdr = i.OutAdr;
     Instuct = i.Instuct;
 }

        public void Execute(Machine machine, Stack<object> stack, Scope scope, Instruction instr)
        {
            int length = (int)machine.TakeByte();
            string name = machine.TakeBytes(length * sizeof(char)).AsString();

            scope.GetFunction(name).Call(machine);
        }

        public void Execute(Machine machine, Stack<object> stack, Scope scope, Instruction instr)
        {
            Instruction type = (Instruction)machine.TakeByte();

            switch (type)
            {
                default:
                    throw new VMException("Unhandled literal type: {0}", type.ToString());

                case Instruction.TypeNumeral:
                    byte[] numBytes = machine.TakeBytes(8);
                    stack.Push(numBytes.AsDouble());
                    break;

                case Instruction.TypeString:
                    double length = machine.TakeBytes(8).AsDouble();
                    string text = machine.TakeBytes((int)length * sizeof(char)).AsString();
                    stack.Push(text);
                    break;

                case Instruction.TypeBoolean:
                    stack.Push(Convert.ToBoolean(machine.TakeByte()));
                    break;
            }
        }

        private int OpCodeCost(Instruction instruction)
        {
            switch (instruction.instruction)
            {
                case 0x0:
                    switch (instruction.a)
                    {
                        case 0x01:
                            return 3;
                    }
                    return 0;
                case 0x01:
                    return 1;

                case 0x06:
                case 0x07:
                case 0x08:
                    return 3;
                case 0x09:
                case 0x0a:
                case 0x0b:
                    return 1;

                default:
                    return 2;
            }
        }

        private int ValueCost(Instruction instruction)
        {
            if (instruction.instruction == 0x0) // extended
                return ValueCost(instruction.b);

            return ValueCost(instruction.a) + ValueCost(instruction.b);
        }

 public static void instr(Instruction instr, TargetRegister op1, byte op2)
 {
     BuildInstruction (instr);
     BuildLengthPrefix (LengthPrefix.f_reg | LengthPrefix.s_8);
     BuildRegister (op1);
     bitstream.Write (op2 & 0xFF);
 }

        public static Instruction CreateBinaryInstruction(
            string mnemonic, OperationNode op, int exUnit,
            ValueNode vres, RegisterSet vresRegs,
            ValueNode v1, RegisterSet v1Regs,
            ValueNode v2, RegisterSet v2Regs)
        {
            InstructionPattern ip = new InstructionPattern();

            ip.AddNode(op);
            ip.AddNode(vres);
            ip.AddNode(v1);
            ip.AddNode(v2);
            ip.AddEdge(op, vres);
            ip.AddEdge(v1, op);
            ip.AddEdge(v2, op);

            ip.OperandValues.Add(v1);
            ip.OperandValues.Add(v2);
            ip.ResultValue = vres;

            Instruction i = new Instruction(mnemonic, ip);

            i.ExecutionUnit = exUnit;
            i.ResultRegisters = vresRegs;
            i.OperandsRegisters[0] = v1Regs;
            i.OperandsRegisters[1] = v2Regs;

            return i;
        }

        public Result Disassemble(uint PC, Instruction Instruction)
        {
            if (ProcessCallback == null)
            {
                var Dictionary = new Dictionary<InstructionInfo, int>();

                InstructionLookup = InstructionTable.ALL.ToArray();
                for (int n = 0; n < InstructionLookup.Length; n++) Dictionary[InstructionLookup[n]] = n;

                ProcessCallback = EmitLookupGenerator.GenerateSwitch<Func<uint, MipsDisassembler, Result>>("", InstructionTable.ALL, (InstructionInfo) =>
                {
                    return ast.Return(ast.CallStatic(
                        (Func<uint, int, Result>)MipsDisassembler._InternalHandle,
                        ast.Argument<uint>(0),
                        (InstructionInfo != null) ? Dictionary[InstructionInfo] : -1
                    ));
                });
            }

            var Result = ProcessCallback(Instruction, this);
            if (Result.InstructionInfo == null)
            {
                Console.Error.WriteLine(String.Format("Instruction at 0x{0:X8} with data 0x{1:X8} didn't generate a value", PC, (uint)Instruction));
                Result.InstructionInfo = InstructionTable.Unknown;
            }
            Result.InstructionPC = PC;
            return Result;
        }

    public void MakeLastStatementReturn()
    {
        instructions = Method.Body.Instructions;
        FixHangingHandlerEnd();

        sealBranchesNop = Instruction.Create(OpCodes.Nop);
           instructions.Add(sealBranchesNop);

        NopBeforeReturn = Instruction.Create(OpCodes.Nop);

        foreach (var instruction in instructions)
        {
            var operand = instruction.Operand as Instruction;
            if (operand != null)
            {
                if (operand.OpCode == OpCodes.Ret)
                {
                    instruction.Operand = sealBranchesNop;
                }
            }
        }

        if (Method.MethodReturnType.ReturnType.Name == "Void")
        {
            WithNoReturn();
            return;
        }
        WithReturnValue();
    }

        public Result Disassemble(uint PC, Instruction Instruction)
        {
            if (ProcessCallback == null)
            {
                InstructionDictionary = InstructionTable.ALL.ToDictionary(Item => Item.Name);
                ProcessCallback = EmitLookupGenerator.GenerateSwitch<Func<uint, MipsDisassembler, Result>>(InstructionTable.ALL, (SafeILGenerator, InstructionInfo) =>
                {
                    //SafeILGenerator.LoadArgument<MipsDisassembler>(1);
                    SafeILGenerator.LoadArgument<uint>(0);
                    if (InstructionInfo == null)
                    {
                        SafeILGenerator.Push("Unknown");
                    }
                    else
                    {
                        SafeILGenerator.Push(InstructionInfo.Name);
                    }
                    SafeILGenerator.Call((Func<uint, String, Result>)MipsDisassembler._InternalHandle);
                });
            }

            var Result = ProcessCallback(Instruction, this);
            Result.InstructionPC = PC;
            return Result;
        }

        public void Execute(Machine machine, Stack<object> stack, Scope scope, Instruction instr)
        {
            int length;
            string name;

            switch (instr)
            {
                default:
                    throw new VMException("Something just went horribly wrong. Variable instructlet is not supposed to receive {0}", instr.ToString());

                case Instruction.SetVar:
                    length = (int)machine.TakeByte();
                    name = machine.TakeBytes(length).AsString();

                    machine.ExecuteNextInstructlet();
                    scope.SetVariable(name, stack.Pop());
                    break;

                case Instruction.GetVar:
                    length = (int)machine.TakeByte();
                    name = machine.TakeBytes((int)length).AsString();

                    stack.Push(scope.GetVariable(name));
                    break;
            }
        }

 void InjectNop(Instruction instruction)
 {
     Instruction nop;
     if (instruction.Previous != null && instruction.Previous.OpCode == OpCodes.Nop)
     {
         nop = instruction.Previous;
     }
     else
     {
         nop = Instruction.Create(OpCodes.Nop);
         instructions.Insert(instructions.IndexOf(instruction), nop);
     }
     foreach (var innerInstruction in instructions)
     {
         if (innerInstruction == instruction)
         {
             continue;
         }
         var flowControl = innerInstruction.OpCode.FlowControl;
         if (flowControl != FlowControl.Branch && flowControl != FlowControl.Cond_Branch)
         {
             continue;
         }
         if (innerInstruction.Operand != instruction)
         {
             continue;
         }
         innerInstruction.Operand = nop;
     }
 }

 public AstAsmInstruction(string file, int line, int column, Instruction instruction)
     : base(file, line, column)
 {
     if (instruction == null)
         throw new ArgumentNullException("instruction");
     Instruction = instruction;
 }

        public static Instruction Push(object value) {
            if (value == null) {
                return _null ?? (_null = new PushInstruction(null));
            }

            if (value is bool) {
                if ((bool)value) {
                    return _true ?? (_true = new PushInstruction(value));
                } else {
                    return _false ?? (_false = new PushInstruction(value));
                }
            }

            if (value is int) {
                int i = (int)value;
                if (i >= PushIntMinCachedValue && i <= PushIntMaxCachedValue) {
                    if (_ints == null) {
                        _ints = new Instruction[PushIntMaxCachedValue - PushIntMinCachedValue + 1];
                    }
                    i -= PushIntMinCachedValue;
                    return _ints[i] ?? (_ints[i] = new PushInstruction(value));
                }
            }

            return new PushInstruction(value);
        }

    public object Run(Instruction i)
    {
        Debug.Log ("Exec "+i.name);

        if(i.name=="left") 				AddImpulse( -1.0f, 0.0f,  0.0f );
        else if(i.name=="right")		AddImpulse(  1.0f, 0.0f,  0.0f );
        else if(i.name=="forward")		AddImpulse(  0.0f, 0.0f,  1.0f );
        else if(i.name=="backward")		AddImpulse(  0.0f, 0.0f, -1.0f );
        else if(i.name=="up") 			AddImpulse(  0.0f, 1.0f,  0.0f );
        else if(i.name=="sum"){

            float s = 0.0f;
            foreach(var e in i.arguments){
                s+=(float)e;
            }
            return s;

        }else if(i.name=="product"){

            float s = 1.0f;
            foreach(var e in i.arguments){
                s+=(float)e;
            }
            return s;

        }else{

            Debug.LogError ("illegal instruction: "+i.name);
            return null;

        }

        return null;
    }

 internal static MemoryStream SerializeBytecode(Instruction[] bytecode)
 {
     return Utils.SerializeWithMd5CheckSum (str => {
         SerializeBytecodeImplementation (str, bytecode);
     }
     );
 }