assertEquals(1, pairs.size(), "Should have decoded one pair");

        AvPair pair = pairs.get(0);
        assertEquals(AvPair.MsvAvFlags, pair.getType(), "Pair type should be MsvAvFlags");
        assertTrue(pair instanceof AvFlags, "Should be decoded as AvFlags");
        assertEquals(0x12345678, ((AvFlags) pair).getFlags(), "Flags value should match");
    }

    /**

                    }
                    configPasswordMap.put(value, list);
                }
                for (final Pair<Pattern, String> pair : list) {
                    if (pair.getFirst().matcher(url).matches()) {
                        return pair.getSecond();
                    }
                }
            }
        }

        return null;
    }

    // Returns -1 if the DOS code is not mapped.
    private static int findNtStatusOrMinusOne(int dosCode) {
        for (int[] pair : DosError.DOS_ERROR_CODES) {
            // each pair is [dosCode, ntStatus]
            if (pair != null && pair.length == 2 && pair[0] == dosCode) {
                return pair[1];
            }
        }
        return -1;
    }

pkg p4, func Clone //deprecated
pkg p4, func Clone[$0 interface{ ~[]$1 }, $1 interface{}]($0) $0
pkg p4, func NewPair[$0 interface{ M }, $1 interface{ ~int }]($0, $1) Pair[$0, $1]
pkg p4, method (Pair[$0, $1]) First() $0
pkg p4, method (Pair[$0, $1]) Second() $1

            result.setAttributes(source.entrySet()
                    .stream()
                    .filter(e -> !"name".equals(e.getKey()))
                    .map(e -> new Pair<>(e.getKey(), (String) e.getValue()))
                    .collect(Collectors.toMap(Pair::getFirst, Pair::getSecond)));
            return result;
        } catch (InstantiationException | IllegalAccessException e) {

        }
        return pairs;
    }

    /**
     * Checks if the AV pairs list contains a pair of the specified type
     *
     * @param pairs the list of AV pairs to search
     * @param type the AV pair type to look for
     * @return whether the list contains a pair of that type
     */
    public static boolean contains(final List<AvPair> pairs, final int type) {
        if (pairs == null) {

            final List<Tuple3<String, QueryBuilder, ScoreFunctionBuilder<?>>> boostList = getQueryMap(key).get(toLowerCase(keyword));
            if (boostList != null) {
                boostList.forEach(pair -> list.add(new FilterFunctionBuilder(pair.getValue2(), pair.getValue3())));
            }
        });
    }

    /**
     * Retrieves a list of boosted documents for the specified KeyMatch.
     *

            result.setAttributes(source.entrySet()
                    .stream()
                    .filter(e -> isAttribute(e.getKey()))
                    .map(e -> new Pair<>(e.getKey(), (String) e.getValue()))
                    .collect(Collectors.toMap(Pair::getFirst, Pair::getSecond)));
            return result;
        } catch (InstantiationException | IllegalAccessException e) {

/**
 * NTLMSSP AV pair representing timestamp information in NTLM authentication.
 * Contains time-based data used to prevent replay attacks and ensure message freshness.
 *
 * @author mbechler
 */
public class AvTimestamp extends AvPair {

    /**
     * Constructs an AvTimestamp from raw byte data
     *
     * @param raw the raw byte data for the timestamp AV pair
     */

  }

  @CollectionFeature.Require(SERIALIZABLE)
  public void testInverseSerialization() {
    BiMapPair<K, V> pair = new BiMapPair<>(getMap());
    BiMapPair<K, V> copy = SerializableTester.reserialize(pair);
    assertEquals(pair.forward, copy.forward);
    assertEquals(pair.backward, copy.backward);
    assertSame(copy.backward, copy.forward.inverse());
    assertSame(copy.forward, copy.backward.inverse());
  }