anchor.diff:    /// executing write tasks with this priority.
     Future write([int priority = lowestPriority]) {
       if (priority == lowestPriority) {
  -      if (_lowestPriorityWriteGroup == null) {
  -        _lowestPriorityWriteGroup = new _WriteGroup(lowestPriority);
  -        _lowestPriorityWriteGroup._completer = new Completer();
  +      if (_writeGroup == null) {
  +        _writeGroup = new _WriteGroup(lowestPriority);
  +        _writeGroup._completer = new Completer();
         }
  -      return _lowestPriorityWriteGroup._completer.future;
  -    }
  -
  -    if (priority >= _writeGroups.length) {
  -      var i = _writeGroups.length;
  +      return _writeGroup._completer.future;
  +    }
  +
  +    if (priority >= _prioWriteGroups.length) {
  +      var i = _prioWriteGroups.length;
         while (i <= priority) {
  -        _writeGroups.add(new _WriteGroup(i++));
  +        _prioWriteGroups.add(new _WriteGroup(i++));
         }
       }
  -    final g = _writeGroups[priority];
  +
  +    final g = _prioWriteGroups[priority];
       if (g._completer == null) {
         g._completer = new Completer();
         _writeQueue.add(g);
       }
  +
       return g._completer.future;
     }
   
  
positive.code:     return _nextFrame;
    }
  
    void _scheduleMicrotask(Zone self, ZoneDelegate parent, Zone zone, void f()) {
      if (_running) {
        _currentTasks.add(f);
      } else {
        parent.scheduleMicrotask(zone, f);
  
negative.code:   }
  }
  
  /// [Scheduler].
  class Scheduler {
    static const int runningFlag = 1;
    static const int tickPendingFlag = 1 << 1;
    static const int framePendingFlag = 1 << 2;
  
    int flags = 0;
    int clock = 0;
  
    bool get isRunning => ((flags & runningFlag) != 0);
  
    Queue<Function> _currentTasks = new Queue<Function>();
  
    ZoneSpecification _zoneSpec;
    Zone _zone;
  
    /// Scheduler [Zone].
    Zone get zone => _zone;
  
    Frame _currentFrame = new Frame();
    Frame _nextFrame = new Frame();
  
    Completer _nextTickCompleter;
  
    /// [Frame] that contains tasks for the current animation frame.
    Frame get currentFrame {
      assert(isRunning);
      return _currentFrame;
    }
  
  