anchor.diff:      s();
   
       var continueBlock = currentBlock = emptyBlock();
  -    visit(node.condition)(f, (expr) {
  +    visit(node.condition)((expr) {
         var savedBlock = currentBlock;
         var bodyBlock = currentBlock = emptyBlock();
   
         _addJumpTargets(node, breakName, breakTargets, breakLabels);
         _addJumpTargets(node, continueName, continueTargets, continueLabels);
  -      visit(node.body)(f, r, () {
  +      visit(node.body)(r, () {
           addStatement(
               AstFactory.returnStatement2(
                   AstFactory.functionExpressionInvocation(
  
positive.code: 
        breakTargets = breakTargets.map(newJumpTarget).toList();
        continueTargets = continueTargets.map(newJumpTarget).toList();
        var fail = f, ret = r;
        f = (e) {
          addStatement(
              AstFactory.returnStatement2(
                  functionExpression([], applyExpressionCont(fail, e))));
        };
        r = (v) {
          addStatement(
              AstFactory.returnStatement2(
  
negative.code:   // ---- Statements ----
    unimplemented(ast.AstNode node) => throw 'Unimplemented(${node.runtimeType})';
  
    visitAssertStatement(ast.AssertStatement node) => (r, s) {
      return visit(node.condition)((cond) {
        addStatement(AstFactory.assertStatement(cond));
        return s();
      });
    };
  
    _translateStatementList(ast.NodeList<ast.Statement> list, r, s) {
      for (var stmt in list.reversed) {
        var nextCont = s;
        s = () => visit(stmt)(r, nextCont);
      }
      return s();
    }
  
    visitBlock(ast.Block node) => (r, s) {
      return _translateStatementList(node.statements, r, s);
    };
  
    ast.Expression _findJumpTarget(node, List<ast.Expression> targets,
  