anchor.diff:            new DateTime.now().millisecondsSinceEpoch + 1 + milliSeconds;
       }
       timer._milliSeconds = repeating ? milliSeconds : -1;
  -    if (timer._addTimerToHeap()) {
  +    timer._addTimerToList();
  +    if (identical(timer, _timers.first)) {
         // The new timer is the first in queue. Update event handler.
         timer._notifyEventHandler();
       }
  
positive.code: 
    _Timer._internal() {}
  
    bool get _isInHeap => _id >= 0;
  
    void _clear() {
      _callback = null;
    }
  
    int _compareTo(_Timer other) {
      int c = _wakeupTime - other._wakeupTime;
      if (c != 0) return c;
      return _id - other._id;
    }
  
    bool get _repeating => _milliSeconds >= 0;
  
negative.code:       }
        _EventHandler._sendData(null,
                                _receivePort,
                                _timers.first._wakeupTime);
      }
    }
  
  
    // Creates a receive port and registers the timer handler on that
    // receive port.
    void _createTimerHandler() {
  
      void _handleTimeout() {
        int currentTime = new DateTime.now().millisecondsSinceEpoch;
  
        // Collect all pending timers.
        var pending_timers = new List();
        while (!_timers.isEmpty) {
          _Timer entry = _timers.first;
          if (entry._wakeupTime <= currentTime) {
            entry.unlink();
            pending_timers.add(entry);
          } else {
            break;
          }
        }
  
        // Trigger all of the pending timers. New timers added as part of the
        // callbacks will be enqueued now and notified in the next spin at the
        // earliest.
        _handling_callbacks = true;
        try {
          for (var timer in pending_timers) {
            // One of the timers in the pending_timers list can cancel
            // one of the later timers which will set the callback to
            // null.
            if (timer._callback != null) {
              var callback = timer._callback;
              if (!timer._repeating) {
                //Mark timer as inactive.
                timer._callback = null;
              }
              callback(timer);
              // Re-insert repeating timer if not canceled.
              if (timer._repeating && timer._callback != null) {
                timer._advanceWakeupTime();
                timer._addTimerToList();
              }
            }
          }
        } finally {
          _handling_callbacks = false;
          _notifyEventHandler();
        }
      }
  
      if(_receivePort == null) {
        _receivePort = new RawReceivePort((_) { _handleTimeout(); });
      }
    }
  
  