/**

@java.io.Serial

private static final long serialVersionUID = 4112578634029874840L;

private static final Unsafe UNSAFE = Unsafe.getUnsafe();

/**

protected volatile Properties defaults;

/**

private transient volatile ConcurrentHashMap<Object, Object> map;

/**

public Properties() {

this(null, 8);

}

/**

public Properties(int initialCapacity) {

this(null, initialCapacity);

}

/**

public Properties(Properties defaults) {

this(defaults, 8);

}

private Properties(Properties defaults, int initialCapacity) {

// use package-private constructor to

// initialize unused fields with dummy values

super((Void) null);

map = new ConcurrentHashMap<>(initialCapacity);

this.defaults = defaults;

// Ensure writes can't be reordered

UNSAFE.storeFence();

}

/**

public synchronized Object setProperty(String key, String value) {

return put(key, value);

}

/**

public synchronized void load(Reader reader) throws IOException {

Objects.requireNonNull(reader, "reader parameter is null");

load0(new LineReader(reader));

}

/**

public synchronized void load(InputStream inStream) throws IOException {

Objects.requireNonNull(inStream, "inStream parameter is null");

load0(new LineReader(inStream));

}

private void load0(LineReader lr) throws IOException {

StringBuilder outBuffer = new StringBuilder();

int limit;

int keyLen;

int valueStart;

boolean hasSep;

boolean precedingBackslash;

while ((limit = lr.readLine()) >= 0) {

keyLen = 0;

valueStart = limit;

hasSep = false;

//System.out.println("line=<" + new String(lineBuf, 0, limit) + ">");

precedingBackslash = false;

while (keyLen < limit) {

char c = lr.lineBuf[keyLen];

//need check if escaped.

if ((c == '=' || c == ':') && !precedingBackslash) {

valueStart = keyLen + 1;

hasSep = true;

break;

} else if ((c == ' ' || c == '\t' || c == '\f') && !precedingBackslash) {

valueStart = keyLen + 1;

break;

}

if (c == '\\') {

precedingBackslash = !precedingBackslash;

} else {

precedingBackslash = false;

}

keyLen++;

}

while (valueStart < limit) {

char c = lr.lineBuf[valueStart];

if (c != ' ' && c != '\t' && c != '\f') {

if (!hasSep && (c == '=' || c == ':')) {

hasSep = true;

} else {

break;

}

}

valueStart++;

}

String key = loadConvert(lr.lineBuf, 0, keyLen, outBuffer);

String value = loadConvert(lr.lineBuf, valueStart, limit - valueStart, outBuffer);

put(key, value);

}

}

/* Read in a "logical line" from an InputStream/Reader, skip all comment

private static class LineReader {

LineReader(InputStream inStream) {

this.inStream = inStream;

inByteBuf = new byte[8192];

}

LineReader(Reader reader) {

this.reader = reader;

inCharBuf = new char[8192];

}

char[] lineBuf = new char[1024];

private byte[] inByteBuf;

private char[] inCharBuf;

private int inLimit = 0;

private int inOff = 0;

private InputStream inStream;

private Reader reader;

int readLine() throws IOException {

// use locals to optimize for interpreted performance

int len = 0;

int off = inOff;

int limit = inLimit;

boolean skipWhiteSpace = true;

boolean appendedLineBegin = false;

boolean precedingBackslash = false;

boolean fromStream = inStream != null;

byte[] byteBuf = inByteBuf;

char[] charBuf = inCharBuf;

char[] lineBuf = this.lineBuf;

char c;

while (true) {

if (off >= limit) {

inLimit = limit = fromStream ? inStream.read(byteBuf)

: reader.read(charBuf);

if (limit <= 0) {

if (len == 0) {

return -1;

}

return precedingBackslash ? len - 1 : len;

}

off = 0;

}

// (char)(byte & 0xFF) is equivalent to calling a ISO8859-1 decoder.

c = (fromStream) ? (char)(byteBuf[off++] & 0xFF) : charBuf[off++];

if (skipWhiteSpace) {

if (c == ' ' || c == '\t' || c == '\f') {

continue;

}

if (!appendedLineBegin && (c == '\r' || c == '\n')) {

continue;

}

skipWhiteSpace = false;

appendedLineBegin = false;

}

if (len == 0) { // Still on a new logical line

if (c == '#' || c == '!') {

// Comment, quickly consume the rest of the line

// When checking for new line characters a range check,

// starting with the higher bound ('\r') means one less

// branch in the common case.

commentLoop: while (true) {

if (fromStream) {

byte b;

while (off < limit) {

b = byteBuf[off++];

if (b <= '\r' && (b == '\r' || b == '\n'))

break commentLoop;

}

if (off == limit) {

inLimit = limit = inStream.read(byteBuf);

if (limit <= 0) { // EOF

return -1;

}

off = 0;

}

} else {

while (off < limit) {

c = charBuf[off++];

if (c <= '\r' && (c == '\r' || c == '\n'))

break commentLoop;

}

if (off == limit) {

inLimit = limit = reader.read(charBuf);

if (limit <= 0) { // EOF

return -1;

}

off = 0;

}

}

}

skipWhiteSpace = true;

continue;

}

}

if (c != '\n' && c != '\r') {

lineBuf[len++] = c;

if (len == lineBuf.length) {

lineBuf = new char[ArraysSupport.newLength(len, 1, len)];

System.arraycopy(this.lineBuf, 0, lineBuf, 0, len);

this.lineBuf = lineBuf;

}

// flip the preceding backslash flag

precedingBackslash = (c == '\\') ? !precedingBackslash : false;

} else {

// reached EOL

if (len == 0) {

skipWhiteSpace = true;

continue;

}

if (off >= limit) {

inLimit = limit = fromStream ? inStream.read(byteBuf)

: reader.read(charBuf);

off = 0;

if (limit <= 0) { // EOF

return precedingBackslash ? len - 1 : len;

}

}

if (precedingBackslash) {

// backslash at EOL is not part of the line

len -= 1;

// skip leading whitespace characters in the following line

skipWhiteSpace = true;

appendedLineBegin = true;

precedingBackslash = false;

// take care not to include any subsequent \n

if (c == '\r') {

if (fromStream) {

if (byteBuf[off] == '\n') {

off++;

}

} else {

if (charBuf[off] == '\n') {

off++;

}

}

}

} else {

inOff = off;

return len;

}

}

}

}

}

/*

private String loadConvert(char[] in, int off, int len, StringBuilder out) {

char aChar;

int end = off + len;

int start = off;

while (off < end) {

aChar = in[off++];

if (aChar == '\\') {

break;

}

}

if (off == end) { // No backslash

return new String(in, start, len);

}

// backslash found at off - 1, reset the shared buffer, rewind offset

out.setLength(0);

off--;

out.append(in, start, off - start);

while (off < end) {

aChar = in[off++];

if (aChar == '\\') {

// No need to bounds check since LineReader::readLine excludes

// unescaped \s at the end of the line

aChar = in[off++];

if(aChar == 'u') {

// Read the xxxx

if (off > end - 4)

throw new IllegalArgumentException(

"Malformed \\uxxxx encoding.");

int value = 0;

for (int i = 0; i < 4; i++) {

aChar = in[off++];

switch (aChar) {

case '0': case '1': case '2': case '3': case '4':

case '5': case '6': case '7': case '8': case '9':

value = (value << 4) + aChar - '0';

break;

case 'a': case 'b': case 'c':

case 'd': case 'e': case 'f':

value = (value << 4) + 10 + aChar - 'a';

break;

case 'A': case 'B': case 'C':

case 'D': case 'E': case 'F':

value = (value << 4) + 10 + aChar - 'A';

break;

default:

throw new IllegalArgumentException(

"Malformed \\uxxxx encoding.");

}

}

out.append((char)value);

} else {

if (aChar == 't') aChar = '\t';

else if (aChar == 'r') aChar = '\r';

else if (aChar == 'n') aChar = '\n';

else if (aChar == 'f') aChar = '\f';

out.append(aChar);

}

} else {

out.append(aChar);

}

}

return out.toString();

}

/*

private String saveConvert(String theString,

boolean escapeSpace,

boolean escapeUnicode) {

int len = theString.length();

int bufLen = len * 2;

if (bufLen < 0) {

bufLen = Integer.MAX_VALUE;

}

StringBuilder outBuffer = new StringBuilder(bufLen);

for(int x=0; x<len; x++) {

char aChar = theString.charAt(x);

// Handle common case first, selecting largest block that

// avoids the specials below

if ((aChar > 61) && (aChar < 127)) {

if (aChar == '\\') {

outBuffer.append('\\'); outBuffer.append('\\');

continue;

}

outBuffer.append(aChar);

continue;

}

switch(aChar) {

case ' ':

if (x == 0 || escapeSpace)

outBuffer.append('\\');

outBuffer.append(' ');

break;

case '\t':outBuffer.append('\\'); outBuffer.append('t');

break;

case '\n':outBuffer.append('\\'); outBuffer.append('n');

break;

case '\r':outBuffer.append('\\'); outBuffer.append('r');

break;

case '\f':outBuffer.append('\\'); outBuffer.append('f');

break;

case '=': // Fall through

case ':': // Fall through

case '#': // Fall through

case '!':

outBuffer.append('\\'); outBuffer.append(aChar);

break;

default:

if (((aChar < 0x0020) || (aChar > 0x007e)) & escapeUnicode ) {

outBuffer.append('\\');

outBuffer.append('u');

outBuffer.append(toHex((aChar >> 12) & 0xF));

outBuffer.append(toHex((aChar >> 8) & 0xF));

outBuffer.append(toHex((aChar >> 4) & 0xF));

outBuffer.append(toHex( aChar & 0xF));

} else {

outBuffer.append(aChar);

}

}

}

return outBuffer.toString();

}

private static void writeComments(BufferedWriter bw, String comments)

throws IOException {

bw.write("#");

int len = comments.length();

int current = 0;

int last = 0;

char[] uu = new char[6];

uu[0] = '\\';

uu[1] = 'u';

while (current < len) {

char c = comments.charAt(current);

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

if (last != current)

bw.write(comments.substring(last, current));

if (c > '\u00ff') {

uu[2] = toHex((c >> 12) & 0xf);

uu[3] = toHex((c >> 8) & 0xf);

uu[4] = toHex((c >> 4) & 0xf);

uu[5] = toHex( c & 0xf);

bw.write(new String(uu));

} else {

bw.newLine();

if (c == '\r' &&

current != len - 1 &&

comments.charAt(current + 1) == '\n') {

current++;

}

if (current == len - 1 ||

(comments.charAt(current + 1) != '#' &&

comments.charAt(current + 1) != '!'))

bw.write("#");

}

last = current + 1;

}

current++;

}

if (last != current)

bw.write(comments.substring(last, current));

bw.newLine();

}

/**

@Deprecated

public void save(OutputStream out, String comments) {

try {

store(out, comments);

} catch (IOException e) {

}

}

/**

public void store(Writer writer, String comments)

throws IOException

{

store0((writer instanceof BufferedWriter)?(BufferedWriter)writer

: new BufferedWriter(writer),

comments,

false);

}

/**

public void store(OutputStream out, String comments)

throws IOException

{

store0(new BufferedWriter(new OutputStreamWriter(out, ISO_8859_1.INSTANCE)),

comments,

true);

}

private void store0(BufferedWriter bw, String comments, boolean escUnicode)

throws IOException

{

if (comments != null) {

writeComments(bw, comments);

}

bw.write("#" + new Date().toString());

bw.newLine();

synchronized (this) {

for (Map.Entry<Object, Object> e : entrySet()) {

String key = (String)e.getKey();

String val = (String)e.getValue();

key = saveConvert(key, true, escUnicode);

/* No need to escape embedded and trailing spaces for value, hence

val = saveConvert(val, false, escUnicode);

bw.write(key + "=" + val);

bw.newLine();

}

}

bw.flush();

}

/**

public synchronized void loadFromXML(InputStream in)

throws IOException, InvalidPropertiesFormatException

{

Objects.requireNonNull(in);

PropertiesDefaultHandler handler = new PropertiesDefaultHandler();

handler.load(this, in);

in.close();

}

/**