}
        outI++;
      }
      return outI == n ? hashTable : new Object[] {hashTable, outI, duplicateKey};
    } else {
      /*
       * Use 32 bits per entry.
       */
      int[] hashTable = new int[tableSize];
      Arrays.fill(hashTable, ABSENT);

      int outI = 0;
      entries:
      for (int i = 0; i < n; i++) {

        this.hashTable = hashTable;
        int mask = hashTable.length - 1;
        for (ValueEntry<K, V> entry = firstEntry;
            entry != null;
            entry = entry.successorInValueSet) {
          int bucket = entry.smearedValueHash & mask;
          entry.nextInValueBucket = hashTable[bucket];
          hashTable[bucket] = entry;
        }
      }
    }

    @CanIgnoreReturnValue

        this.hashTable = hashTable;
        int mask = hashTable.length - 1;
        for (ValueEntry<K, V> entry = firstEntry;
            entry != null;
            entry = entry.successorInValueSet) {
          int bucket = entry.smearedValueHash & mask;
          entry.nextInValueBucket = hashTable[bucket];
          hashTable[bucket] = entry;
        }
      }
    }

    @CanIgnoreReturnValue

          int index = j & mask;
          if (hashTable[index] == null) {
            hashTable[index] = e;
            break;
          }
        }
      }
      return hashTable;
    }

    void ensureTableCapacity(int minCapacity) {
      int newTableSize;
      if (hashTable == null) {
        newTableSize = chooseTableSize(minCapacity);
        hashTable = new Object[newTableSize];

    /**
     * Creates and returns a new instance of {@link Hashtable}.
     *
     * @param <K> the key type of {@link Hashtable}
     * @param <V> the value type of {@link Hashtable}
     * @return a new instance of {@link Hashtable}
     * @see Hashtable#Hashtable()
     */
    public static <K, V> Hashtable<K, V> newHashtable() {
        return new Hashtable<>();
    }

    /**

    }
  }

  /**
   * Returns a larger power of 2 hashtable size given the current mask.
   *
   * <p>For hashtable sizes less than or equal to 32, the returned power of 2 is 4x the current
   * hashtable size to reduce expensive rehashing. Otherwise the returned power of 2 is 2x the
   * current hashtable size.
   */
  static int newCapacity(int mask) {
    return ((mask < 32) ? 4 : 2) * (mask + 1);

    }
  }

  /**
   * Returns a larger power of 2 hashtable size given the current mask.
   *
   * <p>For hashtable sizes less than or equal to 32, the returned power of 2 is 4x the current
   * hashtable size to reduce expensive rehashing. Otherwise the returned power of 2 is 2x the
   * current hashtable size.
   */
  static int newCapacity(int mask) {
    return ((mask < 32) ? 4 : 2) * (mask + 1);

     */
    public Lmhosts() {
        // Default constructor
    }

    private static final String FILENAME = Config.getProperty("jcifs.smb1.netbios.lmhosts");
    private static final Hashtable TAB = new Hashtable();
    private static long lastModified = 1L;
    private static int alt;
    private static LogStream log = LogStream.getInstance();

    /**

        // Test getEnvironment returns the correct environment
        Hashtable<String, String> env = ldapUser.getEnvironment();
        assertSame(testEnv, env);
        assertEquals("test.value", env.get("test.key"));

        // Test with empty environment
        Hashtable<String, String> emptyEnv = new Hashtable<>();
        LdapUser user = new LdapUser(emptyEnv, "user");

   * part of the smeared hash of the element not covered by the hashtable mask, whereas the low bits
   * are the "next" pointer (pointing to the next entry in the bucket chain), which will always be
   * less than or equal to the hashtable mask.
   *
   * <pre>
   * hash  = aaaaaaaa
   * mask  = 00000fff
   * next  = 00000bbb
   * entry = aaaaabbb