anchor.diff:    final Completer _closeCompleter = new Completer();
   
     // Has the stream been paused or unsubscribed?
  -  bool _paused = false;
     bool _unsubscribed = false;
   
     // Is there a read currently in progress?
  -  bool _readInProgress = false;
  +  bool _readInProgress = true;
     bool _closed = false;
   
  -  // Block read but not yet send because stream is paused.
  -  List<int> _currentBlock;
  +  bool _atEnd = false;
   
     _FileStream(this._path, this._position, this._end) {
  -    _setupController();
  -  }
  -
  -  _FileStream.forStdin() : _position = 0 {
  -    _setupController();
  -  }
  +    if (_position == null) _position = 0;
  +  }
  +
  +  _FileStream.forStdin() : _position = 0;
   
     StreamSubscription<List<int>> listen(void onData(List<int> event),
                                          {Function onError,
                                           void onDone(),
                                           bool cancelOnError}) {
  +    _setupController();
       return _controller.stream.listen(onData,
                                        onError: onError,
                                        onDone: onDone,
  
positive.code:   }
  
    void _start() {
      if (_position == null) {
        _position = 0;
      } else if (_position < 0) {
        _controller.addError(new RangeError("Bad start position: $_position"));
        _controller.close();
        return;
      }
      Future<RandomAccessFile> openFuture;
      if (_path != null) {
        openFuture = new File(_path).open(mode: FileMode.READ);
      } else {
        openFuture = new Future.value(_File._openStdioSync(0));
      }
      _readInProgress = true;
      openFuture
        .then((RandomAccessFile opened) {
          _openedFile = opened;
          if (_position > 0) {
            return opened.setPosition(_position);
          }
        })
        .whenComplete(() {
          _readInProgress = false;
        })
        .then((_) => _readBlock())
        .catchError((e) {
          _controller.addError(e);
          _closeFile();
        });
    }
  
    void _resume() {
      _paused = false;
      if (_currentBlock != null) {
        _controller.add(_currentBlock);
        _currentBlock = null;
      }
      // Resume reading unless we are already done.
      if (_openedFile != null) _readBlock();
    }
  }
  
  
negative.code:   void _setupController() {
      _controller = new StreamController<List<int>>(sync: true,
          onListen: _start,
          onResume: _readBlock,
          onCancel: () {
            _unsubscribed = true;
            return _closeFile();
  