final int bytesPerChunk;
    private final byte[] decodabet;
    private final boolean[] validPadding;
    private final boolean ignoreCase;

    Alphabet(String name, char[] chars) {
      this(name, chars, decodabetFor(chars), /* ignoreCase= */ false);
    }

    private Alphabet(String name, char[] chars, byte[] decodabet, boolean ignoreCase) {
      this.name = checkNotNull(name);
      this.chars = checkNotNull(chars);

 */
class RouteSelector(
  private val address: Address,
  private val routeDatabase: RouteDatabase,
  private val connectionUser: ConnectionUser,
  private val fastFallback: Boolean,
) {
  // State for negotiating the next proxy to use.
  private var proxies = emptyList<Proxy>()
  private var nextProxyIndex: Int = 0

  // State for negotiating the next socket address to use.

    private static final Logger log = LoggerFactory.getLogger(SmbFileHandleImpl.class);

    private final Configuration cfg;
    private final int fid;
    private final byte[] fileId;
    private boolean open = true;
    private final long tree_num; // for checking whether the tree changed
    private SmbTreeHandleImpl tree;

    private final AtomicLong usageCount = new AtomicLong(1);
    private final int flags;

    } finally {
      System.setProperty("user.name", save);
    }
  }

  private static boolean isAndroid() {
    return System.getProperty("java.runtime.name", "").contains("Android");
  }

  private static boolean isWindows() {
    return OS_NAME.value().startsWith("Windows");
  }

  private static boolean isJava8() {
    return JAVA_SPECIFICATION_VERSION.value().equals("1.8");
  }

  }

  static String formatCompact4Digits(double value) {
    return String.format(Locale.ROOT, "%.4g", value);
  }

  static boolean stringIsNullOrEmpty(@CheckForNull String string) {
    return string == null || string.isEmpty();
  }

  /**
   * Returns the string if it is not null, or an empty string otherwise.
   *

    XmlNode getChild(String name);

    @Nullable
    Object getInputLocation();

    default XmlNode merge(@Nullable XmlNode source) {
        return merge(source, (Boolean) null);
    }

    XmlNode merge(@Nullable XmlNode source, @Nullable Boolean childMergeOverride);

    /**
     * Merge recessive into dominant and return either {@code dominant}
     * with merged information or a clone of {@code recessive} if

     */
    @SuppressWarnings("CatchingUnchecked") // sneaky checked exception
    private void workOnQueue() {
      boolean interruptedDuringTask = false;
      boolean hasSetRunning = false;
      try {
        while (true) {
          synchronized (queue) {
            // Choose whether this thread will run or not after acquiring the lock on the first

        return doResolve(link, relative, domain, false);
    }


    /**
     * @return
     * @throws URISyntaxException
     * @throws CIFSException
     */
    private DfsReferralData doResolve ( String link, String relative, boolean domain, boolean upper ) throws URISyntaxException, CIFSException {

    assertSame(null, getResponse(methodName).getResult());
  }

  /**
   * Causes this thread to call the named method, and asserts that the call returns the expected
   * boolean value.
   */
  public void callAndAssertReturns(boolean expected, String methodName, Object... arguments)
      throws Exception {
    checkNotNull(methodName);
    checkNotNull(arguments);
    sendRequest(methodName, arguments);

     */
    @SuppressWarnings("CatchingUnchecked") // sneaky checked exception
    private void workOnQueue() {
      boolean interruptedDuringTask = false;
      boolean hasSetRunning = false;
      try {
        while (true) {
          synchronized (queue) {
            // Choose whether this thread will run or not after acquiring the lock on the first