anchor.diff:  
     _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;
  +    _milliSeconds = 0;
  +    _wakeupTime = 0;
     }
   
     bool get _repeating => _milliSeconds >= 0;
  
positive.code:       }
        _EventHandler._sendData(null,
                                _receivePort,
                                _firstZeroTimer != null ?
                                    0 : _heap.first._wakeupTime);
      }
    }
  
    void _handleTimeout(_) {
      int currentTime = new DateTime.now().millisecondsSinceEpoch;
      // Collect all pending timers.
      var timer = _firstZeroTimer;
      var nextTimer = _lastZeroTimer;
      _firstZeroTimer = _lastZeroTimer = null;
      while (_heap.isNotEmpty && _heap.first._wakeupTime <= currentTime) {
        var next = _heap.removeFirst();
        if (timer == null) {
          nextTimer = timer = next;
        } else {
          nextTimer = nextTimer._indexOrNext = next;
        }
      }
  
      // 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.
      _handlingCallbacks = true;
      try {
        while (timer != null) {
          var next = timer._indexOrNext;
          timer._indexOrNext = null;
          // 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._addTimerToHeap();
            }
          }
          timer = next;
        }
      } finally {
        _handlingCallbacks = false;
        _notifyEventHandler();
      }
    }
  
    // Creates a receive port and registers the timer handler on that
    // receive port.
    void _createTimerHandler() {
      if(_receivePort == null) {
        _receivePort = new RawReceivePort(_handleTimeout);
      }
    }
  
  
negative.code:           new DateTime.now().millisecondsSinceEpoch + 1 + milliSeconds;
      }
      timer._milliSeconds = repeating ? milliSeconds : -1;
      timer._addTimerToList();
      if (identical(timer, _timers.first)) {
        // The new timer is the first in queue. Update event handler.
        timer._notifyEventHandler();
      }
  