/// <summary>
 /// Sets the instruction.
 /// </summary>
 /// <param name="instruction">The instruction.</param>
 /// <param name="operandCount">The operand count.</param>
 /// <param name="resultCount">The result count.</param>
 public InstructionNode(BaseInstruction instruction, int operandCount, byte resultCount)
 {
     Instruction = instruction;
     OperandCount = operandCount;
     ResultCount = resultCount;
     Size = InstructionSize.None;
 }

        public void Save(BaseInstruction instruction)
        {
            var client = new RedisClient();
            var key = new InstructionKeys ().GetKey (instruction.Id);

            var json = instruction.ToJson ();
            client.Set(key, json);

            var idManager = new InstructionIdManager ();
            idManager.Add (instruction);
        }

        public void Add(BaseInstruction instruction)
        {
            var key = new InstructionKeys ().GetIdsKey (instruction.TargetType, instruction.TargetId);

            var client = new RedisClient ();

            var stringToAppend = instruction.Id.ToString();

            if (client.Exists (key))
                stringToAppend = "." + stringToAppend;

            client.Append (key, stringToAppend);
        }

 private static void Replace(Context context, BaseInstruction floatingPointInstruction, BaseInstruction signedInstruction, BaseInstruction unsignedInstruction)
 {
     if (context.Result.IsR)
     {
         context.ReplaceInstructionOnly(floatingPointInstruction);
     }
     else if (context.Result.IsUnsigned)
     {
         context.ReplaceInstructionOnly(unsignedInstruction);
     }
     else
     {
         context.ReplaceInstructionOnly(signedInstruction);
     }
 }

 /// <summary>
 /// Sets the instruction.
 /// </summary>
 /// <param name="instruction">The instruction.</param>
 /// <param name="condition">The condition.</param>
 /// <param name="block">The block.</param>
 public void SetInstruction(BaseInstruction instruction, ConditionCode condition, BasicBlock block)
 {
     SetInstruction(instruction);
     ConditionCode = condition;
     AddBranchTarget(block);
 }

 /// <summary>
 /// Sets the instruction.
 /// </summary>
 /// <param name="instruction">The instruction.</param>
 /// <param name="result">The result.</param>
 /// <param name="result2">The result2.</param>
 public void SetInstruction2(BaseInstruction instruction, Operand result, Operand result2)
 {
     SetInstruction(instruction, 1, 2);
     Result = result;
     Result2 = result2;
 }

 /// <summary>
 /// Replaces the instruction only.
 /// </summary>
 /// <param name="instruction">The instruction.</param>
 public void ReplaceInstructionOnly(BaseInstruction instruction)
 {
     Instruction = instruction;
 }

 /// <summary>
 /// Determines whether the specified instruction is commutative.
 /// </summary>
 /// <param name="instruction">The instruction.</param>
 /// <returns>
 /// 	<c>true</c> if the specified instruction is commutative; otherwise, <c>false</c>.
 /// </returns>
 private static bool IsCommutative(BaseInstruction instruction)
 {
     return (instruction is CIL.AddInstruction) ||
            (instruction is CIL.MulInstruction) ||
            (instruction is IR.LogicalAnd) ||
            (instruction is IR.LogicalOr) ||
            (instruction is IR.LogicalXor);
 }