anchor.diff:  }
   
   class _SyncStarIterator implements Iterator {
  -  final dynamic _body;
  -
  -  // If [runningNested] this is the nested iterator, otherwise it is the
  -  // current value.
  +  // _SyncStarIterator handles stepping a sync* generator body state machine.
  +  //
  +  // It also handles the stepping over 'nested' iterators to flatten yield*
  +  // statements. For non-sync* iterators, [_nestedIterator] contains the
  +  // iterator. We delegate to [_nestedIterator] when it is not `null`.
  +  //
  +  // For nested sync* iterators, [this] iterator acts on behalf of the innermost
  +  // nested sync* iterator. The current state machine is suspended on a stack
  +  // until the inner state machine ends.
  +
  +  // The state machine for the innermost _SyncStarIterator.
  +  dynamic _body;
  +
  +  // The current value, unless iterating a non-sync* nested iterator.
     dynamic _current = null;
  -  bool _runningNested = false;
  -
  -  get current => _runningNested ? _current.current : _current;
  +
  +  // This is the nested iterator when iterating a yield* of a non-sync iterator.
  +  Iterator _nestedIterator = null;
  +
  +  // Stack of suspended state machines when iterating a yield* of a sync*
  +  // iterator.
  +  List _suspendedBodies = null;
   
     _SyncStarIterator(this._body);
  +
  +  get current => _nestedIterator == null ? _current : _nestedIterator.current;
   
     _runBody() {
       // TODO(sra): Find a way to hard-wire SUCCESS and ERROR codes.
  
positive.code:         _body, async_error_codes.SUCCESS, async_error_codes.ERROR);
    }
  
  
    bool moveNext() {
      if (_runningNested) {
        if (_current.moveNext()) {
          return true;
        } else {
          _runningNested = false;
        }
      }
      _current = _runBody();
      if (_current is _IterationMarker) {
        if (_current.state == _IterationMarker.ITERATION_ENDED) {
          _current = null;
          // Rely on [_body] to repeatedly return `ITERATION_ENDED`.
          return false;
        } else if (_current.state == _IterationMarker.UNCAUGHT_ERROR) {
          // Rely on [_body] to repeatedly return `UNCAUGHT_ERROR`.
          // This is a wrapped exception, so we use JavaScript throw to throw it.
          JS('', 'throw #', _current.value);
        } else {
          assert(_current.state == _IterationMarker.YIELD_STAR);
          _current = _current.value.iterator;
          _runningNested = true;
          return moveNext();
        }
      }
      return true;
    }
  }
  
  
negative.code:   final value;
    final int state;
  
    const _IterationMarker._(this.state, this.value);
  
    static yieldStar(dynamic /* Iterable or Stream */ values) {
      return new _IterationMarker._(YIELD_STAR, values);
    }
  
    static endOfIteration() {
      return const _IterationMarker._(ITERATION_ENDED, null);
    }
  
    static yieldSingle(dynamic value) {
  