anchor.diff:  }
   
   
  +class _FileOperation {
  +  abstract void execute(ReceivePort port);
  +
  +  SendPort set replyPort(SendPort port) {
  +    _replyPort = port;
  +  }
  +
  +  bool isWrite() => false;
  +
  +  SendPort _replyPort;
  +}
  +
  +
  +class _ExistsOperation extends _FileOperation {
  +  _ExistsOperation(String this._name);
  +
  +  void execute(ReceivePort port) {
  +    _replyPort.send(_File._exists(_name), port.toSendPort());
  +  }
  +
  +  String _name;
  +}
  +
  +
  +class _OpenOperation extends _FileOperation {
  +  _OpenOperation(String this._name, bool this._writable);
  +
  +  void execute(ReceivePort port) {
  +    _replyPort.send(_File._open(_name, _writable), port.toSendPort());
  +  }
  +
  +  String _name;
  +  bool _writable;
  +}
  +
  +
  +class _CloseOperation extends _FileOperation {
  +  _CloseOperation(int this._id);
  +
  +  void execute(ReceivePort port) {
  +    _replyPort.send(_File._close(_id), port.toSendPort());
  +  }
  +
  +  int _id;
  +}
  +
  +
  +class _ReadByteOperation extends _FileOperation {
  +  _ReadByteOperation(int this._id);
  +
  +  void execute(ReceivePort port) {
  +    _replyPort.send(_File._readByte(_id), port.toSendPort());
  +  }
  +
  +  int _id;
  +}
  +
  +
  +class _ReadListResult {
  +  _ReadListResult(this.read, this.buffer);
  +  int read;
  +  List buffer;
  +}
  +
  +
  +class _ReadListOperation extends _FileOperation {
  +  _ReadListOperation(int this._id,
  +                     int this._length,
  +                     int this._offset,
  +                     int this._bytes);
  +
  +  void execute(ReceivePort port) {
  +    if (_bytes == 0) {
  +      _replyPort.send(0, port.toSendPort());
  +      return;
  +    }
  +    int index = _File._checkReadWriteListArguments(_length, _offset, _bytes);
  +    if (index != 0) {
  +      _replyPort.send("index out of range in readList: $index",
  +                      port.toSendPort());
  +      return;
  +    }
  +    var buffer = new List(_bytes);
  +    var result =
  +        new _ReadListResult(_File._readList(_id, buffer, 0, _bytes), buffer);
  +    _replyPort.send(result, port.toSendPort());
  +  }
  +
  +  int _id;
  +  int _length;
  +  int _offset;
  +  int _bytes;
  +}
  +
  +
  +class _WriteByteOperation extends _FileOperation {
  +  _WriteByteOperation(int this._id, int this._value);
  +
  +  void execute(ReceivePort port) {
  +    _replyPort.send(_File._writeByte(_id, _value), port.toSendPort());
  +  }
  +
  +  bool isWrite() => true;
  +
  +  int _id;
  +  int _value;
  +}
  +
  +
  +class _WriteListOperation extends _FileOperation {
  +  _WriteListOperation(int this._id,
  +                      List this._buffer,
  +                      int this._offset,
  +                      int this._bytes);
  +
  +  void execute(ReceivePort port) {
  +    if (_bytes == 0) {
  +      _replyPort.send(0, port.toSendPort());
  +      return;
  +    }
  +    int index =
  +        _File._checkReadWriteListArguments(_buffer.length, _offset, _bytes);
  +    if (index != 0) {
  +      _replyPort.send("index out of range in writeList: $index",
  +                      port.toSendPort());
  +      return;
  +    }
  +    var result = _File._writeList(_id, _buffer, _offset, _bytes);
  +    _replyPort.send(result, port.toSendPort());
  +  }
  +
  +  bool isWrite() => true;
  +
  +  int _id;
  +  List _buffer;
  +  int _offset;
  +  int _bytes;
  +}
  +
  +
  +class _WriteStringOperation extends _FileOperation {
  +  _WriteStringOperation(int this._id, String this._string);
  +
  +  void execute(ReceivePort port) {
  +    _replyPort.send(_File._writeString(_id, _string), port.toSendPort());
  +  }
  +
  +  bool isWrite() => true;
  +
  +  int _id;
  +  String _string;
  +}
  +
  +
  +class _PositionOperation extends _FileOperation {
  +  _PositionOperation(int this._id);
  +
  +  void execute(ReceivePort port) {
  +    _replyPort.send(_File._position(_id), port.toSendPort());
  +  }
  +
  +  int _id;
  +}
  +
  +
  +class _LengthOperation extends _FileOperation {
  +  _LengthOperation(int this._id);
  +
  +  void execute(ReceivePort port) {
  +    _replyPort.send(_File._length(_id), port.toSendPort());
  +  }
  +
  +  int _id;
  +}
  +
  +
  +class _FlushOperation extends _FileOperation {
  +  _FlushOperation(int this._id);
  +
  +  void execute(ReceivePort port) {
  +    _replyPort.send(_File._flush(_id), port.toSendPort());
  +  }
  +
  +  int _id;
  +}
  +
  +
  +class _ExitOperation extends _FileOperation {
  +  void execute(ReceivePort port) {
  +    port.close();
  +  }
  +}
  +
  +
   class _FileOperationIsolate extends Isolate {
  -  static int EXISTS = 0;
  -  static int OPEN = 1;
  -  static int CLOSE = 2;
  -  static int READ_BYTE = 3;
  -  static int READ_LIST = 4;
  -  static int WRITE_BYTE = 5;
  -  static int WRITE_LIST = 6;
  -  static int WRITE_STRING = 7;
  -  static int POSITION = 8;
  -  static int LENGTH = 9;
  -  static int FLUSH = 10;
  -  static int EXIT = 11;
  -
     _FileOperationIsolate() : super.heavy();
   
  -  void handleOperation(Map message, SendPort ignored) {
  -    switch (message["type"]) {
  -      case EXISTS:
  -        message["reply"].send(_File._exists(message["name"]),
  -                              port.toSendPort());
  -        break;
  -      case OPEN:
  -        var name = message["name"];
  -        var writable = message["writable"];
  -        message["reply"].send(_File._open(name, writable),
  -                              port.toSendPort());
  -        break;
  -      case CLOSE:
  -        message["reply"].send(_File._close(message["id"]),
  -                              port.toSendPort());
  -        break;
  -      case READ_BYTE:
  -        message["reply"].send(_File._readByte(message["id"]),
  -                              port.toSendPort());
  -        break;
  -      case READ_LIST:
  -        var replyPort = message["reply"];
  -        var bytes = message["bytes"];
  -        var offset = message["offset"];
  -        var length = message["length"];
  -        var id = message["id"];
  -        if (bytes == 0) {
  -          replyPort.send(0, port.toSendPort());
  -          return;
  -        }
  -        int index = _File._checkReadWriteListArguments(length, offset, bytes);
  -        if (index != 0) {
  -          replyPort.send("index out of range in readList: $index",
  -                         port.toSendPort());
  -          return;
  -        }
  -        var buffer = new List(bytes);
  -        var result = { "read": _File._readList(id, buffer, 0, bytes),
  -                       "buffer": buffer };
  -        replyPort.send(result, port.toSendPort());
  -        break;
  -      case WRITE_BYTE:
  -        message["reply"].send(_File._writeByte(message["id"], message["value"]),
  -                              port.toSendPort());
  -        break;
  -      case WRITE_LIST:
  -        var replyPort = message["reply"];
  -        var buffer = message["buffer"];
  -        var bytes = message["bytes"];
  -        var offset = message["offset"];
  -        var id = message["id"];
  -        if (bytes == 0) {
  -          replyPort.send(0, port.toSendPort());
  -          return;
  -        }
  -        int index =
  -            _File._checkReadWriteListArguments(buffer.length, offset, bytes);
  -        if (index != 0) {
  -          replyPort.send("index out of range in writeList: $index",
  -                         port.toSendPort());
  -          return;
  -        }
  -        var result = _File._writeList(id, buffer, offset, bytes);
  -        replyPort.send(result, port.toSendPort());
  -        break;
  -      case WRITE_STRING:
  -        var id = message["id"];
  -        var string = message["string"];
  -        message["reply"].send(_File._writeString(id, string),
  -                              port.toSendPort());
  -        break;
  -      case POSITION:
  -        message["reply"].send(_File._position(message["id"]),
  -                              port.toSendPort());
  -        break;
  -      case LENGTH:
  -        message["reply"].send(_File._length(message["id"]),
  -                              port.toSendPort());
  -        break;
  -      case FLUSH:
  -        message["reply"].send(_File._flush(message["id"]),
  -                              port.toSendPort());
  -        break;
  -      case EXIT:
  -        port.close();
  -        return;
  -    }
  +  void handleOperation(_FileOperation message, SendPort ignored) {
  +    message.execute(port);
       port.receive(handleOperation);
     }
   
  
positive.code:         _errorHandler(result is String ? result : "readList failed");
        }
      };
      Map params = {
        "type": _FileOperationIsolate.READ_LIST,
        "length": buffer.length,
        "offset": offset,
        "bytes": bytes,
        "id": _id
      };
      _scheduler.enqueue(params, handleReadListResult);
    }
  
    int readListSync(List<int> buffer, int offset, int bytes) {
  
negative.code:       }
        _checkPendingWrites();
      };
      var operation = new _WriteByteOperation(_id, value);
      _scheduler.enqueue(operation, handleReadByteResult);
    }
  
    int writeByteSync(int value) {
  