anchor.diff:  
   part of dart.io;
   
  -// Timer heap implemented as a array-based binary heap[0].
  -// This allows for O(1) `first`, O(log(n)) `remove`/`removeFirst` and O(log(n))
  -// `add`.
  -//
  -// To ensure the timers are ordered by insertion time, the _Timer class has a
  -// `_id` field set when added to the heap.
  -//
  -// [0] http://en.wikipedia.org/wiki/Binary_heap
  -class _TimerHeap {
  -  List<_Timer> _list;
  -  int _used = 0;
  -
  -  _TimerHeap([int initSize = 7])
  -      : _list = new List<_Timer>(initSize);
  -
  -  bool get isEmpty => _used == 0;
  -  bool get isNotEmpty => _used > 0;
  -
  -  _Timer get first => _list[0];
  -
  -  bool isFirst(_Timer timer) => timer._indexOrNext == 0;
  -
  -  void add(_Timer timer) {
  -    if (_used == _list.length) {
  -      _resize();
  -    }
  -    timer._indexOrNext = _used++;
  -    _list[timer._indexOrNext] = timer;
  -    _bubbleUp(timer);
  -  }
  -
  -  _Timer removeFirst() {
  -    var f = first;
  -    remove(f);
  -    return f;
  -  }
  -
  -  void remove(_Timer timer) {
  -    _used--;
  -    timer._id = -1;
  -    if (isEmpty) {
  -      _list[0] = null;
  -      timer._indexOrNext = null;
  -      return;
  -    }
  -    var last = _list[_used];
  -    last._indexOrNext = timer._indexOrNext;
  -    _list[last._indexOrNext] = last;
  -    if (last._compareTo(timer) < 0) {
  -      _bubbleUp(last);
  -    } else {
  -      _bubbleDown(last);
  -    }
  -    _list[_used] = null;
  -    timer._indexOrNext = null;
  -  }
  -
  -  void _resize() {
  -    var newList = new List(_list.length * 2 + 1);
  -    newList.setRange(0, _used, _list);
  -    _list = newList;
  -  }
  -
  -  void _bubbleUp(_Timer timer) {
  -    while (!isFirst(timer)) {
  -      Timer parent = _parent(timer);
  -      if (timer._compareTo(parent) < 0) {
  -        _swap(timer, parent);
  -      } else {
  -        break;
  -      }
  -    }
  -  }
  -
  -  void _bubbleDown(_Timer timer) {
  -    while (true) {
  -      int leftIndex = _leftChildIndex(timer._indexOrNext);
  -      int rightIndex = _rightChildIndex(timer._indexOrNext);
  -      _Timer newest = timer;
  -      if (leftIndex < _used && _list[leftIndex]._compareTo(newest) < 0) {
  -        newest = _list[leftIndex];
  -      }
  -      if (rightIndex < _used && _list[rightIndex]._compareTo(newest) < 0) {
  -        newest = _list[rightIndex];
  -      }
  -      if (newest == timer) {
  -        // We are where we should be, break.
  -        break;
  -      }
  -      _swap(newest, timer);
  -    }
  -  }
  -
  -  void _swap(_Timer first, _Timer second) {
  -    int tmp = first._indexOrNext;
  -    first._indexOrNext = second._indexOrNext;
  -    second._indexOrNext = tmp;
  -    _list[first._indexOrNext] = first;
  -    _list[second._indexOrNext] = second;
  -  }
  -
  -  Timer _parent(_Timer timer) => _list[_parentIndex(timer._indexOrNext)];
  -  Timer _leftChild(_Timer timer) => _list[_leftChildIndex(timer._indexOrNext)];
  -  Timer _rightChild(_Timer timer) =>
  -      _list[_rightChildIndex(timer._indexOrNext)];
  -
  -  static int _parentIndex(int index) => (index - 1) ~/ 2;
  -  static int _leftChildIndex(int index) => 2 * index + 1;
  -  static int _rightChildIndex(int index) => 2 * index + 2;
  -}
  -
  -class _Timer implements Timer {
  +class _Timer extends LinkedListEntry<_Timer> implements Timer {
     // Disables the timer.
     static const int _NO_TIMER = -1;
   
     // Timers are ordered by wakeup time.
  -  static _TimerHeap _heap = new _TimerHeap();
  -  static _Timer _firstZeroTimer;
  -  static _Timer _lastZeroTimer;
  -  static int _idCount = 0;
  +  static LinkedList<_Timer> _timers = new LinkedList<_Timer>();
   
     static RawReceivePort _receivePort;
  -  static bool _handlingCallbacks = false;
  +  static bool _handling_callbacks = false;
   
     Function _callback;
     int _milliSeconds;
     int _wakeupTime = 0;
  -  var _indexOrNext;
  -  int _id = -1;
   
     static Timer _createTimer(void callback(Timer timer),
                               int milliSeconds,
  
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: 
    // Adds a timer to the timer list. Timers with the same wakeup time are
    // enqueued in order and notified in FIFO order.
    void _addTimerToList() {
      _Timer entry = _timers.isEmpty ? null : _timers.first;
      // If timer is last, add to end.
      if (entry == null || _timers.last._wakeupTime <= _wakeupTime) {
        _timers.add(this);
        return;
      }
      // Otherwise scan through and find the right position.
      while (entry != null) {
        if (_wakeupTime < entry._wakeupTime) {
          entry.insertBefore(this);
          return;
        }
        entry = entry.next;
      }
      _timers.add(this);
    }
  
  
    void _notifyEventHandler() {
      if (_handling_callbacks) {
        // While we are already handling callbacks we will not notify the event
        // handler. _handleTimeout will call _notifyEventHandler once all pending
        // timers are processed.
        return;
      }
  
      if (_timers.isEmpty) {
        // No pending timers: Close the receive port and let the event handler
        // know.
        if (_receivePort != null) {
  