public long skip(long n) throws IOException {
        if (n < 0L) {
            throw new IllegalArgumentException("skip value is negative");
        }

        for (long i = 0; i < n; i++) {
            if (read() == -1) {
                return i;
            }
        }
        return n;
    }

    /**
     * Reads characters into a portion of an array. This method will block until some input is available, an I/O error
     * occurs, or the end of the stream is reached.
     *
     * @param cbuf Destination buffer to write characters to. Must not be <code>null</code>.
     * @param off Offset at which to start storing characters.
     * @param len Maximum number of characters to read.
     * @return the number of characters read, or -1 if the end of the stream has been reached
     * @throws IOException If an I/O error occurs
     */
    @Override
    public int read(char[] cbuf, int off, int len) throws IOException {
        for (int i = 0; i < len; i++) {
            int ch = read();
            if (ch == -1) {
                if (i == 0) {
                    return -1;
                } else {
                    return i;
                }
            }
            cbuf[off + i] = (char) ch;
        }
        return len;
    }

    /**
     * Returns the next character in the filtered stream, replacing tokens from the original stream.
     *
     * @return the next character in the resulting stream, or -1 if the end of the resulting stream has been reached
     * @throws IOException if the underlying stream throws an IOException during reading
     */
    @Override
    public int read() throws IOException {
        if (replaceIndex > 0) {
            return replaceData.charAt(replaceData.length() - (replaceIndex--));
        }
        if (eof) {
            return -1;
        }

if (!foundToken) {

            in.reset();
            return in.read();
        }

        // we're committed, find the end token, EOL or EOF

        key.append(beginToken);
        in.reset();
        in.skip(beginToken.length());
        ch = in.read();

        int endTokenSize = endToken.length();
        int end = endTokenSize;
        do {
            if (ch == -1) {
                break;
            } else if (ch == '\n' && !supportMultiLineFiltering) {
                // EOL
                key.append((char) ch);
                break;
            }

            key.append((char) ch);

            if (ch == this.endToken.charAt(endTokenSize - end)) {
                end--;
                if (end == 0) {
                    break;
                }
            } else {
                end = endTokenSize;
            }

            ch = in.read();
        } while (true);

in.mark(markLength);

        int ch = in.read();
        if (ch == -1 || (ch == '\n' && !supportMultiLineFiltering)) {
            return ch;
        }

        boolean inEscape = useEscape && ch == getEscapeString().charAt(0);

        StringBuilder key = new StringBuilder();

        // have we found an escape string?
        if (inEscape) {
            for (int i = 0; i < getEscapeString().length(); i++) {
                key.append((char) ch);

                if (ch != getEscapeString().charAt(i) || ch == -1 || (ch == '\n' && !supportMultiLineFiltering)) {