if (pair != null && pair.length == 2 && pair[0] == dosCode) {
                return pair[1];
            }
        }
        return -1;
    }

    // Provide a handful of representative mappings present in the table.
    static Stream<Arguments> knownMappings() {
        return Stream.of(Arguments.of(0x00000000, 0x00000000), Arguments.of(0x00020001, 0xc000000f), Arguments.of(0x00050001, 0xc0000022),

	var policies set.StringSet
	var updatedAt time.Time

	if store.getUsersSysType() == LDAPUsersSysType {
		// For LDAP policy mapping is part of STS users, we only need to lookup
		// those mappings.
		mp, ok := c.iamSTSPolicyMap.Load(name)
		if !ok {
			// Attempt to load parent user mapping for STS accounts

   *
   * @since 11.0
   */
  void put(K key, V value);

  /**
   * Copies all of the mappings from the specified map to the cache. The effect of this call is
   * equivalent to that of calling {@code put(k, v)} on this map once for each mapping from key
   * {@code k} to value {@code v} in the specified map. The behavior of this operation is undefined

    return new ArrayListMultimap<>(expectedKeys, expectedValuesPerKey);
  }

  /**
   * Constructs an {@code ArrayListMultimap} with the same mappings as the specified multimap.
   *
   * <p>You may also consider the equivalent {@code
   * MultimapBuilder.hashKeys().arrayListValues().build(multimap)}, which provides more control over
   * the underlying data structure.

     * Applies fuzzy matching configuration including edit distance, expansions, and prefix length.
     *
     * @param context the query context containing field mappings
     * @param fuzzyQuery the Lucene FuzzyQuery to convert
     * @param boost the boost factor to apply
     * @return OpenSearch QueryBuilder configured for fuzzy matching
     */

       */
      info.getName().contains("TypeResolverTest")
          /*
           * And at least one of the classes inside TypeTokenTest ends up with a null value in
           * TypeMappingIntrospector.mappings. That happens only under older JDKs, too, so it may
           * well be a JDK bug.
           */
          || info.getName().contains("TypeTokenTest")
          /*
           * "IllegalAccess tried to access class

   * safe range. If {@code safeMax < safeMin} then no code points are considered safe. This
   * initializer is useful when explicit instances of ArrayBasedEscaperMap are used to allow the
   * sharing of large replacement mappings.
   *
   * <p>If a code point has no mapped replacement then it is checked against the safe range. If it
   * lies outside that, then {@link #escapeUnsafe} is called, otherwise no escaping is performed.
   *

   * have the provided key, an empty immutable collection is returned. The values are in the same
   * order as the parameters used to build this multimap.
   */
  @Override
  public abstract ImmutableCollection<V> get(K key);

  /**
   * Returns an immutable multimap which is the inverse of this one. For every key-value mapping in

   * replacement mappings.
   *
   * <p>If a character has no mapped replacement then it is checked against the safe range. If it
   * lies outside that, then {@link #escapeUnsafe} is called, otherwise no escaping is performed.
   *
   * @param escaperMap the mapping of characters to be escaped
   * @param safeMin the lowest character value in the safe range

   *         .build();
   * }
   *
   * <p>Builder instances can be reused; it is safe to call {@link #build} multiple times to build
   * multiple multimaps in series. Each multimap contains the key-value mappings in the previously
   * created multimaps.
   *
   * @since 2.0
   */
  public static final class Builder<K, V> extends ImmutableMultimap.Builder<K, V> {
    /**