sclass InflaterInputStream_relaxed extends InflaterInputStream {
  *(InputStream in, Inflater inf, int size) {
    super(in, inf, sizee);
  }

  *(InputStream in, Inflater inf) {
    super(in, inf);
  }

  *(InputStream in) {
    super(in);
  }

  public int read(byte[] b, int off, int len) throws IOException {
      ensureOpen();
      if (b == null) {
          throw new NullPointerException();
      } else if (off < 0 || len < 0 || len > b.length - off) {
          throw new IndexOutOfBoundsException();
      } else if (len == 0) {
          return 0;
      }
      try {
          int n;
          while ((n = inf.inflate(b, off, len)) == 0) {
              if (inf.finished() || inf.needsDictionary()) {
                  reachEOF = true;
                  return -1;
              }
              if (inf.needsInput()) {
                if (!fill2())
                  ret -1;
              }
          }
          return n;
      } catch (DataFormatException e) {
          String s = e.getMessage();
          throw new ZipException(s != null ? s : "Invalid ZLIB data format");
      }
  }

  /**
   * Returns 0 after EOF has been reached, otherwise always return 1.
   * <p>
   * Programs should not count on this method to return the actual number
   * of bytes that could be read without blocking.
   *
   * @return     1 before EOF and 0 after EOF.
   * @throws     IOException  if an I/O error occurs.
   *
   */
  public int available() throws IOException {
      ensureOpen();
      if (reachEOF) {
          return 0;
      } else if (inf.finished()) {
          // the end of the compressed data stream has been reached
          reachEOF = true;
          return 0;
      } else {
          return 1;
      }
  }

  private byte[] b = new byte[512];

  /**
   * Skips specified number of bytes of uncompressed data.
   * @param n the number of bytes to skip
   * @return the actual number of bytes skipped.
   * @throws    IOException if an I/O error has occurred
   * @throws    IllegalArgumentException if {@code n < 0}
   */
  public long skip(long n) throws IOException {
      if (n < 0) {
          throw new IllegalArgumentException("negative skip length");
      }
      ensureOpen();
      int max = (int)Math.min(n, Integer.MAX_VALUE);
      int total = 0;
      while (total < max) {
          int len = max - total;
          if (len > b.length) {
              len = b.length;
          }
          len = read(b, 0, len);
          if (len == -1) {
              reachEOF = true;
              break;
          }
          total += len;
      }
      return total;
  }

  /**
   * Fills input buffer with more data to decompress.
   * @throws    IOException if an I/O error has occurred
   * @return true when not at end of stream
   */
  protected bool fill2() throws IOException {
    ensureOpen();
    len = in.read(buf, 0, buf.length);
    if (len == -1)
      false;
    inf.setInput(buf, 0, len);
    true;
  }
}