return new Keys();
  }

  @WeakOuter
  final class Keys extends Multimaps.Keys<K, V> {
    Keys() {
      super(FilteredEntryMultimap.this);
    }

    @Override
    public int remove(@Nullable Object key, int occurrences) {
      checkNonnegative(occurrences, "occurrences");
      if (occurrences == 0) {
        return count(key);
      }
      Collection<V> collection = unfiltered.asMap().get(key);

    int totalBytes = hashCode.bits() / 8;

    for (int bytes = 0; bytes < totalBytes; bytes++) {
      byte[] bb = new byte[bytes];
      hashCode.writeBytesTo(bb, 0, bb.length);

      assertTrue(Arrays.equals(Arrays.copyOf(hashBytes, bytes), bb));
    }
  }

  private static class ExpectedHashCode {
    final byte[] bytes;
    final int asInt;

                data.putValue(key, ((Integer) value).toString());
            } else if (value instanceof Address[]) {
                final int size = ((Address[]) value).length;
                final String[] values = new String[size];
                for (int i = 0; i < size; i++) {
                    final Address address = ((Address[]) value)[i];
                    values[i] = getDecodeText(address.toString());

        final int threadCount = 10;
        final int matchesPerThread = 100;
        final AtomicInteger matchCount = new AtomicInteger(0);
        final AtomicInteger noMatchCount = new AtomicInteger(0);
        final List<Exception> exceptions = new ArrayList<>();

        Thread[] threads = new Thread[threadCount];
        for (int i = 0; i < threadCount; i++) {

  static byte[] newPreFilledByteArray(int size) {
    return newPreFilledByteArray(0, size);
  }

  /** Returns a byte array of length size that has values offset .. offset + size - 1. */
  static byte[] newPreFilledByteArray(int offset, int size) {
    byte[] array = new byte[size];
    for (int i = 0; i < size; i++) {
      array[i] = (byte) (offset + i);
    }
    return array;

     * @param len the number of SIDs to resolve
     * @throws CIFSException if there is an error resolving the SIDs
     */
    void resolveSids(CIFSContext tc, String authorityServerName, SID[] sids, int off, int len) throws CIFSException;

    /**
     * Gets the SIDs of members of a group.
     *
     * @param tc the CIFS context to use
     * @param authorityServerName the server to use for resolution

    public Entry<String, Collection<Integer>>[] createArray(int length) {
      return new Entry[length];
    }

    @Override
    public Iterable<Entry<String, Collection<Integer>>> order(
        List<Entry<String, Collection<Integer>>> insertionOrder) {
      return insertionOrder;
    }

    @Override
    public String[] createKeyArray(int length) {
      return new String[length];
    }

        InputStream s = new ByteArrayInputStream(new byte[] {});
        int tagNo = ASN1Util.readTagNumber(s, 0x05);
        assertEquals(5, tagNo);
    }

    @Test
    void testReadTagNumber_HighTag() throws IOException {
        // High tag number (31)
        InputStream s = new ByteArrayInputStream(new byte[] { 0x1F });
        int tagNo = ASN1Util.readTagNumber(s, 0x1F);
        assertEquals(31, tagNo);
    }

        assertSame(buffer, ndrBuffer.getBuffer());
    }

    @Test
    void testAlignWithValue() {
        // Align to 4-byte boundary with a fill value
        ndrBuffer.setIndex(1);
        int alignedBytes = ndrBuffer.align(4, (byte) 0xFF);
        assertEquals(3, alignedBytes); // Should advance by 3 bytes (1 -> 4)
        assertEquals(4, ndrBuffer.getIndex());

  public Set<EndpointPair<N>> incidentEdges(N node) {
    return delegate().incidentEdges(node);
  }

  @Override
  public int degree(N node) {
    return delegate().degree(node);
  }

  @Override
  public int inDegree(N node) {
    return delegate().inDegree(node);
  }

  @Override
  public int outDegree(N node) {
    return delegate().outDegree(node);
  }

  @Override