} else if (DISABLE_PLAIN_TEXT_PASSWORDS) {
                throw new RuntimeException("Plain text passwords are disabled");
            } else {
                // plain text
                password = new byte[(session.auth.password.length() + 1) * 2];
                passwordLength = writeString(session.auth.password, password, 0);
            }
        } else {
            // no password in tree connect

                    }
                    tmp[i] = RESOLVER_WINS;
                    i++;
                } else if (s.equalsIgnoreCase("BCAST")) {
                    tmp[i] = RESOLVER_BCAST;
                    i++;
                } else if (s.equalsIgnoreCase("DNS")) {
                    // skip
                } else if (LogStream.level > 1) {
                    log.println("unknown resolver method: " + s);
                }

                    t.numThreads = Integer.parseInt(args[ai]);
                } else if (args[ai].equals("-i")) {
                    ai++;
                    t.numIter = Integer.parseInt(args[ai]);
                } else if (args[ai].equals("-d")) {
                    ai++;
                    t.delay = Long.parseLong(args[ai]);
                } else {
                    t.url = args[ai];
                }
            }

                }
            } else if (!parentDir.isDirectory()) {
                throw new FileAccessException("ECL0110", new Object[] { path });
            }
            propertiesFile = file;
            store();
        } else if (!file.isFile()) {
            throw new FileAccessException("ECL0111", new Object[] { path });
        } else {
            propertiesFile = file;
        }

     * @return The {@literal byte} array
     */
    public static byte[] toBinary(final Object o) {
        if (o instanceof byte[]) {
            return (byte[]) o;
        } else if (o == null) {
            return null;
        } else {
            assertArgument("o", o instanceof String, o.getClass().toString());
            return ((String) o).getBytes();
        }
    }

                // t also in DST so no correction
            } else {
                // t not in DST so subtract 1 hour
                t -= 3600000;
            }
        } else // not in DST
        if (cfg.getLocalTimezone().inDaylightTime(new Date(t))) {
            // t is in DST so add 1 hour
            t += 3600000;
        } else {
            // t isn't in DST either
        }

                }
                filePrefix = buf.toString();
                extention = strings[strings.length - 1];
            } else {
                filePrefix = name;
                extention = "";
            }
            filePrefix = filePrefix.replaceAll("\\p{Zs}", "_");
        } else {
            filePrefix = "none";
            extention = "";
        }
        File inputFile = null;

            if (!(value instanceof Long)) {
                return (T) Long.valueOf(value.toString());
            }
        } else if (clazz.isAssignableFrom(Integer.class)) {
            if (!(value instanceof Integer)) {
                return (T) Integer.valueOf(value.toString());
            }
        } else if (clazz.isAssignableFrom(Double.class)) {
            if (!(value instanceof Double)) {

            System.arraycopy(nonce, 0, this.nonce, 0, 12);
            // Last 4 bytes remain zero-initialized
        } else if (nonce.length == 16) {
            // For GCM cipher, use full 16-byte nonce
            System.arraycopy(nonce, 0, this.nonce, 0, 16);
        } else {
            throw new IllegalArgumentException("Nonce must be 12 bytes (CCM) or 16 bytes (GCM)");
        }

        if (keyLength == 32) {
            // AES-256 support
            transformation = "AES/GCM/NoPadding";
        } else if (keyLength == 16) {
            // AES-128 (existing)
            transformation = "AES/GCM/NoPadding";
        } else {
            throw new IllegalArgumentException("Unsupported key length for GCM: " + keyLength);
        }

        byte[] key = null;