private static final int TRANSFER_BUFFER_SIZE = 8192;

/**

public static Reader nullReader() {

return new Reader() {

private volatile boolean closed;

private void ensureOpen() throws IOException {

if (closed) {

throw new IOException("Stream closed");

}

}

@Override

public int read() throws IOException {

ensureOpen();

return -1;

}

@Override

public int read(char[] cbuf, int off, int len) throws IOException {

Objects.checkFromIndexSize(off, len, cbuf.length);

ensureOpen();

if (len == 0) {

return 0;

}

return -1;

}

@Override

public int read(CharBuffer target) throws IOException {

Objects.requireNonNull(target);

ensureOpen();

if (target.hasRemaining()) {

return -1;

}

return 0;

}

@Override

public boolean ready() throws IOException {

ensureOpen();

return false;

}

@Override

public long skip(long n) throws IOException {

ensureOpen();

return 0L;

}

@Override

public long transferTo(Writer out) throws IOException {

Objects.requireNonNull(out);

ensureOpen();

return 0L;

}

@Override

public void close() {

closed = true;

}

};

}

/**

public static Reader of(final CharSequence cs) {

Objects.requireNonNull(cs);

return new Reader() {

private boolean isClosed;

private int next = 0;

private int mark = 0;

/** Check to make sure that the stream has not been closed */

private void ensureOpen() throws IOException {

if (isClosed)

throw new IOException("Stream closed");

}

@Override

public int read() throws IOException {

ensureOpen();

if (next >= cs.length())

return -1;

return cs.charAt(next++);

}

@Override

public int read(char[] cbuf, int off, int len) throws IOException {

ensureOpen();

Objects.checkFromIndexSize(off, len, cbuf.length);

if (len == 0) {

return 0;

}

int length = cs.length();

if (next >= length)

return -1;

int n = Math.min(length - next, len);

cs.getChars(next, next + n, cbuf, off);

next += n;

return n;

}

@Override

public String readAllAsString() throws IOException {

ensureOpen();

int len = cs.length();

String result = cs.subSequence(next, len).toString();

next += result.length();

return result;

}

@Override

public List<String> readAllLines() throws IOException {

return readAllAsString().lines().toList();

}

@Override

public long skip(long n) throws IOException {

ensureOpen();

if (next >= cs.length())

return 0;

// Bound skip by beginning and end of the source

long r = Math.min(cs.length() - next, n);

r = Math.max(-next, r);

next += (int)r;

return r;

}

@Override

public boolean ready() throws IOException {

ensureOpen();

return true;

}

@Override

public boolean markSupported() {

return true;

}

@Override

public void mark(int readAheadLimit) throws IOException {

if (readAheadLimit < 0){

throw new IllegalArgumentException("Read-ahead limit < 0");

}

ensureOpen();

mark = next;

}

@Override

public void reset() throws IOException {

ensureOpen();

next = mark;

}

@Override

public void close() {

isClosed = true;

}

};

}

/**

protected Object lock;

/**

protected Reader() {

this.lock = this;

}

/**

protected Reader(Object lock) {

if (lock == null) {

throw new NullPointerException();

}

this.lock = lock;

}

/**

public int read(CharBuffer target) throws IOException {

if (target.isReadOnly())

throw new ReadOnlyBufferException();

int nread;

if (target.hasArray()) {

char[] cbuf = target.array();

int pos = target.position();

int rem = Math.max(target.limit() - pos, 0);

int off = target.arrayOffset() + pos;

nread = this.read(cbuf, off, rem);

if (nread > 0)

target.position(pos + nread);

} else {

int len = target.remaining();

char[] cbuf = new char[len];

nread = read(cbuf, 0, len);

if (nread > 0)

target.put(cbuf, 0, nread);

}

return nread;

}

/**

public int read() throws IOException {

char[] cb = new char[1];

if (read(cb, 0, 1) == -1)

return -1;

else

return cb[0];

}

/**

public int read(char[] cbuf) throws IOException {

return read(cbuf, 0, cbuf.length);

}

/**

public abstract int read(char[] cbuf, int off, int len) throws IOException;

/**

public List<String> readAllLines() throws IOException {

List<String> lines = new ArrayList<>();

char[] cb = new char[1024];

int start = 0;

int pos = 0;

int limit = 0;

boolean skipLF = false;

int n;

while ((n = read(cb, pos, cb.length - pos)) != -1) {

limit = pos + n;

while (pos < limit) {

if (skipLF) {

if (cb[pos] == '\n') {

pos++;

start++;

}

skipLF = false;

}

while (pos < limit) {

char c = cb[pos++];

if (c == '\n' || c == '\r') {

lines.add(new String(cb, start, pos - 1 - start));

skipLF = (c == '\r');

start = pos;

break;

}

}

if (pos == limit) {

int len = limit - start;

if (len >= cb.length/2) {

// allocate larger buffer and copy chars to beginning

int newLength = ArraysSupport.newLength(cb.length,

TRANSFER_BUFFER_SIZE, cb.length);

char[] tmp = new char[newLength];

System.arraycopy(cb, start, tmp, 0, len);

cb = tmp;

} else if (start != 0 && len != 0) {

// move fragment to beginning of buffer

System.arraycopy(cb, start, cb, 0, len);

}

pos = limit = len;

start = 0;

break;

}

}

}

// add a string if EOS terminates the last line

if (limit > start)

lines.add(new String(cb, start, limit - start));

return Collections.unmodifiableList(lines);

}

/**

public String readAllAsString() throws IOException {

StringBuilder result = new StringBuilder();

char[] cbuf = new char[TRANSFER_BUFFER_SIZE];

int nread;

while ((nread = read(cbuf, 0, cbuf.length)) != -1) {

result.append(cbuf, 0, nread);

}

return result.toString();

}

/** Maximum skip-buffer size */

private static final int maxSkipBufferSize = 8192;

/** Skip buffer, null until allocated */

private char[] skipBuffer = null;

/**

public long skip(long n) throws IOException {

if (n < 0L)

throw new IllegalArgumentException("skip value is negative");

synchronized (lock) {

int nn = (int) Math.min(n, maxSkipBufferSize);

if ((skipBuffer == null) || (skipBuffer.length < nn))

skipBuffer = new char[nn];

long r = n;

while (r > 0) {

int nc = read(skipBuffer, 0, (int)Math.min(r, nn));

if (nc == -1)

break;

r -= nc;

}

return n - r;

}

}

/**

public boolean ready() throws IOException {

return false;

}

/**

public boolean markSupported() {

return false;

}

/**

public void mark(int readAheadLimit) throws IOException {

throw new IOException("mark() not supported");

}

/**

public void reset() throws IOException {

throw new IOException("reset() not supported");

}

/**

public abstract void close() throws IOException;

/**

public long transferTo(Writer out) throws IOException {

Objects.requireNonNull(out, "out");

long transferred = 0;

char[] buffer = new char[TRANSFER_BUFFER_SIZE];

int nRead;

while ((nRead = read(buffer, 0, TRANSFER_BUFFER_SIZE)) >= 0) {

out.write(buffer, 0, nRead);

if (transferred < Long.MAX_VALUE) {

try {

transferred = Math.addExact(transferred, nRead);

} catch (ArithmeticException ignore) {

transferred = Long.MAX_VALUE;

}

}

}

return transferred;

}