anchor.diff:      attachLocationToLast(node);
     }
   
  +  static String mapRelationalOperator(String op, bool inverse) {
  +    Map<String, String> inverseOperator = const <String, String>{
  +      "==" : "!=",
  +      "!=" : "==",
  +      "===": "!==",
  +      "!==": "===",
  +      "<"  : ">=",
  +      "<=" : ">",
  +      ">"  : "<=",
  +      ">=" : "<"
  +    };
  +    return inverse ? inverseOperator[op] : op;
  +  }
  +
     void generateNot(HInstruction input) {
       bool canGenerateOptimizedComparison(HInstruction instruction) {
         if (instruction is !HRelational) return false;
  
positive.code:     }
    }
  
    void emitIdentityComparison(HInstruction left, HInstruction right) {
      String op = singleIdentityComparison(left, right);
      if (op != null) {
        use(left);
        js.Expression jsLeft = pop();
        use(right);
        push(new js.Binary(op, jsLeft, pop()));
      } else {
        assert(NullConstant.JsNull == 'null');
        use(left);
  
negative.code:           && right.instructionType.isUseful() && right.isInteger();
      }
  
      bool generateAtUseSite = isGenerateAtUseSite(input);
      if (input is HIdentity && generateAtUseSite) {
        emitIdentityComparison(input.left, input.right, true);
      } else if (input is HBoolify && generateAtUseSite) {
        use(input.inputs[0]);
        push(new js.Binary("!==", pop(), newLiteralBool(true)), input);
      } else if (canGenerateOptimizedComparison(input) && generateAtUseSite) {
        HRelational relational = input;
        BinaryOperation operation = relational.operation(backend.constantSystem);
        String op = mapRelationalOperator(operation.name.stringValue, true);
        visitRelational(input, op);
      } else {
        use(input);
        push(new js.Prefix("!", pop()));
  