anchor.diff:          if (node.arguments.length == 2) {
             Primitive arg = node.dartArgument(0);
             AbstractValue argValue = getValue(arg);
  -          if (lattice.isDefinitelyInt(receiverValue) &&
  +          if (lattice.isDefinitelyInt(receiverValue, allowNull: true) &&
                 lattice.isDefinitelyInt(argValue) &&
                 isIntNotZero(argValue)) {
  -            return
  -                replaceWithBinary(BuiltinOperator.NumRemainder, receiver, arg);
  +            return makeBinary(BuiltinOperator.NumRemainder,
  +                guard: BuiltinOperator.IsNumber);
             }
           }
         } else if (name == 'codeUnitAt') {
  
positive.code:           }
          }
          if (behavesLikeIdentical) {
            return replaceWithBinary(BuiltinOperator.Identical,
                leftArg, rightArg);
          }
        } else {
          if (lattice.isDefinitelyNum(left, allowNull: trustPrimitives) &&
              lattice.isDefinitelyNum(right, allowNull: trustPrimitives)) {
            // Try to insert a numeric operator.
            BuiltinOperator operator = NumBinaryBuiltins[opname];
            if (operator != null) {
              return replaceWithBinary(operator, leftArg, rightArg);
            }
            // Shift operators are not in [NumBinaryBuiltins] because Dart shifts
            // behave different to JS shifts, especially in the handling of the
            // shift count.
            // Try to insert a shift-left operator.
            if (opname == '<<' &&
                lattice.isDefinitelyInt(left, allowNull: trustPrimitives) &&
                lattice.isDefinitelyIntInRange(right, min: 0, max: 31)) {
              return replaceWithBinary(BuiltinOperator.NumShl, leftArg, rightArg);
            }
            // Try to insert a shift-right operator. JavaScript's right shift is
            // consistent with Dart's only for left operands in the unsigned
            // 32-bit range.
            if (opname == '>>' &&
                lattice.isDefinitelyUint32(left, allowNull: trustPrimitives) &&
                lattice.isDefinitelyIntInRange(right, min: 0, max: 31)) {
              return replaceWithBinary(BuiltinOperator.NumShr, leftArg, rightArg);
            }
            // Try to use remainder for '%'. Both operands must be non-negative
            // and the divisor must be non-zero.
            if (opname == '%' &&
                lattice.isDefinitelyUint(left, allowNull: trustPrimitives) &&
                lattice.isDefinitelyUint(right) &&
                lattice.isDefinitelyIntInRange(right, min: 1)) {
              return replaceWithBinary(
                  BuiltinOperator.NumRemainder, leftArg, rightArg);
            }
  
            if (opname == '~/' &&
                lattice.isDefinitelyUint32(left, allowNull: trustPrimitives) &&
                lattice.isDefinitelyIntInRange(right, min: 2)) {
              return replaceWithBinary(
                  BuiltinOperator.NumTruncatingDivideToSigned32,
                  leftArg, rightArg);
            }
          }
          if (lattice.isDefinitelyString(left, allowNull: trustPrimitives) &&
              lattice.isDefinitelyString(right, allowNull: trustPrimitives) &&
              opname == '+') {
            return replaceWithBinary(BuiltinOperator.StringConcatenate,
                                     leftArg, rightArg);
          }
        }
      }
  
negative.code:       Primitive argument = node.dartReceiver;
        AbstractValue value = getValue(argument);
  
        if (lattice.isDefinitelyNum(value, allowNull: true)) {
          String opname = node.selector.name;
          if (opname == '~') {
            return makeUnary(BuiltinOperator.NumBitNot,
                guard: BuiltinOperator.IsNumber);
          }
          if (opname == 'unary-') {
            return makeUnary(BuiltinOperator.NumNegate,
                guard: BuiltinOperator.IsNumber);
          }
        }
      }
  