anchor.diff:    }
   
     _ReductionTask(this.kind, this.node) {
  -    assert(node is Continuation || node is LetPrim || node is Parameter);
  +    assert(node is Continuation || node is LetPrim || node is Parameter ||
  +           node is Branch);
     }
   
     bool operator==(_ReductionTask that) {
  
positive.code:       worklist.add(new _ReductionTask(_ReductionKind.BETA_CONT_LIN, node));
      } else if (_isEtaCont(node)) {
        worklist.add(new _ReductionTask(_ReductionKind.ETA_CONT, node));
      }
    }
  
  
negative.code: 
      // Perform bookkeeping on removed body and scan for new redexes.
      new _RemovalVisitor(_worklist).visit(cont);
    }
  
    void _reduceBranch(_ReductionTask task) {
      Branch branch = task.node;
      // Replace Branch with InvokeContinuation of one of the targets. When the
      // branch is deleted the other target becomes unreferenced and the chosen
      // target becomes available for eta-cont and further reductions.
      Continuation target;
      Primitive condition = branch.condition.definition;
      if (condition is Constant) {
        target = isTruthyConstant(condition.value, strict: branch.isStrictCheck)
            ? branch.trueContinuation.definition
            : branch.falseContinuation.definition;
      } else if (_isBranchTargetOfUselessIf(branch.trueContinuation.definition)) {
        target = branch.trueContinuation.definition;
      } else {
        return;
      }
  
      InvokeContinuation invoke = new InvokeContinuation(
          target, <Primitive>[]
          // TODO(sra): Add sourceInformation.
          /*, sourceInformation: branch.sourceInformation*/);
      branch.parent.body = invoke;
      invoke.parent = branch.parent;
      branch.parent = _DELETED;
  
      new _RemovalVisitor(_worklist).visit(branch);
    }
  
    void _reduceDeadParameter(_ReductionTask task) {
  