class JimfsInputStream extends InputStream {

  @GuardedBy("this")
  @VisibleForTesting
  RegularFile file;

  @GuardedBy("this")
  private long pos;

  @GuardedBy("this")
  private boolean finished;

  private final FileSystemState fileSystemState;

  public JimfsInputStream(RegularFile file, FileSystemState fileSystemState) {
    this.file = checkNotNull(file);
    this.fileSystemState = fileSystemState;
    fileSystemState.register(this);
  }

  @Override
  public synchronized int read() throws IOException {
    checkNotClosed();
    if (finished) {
      return -1;
    }

    file.readLock().lock();
    try {

      int b = file.read(pos++); // it's ok for pos to go beyond size()
      if (b == -1) {
        finished = true;
      } else {
        file.setLastAccessTime(fileSystemState.now());
      }
      return b;
    } finally {
      file.readLock().unlock();
    }
  }

  @Override
  public int read(byte[] b) throws IOException {
    return readInternal(b, 0, b.length);
  }

  @Override
  public int read(byte[] b, int off, int len) throws IOException {
    checkPositionIndexes(off, off + len, b.length);
    return readInternal(b, off, len);
  }

  private synchronized int readInternal(byte[] b, int off, int len) throws IOException {<FILL_FUNCTION_BODY>}

  @Override
  public long skip(long n) throws IOException {
    if (n <= 0) {
      return 0;
    }

    synchronized (this) {
      checkNotClosed();
      if (finished) {
        return 0;
      }

      // available() must be an int, so the min must be also
      int skip = (int) Math.min(Math.max(file.size() - pos, 0), n);
      pos += skip;
      return skip;
    }
  }

  @Override
  public synchronized int available() throws IOException {
    checkNotClosed();
    if (finished) {
      return 0;
    }
    long available = Math.max(file.size() - pos, 0);
    return Ints.saturatedCast(available);
  }

  @GuardedBy("this")
  private void checkNotClosed() throws IOException {
    if (file == null) {
      throw new IOException("stream is closed");
    }
  }

  @Override
  public synchronized void close() throws IOException {
    if (isOpen()) {
      fileSystemState.unregister(this);
      file.closed();

      // file is set to null here and only here
      file = null;
    }
  }

  @GuardedBy("this")
  private boolean isOpen() {
    return file != null;
  }
}

    checkNotClosed();
    if (finished) {
      return -1;
    }

    file.readLock().lock();
    try {
      int read = file.read(pos, b, off, len);
      if (read == -1) {
        finished = true;
      } else {
        pos += read;
      }

      file.setLastAccessTime(fileSystemState.now());
      return read;
    } finally {
      file.readLock().unlock();
    }
  
<methods>public void <init>() ,public int available() throws java.io.IOException,public void close() throws java.io.IOException,public synchronized void mark(int) ,public boolean markSupported() ,public static java.io.InputStream nullInputStream() ,public abstract int read() throws java.io.IOException,public int read(byte[]) throws java.io.IOException,public int read(byte[], int, int) throws java.io.IOException,public byte[] readAllBytes() throws java.io.IOException,public byte[] readNBytes(int) throws java.io.IOException,public int readNBytes(byte[], int, int) throws java.io.IOException,public synchronized void reset() throws java.io.IOException,public long skip(long) throws java.io.IOException,public void skipNBytes(long) throws java.io.IOException,public long transferTo(java.io.OutputStream) throws java.io.IOException<variables>private static final int DEFAULT_BUFFER_SIZE,private static final int MAX_BUFFER_SIZE,private static final int MAX_SKIP_BUFFER_SIZE