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:     _succs = succs;
    }
  
    void _buildPostOrder() {
      var N = _N;
      var E = _E;
      var firstSuccs = _firstSuccs;
      var succs = _succs;
  
      var postOrderOrdinals = new Uint32List(N);
      var postOrderIndices = new Uint32List(N + 1);
      var stackNodes = new Uint32List(N);
      var stackCurrentEdgePos = new Uint32List(N);
  
      var visited = new Uint8List(N + 1);
      var postOrderIndex = 0;
      var stackTop = 0;
      var root = 1;
  
      stackNodes[0] = root;
      stackCurrentEdgePos[0] = firstSuccs[root];
      visited[root] = 1;
  
      while (stackTop >= 0) {
        var n = stackNodes[stackTop];
        var edgePos = stackCurrentEdgePos[stackTop];
  
        if (edgePos < firstSuccs[n + 1]) {
          var childId = succs[edgePos];
          edgePos++;
          stackCurrentEdgePos[stackTop] = edgePos;
          if (visited[childId] == 1) continue;
  
          // Push child.
          stackTop++;
          stackNodes[stackTop] = childId;
          edgePos = firstSuccs[childId];
          stackCurrentEdgePos[stackTop] = edgePos;
          visited[childId] = 1;
        } else {
          // Done with all children.
          postOrderIndices[n] = postOrderIndex;
          postOrderOrdinals[postOrderIndex++] = n;
          stackTop--;
        }
      }
  
      assert(postOrderIndex == N);
      assert(postOrderOrdinals[N - 1] == root);
  
      _postOrderOrdinals = postOrderOrdinals;
      _postOrderIndices = postOrderIndices;
      _E = E;
    }
  
    void _buildPredecessors() {
  
negative.code:     _preds = preds;
    }
  
    static int _eval(int v,
                     Uint32List ancestor,
                     Uint32List semi,
                     Uint32List label,
                     Uint32List stackNode,
                     Uint8List stackState) {
      if (ancestor[v] == 0) {
        return label[v];
      } else {
        {
          // Inlined 'compress' with an explicit stack to prevent JS stack
          // overflow.
          var top = 0;
          stackNode[top] = v;
          stackState[top] = 0;
          while (top >= 0) {
            var v = stackNode[top];
            var state = stackState[top];
            if (state == 0) {
              assert(ancestor[v] != 0);
              if (ancestor[ancestor[v]] != 0) {
                stackState[top] = 1;
                // Recurse with ancestor[v]
                top++;
                stackNode[top] = ancestor[v];
                stackState[top] = 0;
              } else {
                top--;
              }
            } else {
              assert(state == 1);
              if (semi[label[ancestor[v]]] < semi[label[v]]) {
                label[v] = label[ancestor[v]];
              }
              ancestor[v] = ancestor[ancestor[v]];
              top--;
            }
          }
        }
  
        if (semi[label[ancestor[v]]] >= semi[label[v]]) {
          return label[v];
        } else {
          return label[ancestor[v]];
        }
      }
    }
  
    // Note the version in the main text of Lengauer & Tarjan incorrectly
    // uses parent instead of ancestor. The correct version is in Appendix B.
    static void _link(int v,
                      int w,
                      Uint32List size,
                      Uint32List label,
                      Uint32List semi,
                      Uint32List child,
                      Uint32List ancestor) {
      assert(size[0] == 0);
      assert(label[0] == 0);
      assert(semi[0] == 0);
      var s = w;
      while (semi[label[w]] < semi[label[child[s]]]) {
        if (size[s] + size[child[child[s]]] >= 2 * size[child[s]]) {
          ancestor[child[s]] = s;
          child[s] = child[child[s]];
        } else {
          size[child[s]] = size[s];
          s = ancestor[s] = child[s];
        }
      }
      label[s] = label[w];
      size[v] = size[v] + size[w];
      if (size[v] < 2 * size[w]) {
        var tmp = s;
        s = child[v];
        child[v] = tmp;
      }
      while (s != 0) {
        ancestor[s] = v;
        s = child[s];
      }
    }
  
    // T. Lengauer and R. E. Tarjan. "A Fast Algorithm for Finding Dominators
    // in a Flowgraph."
    void _buildDominators() {
      var N = _N;
  
      var vertex = _vertex;
      var semi = _semi;
      var parent = _parent;
      var firstPreds = _firstPreds;
      var preds = _preds;
  
      var root = 1;
      var dom = new Uint32List(N + 1);
  
      var ancestor = new Uint32List(N + 1);
      var label = new Uint32List(N + 1);
      for (var i = 1; i <= N; i++) {
        label[i] = i;
      }
      var buckets = new List(N + 1);
      var child = new Uint32List(N + 1);
      var size = new Uint32List(N + 1);
      for (var i = 1; i <= N; i++) {
        size[i] = 1;
      }
      var stackNode = new Uint32List(N + 1);
      var stackState = new Uint8List(N + 1);
  
      for (var i = N; i > 1; i--) {
        var w = vertex[i];
        assert(w != root);
  
        // Lengauer & Tarjan Step 2.
        var startPred = firstPreds[w];
        var limitPred = firstPreds[w + 1];
        for (var predIndex = startPred;
             predIndex < limitPred;
             predIndex++) {
          var v = preds[predIndex];
          var u = _eval(v, ancestor, semi, label, stackNode, stackState);
          if (semi[u] < semi[w]) {
            semi[w] = semi[u];
          }
        }
  
        // w.semi.bucket.add(w);
        var tmp = vertex[semi[w]];
        if (buckets[tmp] == null) {
          buckets[tmp] = new List();
        }
        buckets[tmp].add(w);
  
        _link(parent[w], w, size, label, semi, child, ancestor);
  
        // Lengauer & Tarjan Step 3.
        tmp = parent[w];
        var bucket = buckets[tmp];
        buckets[tmp] = null;
        if (bucket != null) {
          for (var v in bucket) {
            var u = _eval(v, ancestor, semi, label, stackNode, stackState);
            dom[v] = semi[u] < semi[v] ? u : parent[w];
          }
        }
      }
      for (var i = 1; i <= N; i++) {
        assert(buckets[i] == null);
      }
      // Lengauer & Tarjan Step 4.
      for (var i = 2; i <= N; i++) {
        var w = vertex[i];
        if (dom[w] != vertex[semi[w]]) {
          dom[w] = dom[dom[w]];
        }
      }
  
      _doms = dom;
    }
  
    void _calculateRetainedSizes() {
  