public static void CompileBinaryExpression(BinaryExpression expression, bool useInterpreter, bool expected)
        {
            Expression<Func<bool>> e = Expression.Lambda<Func<bool>>(expression, Enumerable.Empty<ParameterExpression>());
            Func<bool> f = e.Compile(useInterpreter);

            Assert.Equal(expected, f());
        }

 protected Expression GetResultIndexExpression()
 {
     var resultVarIndex = ReadWord();
     Expression resultVarIndexExp = resultVarIndex.ToLiteral();
     if ((resultVarIndex & 0x2000) == 0x2000)
     {
         int a = ReadWord();
         if ((a & 0x2000) == 0x2000)
         {
             var variableExp = ReadVariable(a & ~0x2000);
             var literalExp = variableExp as IntegerLiteralExpression;
             if (literalExp != null)
             {
                 resultVarIndex += Convert.ToInt32(literalExp.Value);
                 resultVarIndex &= ~0x2000;
                 resultVarIndexExp = resultVarIndex.ToLiteral();
             }
             else
             {
                 resultVarIndexExp = new BinaryExpression(
                     new BinaryExpression(resultVarIndexExp, Operator.Add, variableExp), 
                     Operator.And,
                     new UnaryExpression(0x2000.ToLiteral(), Operator.Not));
             }
         }
         else
         {
             resultVarIndex = resultVarIndex + (a & 0xFFF);	
             resultVarIndex &= ~0x2000;
             resultVarIndexExp = resultVarIndex.ToLiteral();
         }
     }
     return resultVarIndexExp;
 }

		public bool Match(BinaryExpression exp)
		{
			if (exp.Operator != Operator.IAdd)
				return false;
			id = exp.Left as Identifier;
			
			bin = exp.Right as BinaryExpression;
			if ((id == null || bin == null) && exp.Operator  == Operator.IAdd)
			{
				id = exp.Right as Identifier;
				bin = exp.Left as BinaryExpression;
			}
			if (id == null || bin == null)
				return false;

			if (bin.Operator != Operator.SMul && bin.Operator != Operator.UMul && bin.Operator != Operator.IMul)
				return false;

			Identifier idInner = bin.Left as Identifier;
			cInner = bin.Right as Constant;
			if (idInner == null ||cInner == null)
				return false;

			if (idInner != id)
				return false;

			return true;
		}

 //CONFORMING
 private void EmitBinaryMethod(BinaryExpression b) {
     if (b.IsLifted) {
         ParameterExpression p1 = Expression.Variable(TypeUtils.GetNonNullableType(b.Left.Type), null);
         ParameterExpression p2 = Expression.Variable(TypeUtils.GetNonNullableType(b.Right.Type), null);
         MethodCallExpression mc = Expression.Call(null, b.Method, p1, p2);
         Type resultType = null;
         if (b.IsLiftedToNull) {
             resultType = TypeUtils.GetNullableType(mc.Type);
         } else {
             switch (b.NodeType) {
                 case ExpressionType.Equal:
                 case ExpressionType.NotEqual:
                 case ExpressionType.LessThan:
                 case ExpressionType.LessThanOrEqual:
                 case ExpressionType.GreaterThan:
                 case ExpressionType.GreaterThanOrEqual:
                     if (mc.Type != typeof(bool)) {
                         throw Error.ArgumentMustBeBoolean();
                     }
                     resultType = typeof(bool);
                     break;
                 default:
                     resultType = TypeUtils.GetNullableType(mc.Type);
                     break;
             }
         }
         IList<ParameterExpression> variables = new ParameterExpression[] { p1, p2 };
         IList<Expression> arguments = new Expression[] { b.Left, b.Right };
         ValidateLift(variables, arguments);
         EmitLift(b.NodeType, resultType, mc, variables, arguments);
     } else {
         EmitMethodCallExpression(Expression.Call(null, b.Method, b.Left, b.Right));
     }
 }

        private void AddressOf(BinaryExpression node, Type type)
        {
            Debug.Assert(node.NodeType == ExpressionType.ArrayIndex && node.Method == null);

            if (TypeUtils.AreEquivalent(type, node.Type))
            {
                EmitExpression(node.Left);
                EmitExpression(node.Right);
                Type rightType = node.Right.Type;
                if (TypeUtils.IsNullableType(rightType))
                {
                    LocalBuilder loc = GetLocal(rightType);
                    _ilg.Emit(OpCodes.Stloc, loc);
                    _ilg.Emit(OpCodes.Ldloca, loc);
                    _ilg.EmitGetValue(rightType);
                    FreeLocal(loc);
                }
                Type indexType = TypeUtils.GetNonNullableType(rightType);
                if (indexType != typeof(int))
                {
                    _ilg.EmitConvertToType(indexType, typeof(int), isChecked: true);
                }
                _ilg.Emit(OpCodes.Ldelema, node.Type);
            }
            else
            {
                EmitExpressionAddress(node, type);
            }
        }

 public override Expression VisitBinaryExpression(BinaryExpression binaryExpression){
   if (binaryExpression == null) return null;
   binaryExpression.Operand2 = this.VisitExpression(binaryExpression.Operand2);
   binaryExpression.Operand1 = this.VisitExpression(binaryExpression.Operand1);
   if (binaryExpression.Type == null) binaryExpression.Type = binaryExpression.Operand1.Type; //Hack: need proper inferencing
   return binaryExpression;
 }

 public void Exs_OrWithSelf()
 {
     BuildExpressionSimplifier();
     var expr = new BinaryExpression(Operator.Or, foo.DataType, foo, foo);
     var result = expr.Accept(simplifier);
     Assert.AreSame(foo, result);
 }

        public void TestComplexExpression()
        {
            const string VAR_X = "x";
             const string VAR_Y = "y";
             const string VAR_Z = "z";

             var ctx = new Context();
             ctx.SetValue(VAR_X, true);
             ctx.SetValue(VAR_Y, true);
             ctx.SetValue(VAR_Z, false);

             var constExp = new ConstExpression(TRUE_TOKEN);
             var unaryExp = new UnaryExpression(constExp);
             Assert.AreEqual(false, unaryExp.Interpret(ctx));

             var binaryExp =
                 new BinaryExpression(
                     new BinaryExpression(VAR_X,
                                          BinaryOp.And,
                                          unaryExp),
                     BinaryOp.Or,
                     new BinaryExpression(new UnaryExpression(VAR_Y),
                                          BinaryOp.And,
                                          VAR_Z));

             Assert.AreEqual(false, binaryExp.Interpret(ctx));
        }

		public bool MatchMul(BinaryExpression b)
		{
			if (b.Operator == Operator.SMul || b.Operator == Operator.UMul || b.Operator == Operator.IMul)
			{
				Constant c = b.Left as Constant;
				Expression e = b.Right;
				if (c == null)
				{
					c = b.Right as Constant;
					e = b.Left;
				}
				if (c != null)
				{
					elemSize = c;
					Index = e;
					return true;
				}
			}
			if (b.Operator == Operator.Shl)
			{
				Constant c = b.Right as Constant;
				if (c != null)
				{
					elemSize = b.Operator.ApplyConstants(Constant.Create(b.Left.DataType, 1), c);
					Index = b.Left;
					return true;
				}
			}
			return false;
		}

 public override Expression VisitBinaryExpression(BinaryExpression be) {
   be.Operand1 = this.VisitExpression(be.Operand1);
   bool hcr = this.hasContextReference;
   this.hasContextReference = false;
   be.Operand2 = this.VisitExpression(be.Operand2);
   this.hasContextReference |= hcr;
   return (Expression) this.Compose(be, this.GetComposer(be.Operand1), this.GetComposer(be.Operand2));
 }

 public void EvcBinaryExpression()
 {
     Identifier a = new Identifier("a", PrimitiveType.Word32, new TemporaryStorage("a", 1, PrimitiveType.Word32));
     BinaryExpression a1 = new BinaryExpression(Operator.IAdd, PrimitiveType.Word32, a, a);
     BinaryExpression a2 = new BinaryExpression(Operator.IAdd, PrimitiveType.Word32, a, a);
     Assert.IsTrue(eq.Equals(a1, a2));
     Assert.AreEqual(eq.GetHashCode(a1), eq.GetHashCode(a2));
 }

		public void ExsConstants()
		{
			BuildExpressionSimplifier();
			Expression expr = new BinaryExpression(Operator.IAdd, PrimitiveType.Word32, 
				Constant.Word32(1), Constant.Word32(2));
			Constant c = (Constant) expr.Accept(simplifier);

			Assert.AreEqual(3, c.ToInt32());
		}

        void EmitBinaryExpression(BinaryExpression expr, MethodInfo method)
        {
            // Compute the operands
            VisitExpression(expr.Left);
            VisitExpression(expr.Right);

            // Call the operator method
            IL.Emit(OpCodes.Call, method);
        }

 /// <summary>
 /// Extends an effective address ''id'' to ''id'' + 0. 
 /// </summary>
 /// <remarks>
 /// The purpose here is to extend the effective address to avoid premature typing of id.
 /// If later in the type inference process [[id]] is discovered to be a signed integer, the
 /// decompiler can accomodate that by having the added 0 be [[pointer]] or [[member pointer]].
 /// This is not possible if all we have is the id.
 /// </remarks>
 /// <param name="ea"></param>
 /// <returns></returns>
 private Expression AddZeroToEffectiveAddress(Expression ea)
 {
     BinaryExpression bin = new BinaryExpression(
         Operator.IAdd,
         PrimitiveType.CreateWord(ea.DataType.Size),
         ea,
         Constant.Create(PrimitiveType.CreateWord(ea.DataType.Size), 0));
     return bin;
 }

        public void VpAddZero()
        {
            Identifier r = Reg32("r");
            Identifier s = Reg32("s");

            var sub = new BinaryExpression(Operator.ISub, PrimitiveType.Word32, new MemoryAccess(MemoryIdentifier.GlobalMemory, r, PrimitiveType.Word32), Constant.Word32(0));
            var vp = new ExpressionSimplifier(new SsaEvaluationContext(arch, ssaIds));
            var exp = sub.Accept(vp);
            Assert.AreEqual("Mem0[r:word32]", exp.ToString());
        }

		public bool Match(Identifier id)
		{
            this.id = id;
            bin = ctx.GetValue(id) as BinaryExpression;
			if (bin == null)
				return false;
            if (ctx.IsUsedInPhi(id))
                return false;
			return (bin.Left is Identifier) && (bin.Right is Constant);
		}

		public bool Match(BinaryExpression binExp)
		{
			idLeft = binExp.Left as Identifier;
			if (idLeft == null)
				return false;
			idRight = binExp.Right as Identifier;
			if (idRight == null)
				return false;
			return (idLeft == idRight && binExp.Operator == Operator.IAdd);
		}

		public bool Match(UnaryExpression unary)
		{
			if (unary.Operator == Operator.Neg)
			{
				bin = unary.Expression as BinaryExpression;
				if (bin != null && bin.Operator == Operator.ISub)
					return true;
			}
			return false;
		}

 private void PrintResolvedBinaryExpression(BinaryExpression node, int indent)
 {
     AppendLine(indent, "Type = " + node.Type);
     AppendLine(indent, "CommonType = " + node.CommonType);
     AppendLine(indent, "ExpressionType = " + node.ExpressionType);
     AppendLine(indent, "Left =");
     PrintNode(node.Left, indent + 1);
     AppendLine(indent, "Right =");
     PrintNode(node.Right, indent + 1);
 }

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="listExpression"></param>
        /// <param name="condition"></param>
        /// <param name="expression"></param>
        /// <param name="root">the root element for which this expression should be parsed</param>
        public SumExpression(ModelElement root, Expression listExpression, Expression condition, Expression expression)
            : base(root, listExpression, condition, expression)
        {
            AccumulatorVariable = (Variables.Variable)Generated.acceptor.getFactory().createVariable();
            AccumulatorVariable.Enclosing = this;
            AccumulatorVariable.Name = "RESULT";
            Utils.ISubDeclaratorUtils.AppendNamable(this, AccumulatorVariable);

            Accumulator = new BinaryExpression(root, expression, BinaryExpression.OPERATOR.ADD, new UnaryExpression(root, new Term(root, new Designator(root, "RESULT"))));
            Accumulator.Enclosing = this;
        }