anchor.diff:  
       _firstPreds = null;
       _preds = null;
  -    _postOrderIndices = null;
  +
  +    _semi = null;
  +    _parent = null;
   
       statusReporter.add("Finding retained sizes...");
       await new Future(() => _calculateRetainedSizes());
   
  -    _postOrderOrdinals = null;
  +    _vertex = null;
   
       statusReporter.add("Loaded");
       return this;
  
positive.code:     _preds = preds;
    }
  
    // "A Simple, Fast Dominance Algorithm"
    // Keith D. Cooper, Timothy J. Harvey, and Ken Kennedy
    void _buildDominators() {
      var N = _N;
  
      var postOrder = _postOrderOrdinals;
      var postOrderIndex = _postOrderIndices;
      var firstPreds = _firstPreds;
      var preds = _preds;
  
      var root = 1;
      var rootPostOrderIndex = postOrderIndex[root];
      var domByPOI = new Uint32List(N + 1);
  
      domByPOI[rootPostOrderIndex] = rootPostOrderIndex;
  
      var iteration = 0;
      var changed = true;
      while (changed) {
        changed = false;
        Logger.root.info("Find dominators iteration $iteration");
        iteration++; // dart2js heaps typically converge in 10 iterations.
  
        // Visit the nodes, except the root, in reverse post order (top down).
        for (var curPostOrderIndex = rootPostOrderIndex - 1;
             curPostOrderIndex > 1;
             curPostOrderIndex--) {
          if (domByPOI[curPostOrderIndex] == rootPostOrderIndex)
            continue;
  
          var nodeOrdinal = postOrder[curPostOrderIndex];
          var newDomIndex = 0; // 0 = undefined
  
          // Intersect the DOM sets of the node's precedessors.
          var beginPredIndex = firstPreds[nodeOrdinal];
          var endPredIndex = firstPreds[nodeOrdinal + 1];
          for (var predIndex = beginPredIndex;
               predIndex < endPredIndex;
               predIndex++) {
            var predOrdinal = preds[predIndex];
            var predPostOrderIndex = postOrderIndex[predOrdinal];
            if (domByPOI[predPostOrderIndex] != 0) {
              if (newDomIndex == 0) {
                newDomIndex = predPostOrderIndex;
              } else {
                // Note this two finger algorithm to find the DOM intersection
                // relies on comparing nodes by their post order index.
                while (predPostOrderIndex != newDomIndex) {
                  while(predPostOrderIndex < newDomIndex)
                    predPostOrderIndex = domByPOI[predPostOrderIndex];
                  while (newDomIndex < predPostOrderIndex)
                    newDomIndex = domByPOI[newDomIndex];
                }
              }
              if (newDomIndex == rootPostOrderIndex) {
                break;
              }
            }
          }
          if (newDomIndex != 0 && domByPOI[curPostOrderIndex] != newDomIndex) {
            domByPOI[curPostOrderIndex] = newDomIndex;
            changed = true;
          }
        }
      }
  
      Logger.root.info("Start remap dominators");
  
      // Reindex doms by id instead of post order index so we can throw away
      // the post order arrays.
      var domById = new Uint32List(N + 1);
      for (var id = 1; id <= N; id++) {
        domById[id] = postOrder[domByPOI[postOrderIndex[id]]];
      }
  
      Logger.root.info("End remap dominators");
  
      domById[root] = 0;
  
      _doms = domById;
    }
  
    void _calculateRetainedSizes() {
  
negative.code: 
    // Intermediates.
    AddressMapper _addrToId;
    Uint32List _vertex;
    Uint32List _parent;
    Uint32List _semi;
    Uint32List _firstPreds; // Offset into preds.
    Uint32List _preds;
  
  