private final int constant;

    ConstantWeigher(int constant) {
      this.constant = constant;
    }

    @Override
    public int weigh(Object key, Object value) {
      return constant;
    }
  }

  static final class IntKeyWeigher implements Weigher<Integer, Object> {
    @Override
    public int weigh(Integer key, Object value) {
      return key;
    }
  }

        ExecutorService executor = Executors.newFixedThreadPool(threadCount);

        // When
        for (int t = 0; t < threadCount; t++) {
            final int threadId = t;
            executor.submit(() -> {
                try {
                    for (int i = 0; i < noncesPerThread; i++) {
                        byte[] nonce = encryptionContext.generateNonce();
                        String nonceHex = bytesToHex(nonce);

 * protocol version and connection parameters.
 */
public class RdmaNegotiateRequest {

    private int minVersion;
    private int maxVersion;
    private int creditsRequested;
    private int preferredSendSize;
    private int maxReceiveSize;
    private int maxFragmentedSize;

    /**
     * Create new RDMA negotiation request
     */
    public RdmaNegotiateRequest() {

  public void testConcat_overflow_negative() {
    int dim1 = 1 << 16;
    int dim2 = 1 << 15;
    assertThat(dim1 * dim2).isLessThan(0);
    testConcatOverflow(dim1, dim2);
  }

  @GwtIncompatible // different overflow behavior; could probably be made to work by using ~~
  public void testConcat_overflow_nonNegative() {
    int dim1 = 1 << 16;
    int dim2 = 1 << 16;
    assertThat(dim1 * dim2).isAtLeast(0);

      return (List<V>) getDelegate();
    }

    @Override
    public boolean addAll(int index, Collection<? extends V> c) {
      if (c.isEmpty()) {
        return false;
      }
      int oldSize = size(); // calls refreshIfEmpty
      boolean changed = getListDelegate().addAll(index, c);
      if (changed) {
        int newSize = getDelegate().size();
        totalSize += newSize - oldSize;
        if (oldSize == 0) {

	} ShareInfo0;

	typedef struct {
		int count;
		[size_is(count)] ShareInfo0 *array;
	} ShareInfoCtr0;

	typedef struct {
		[string] wchar_t *netname;
		int type;
		[string] wchar_t *remark;
	} ShareInfo1;

	typedef struct {
		int count;
		[size_is(count)] ShareInfo1 *array;
	} ShareInfoCtr1;

	typedef struct {
		[string] wchar_t *netname;
		int type;
		[string] wchar_t *remark;

        doDelete(entity, null);
    }

    public int queryDelete(CBCall<SearchLogCB> cbLambda) {
        return doQueryDelete(createCB(cbLambda), null);
    }

    public int[] batchInsert(List<SearchLog> list) {
        return batchInsert(list, null, null);
    }

    public int[] batchInsert(List<SearchLog> list, RequestOptionCall<BulkRequestBuilder> call) {

        doDelete(entity, null);
    }

    public int queryDelete(CBCall<FileConfigCB> cbLambda) {
        return doQueryDelete(createCB(cbLambda), null);
    }

    public int[] batchInsert(List<FileConfig> list) {
        return batchInsert(list, null, null);
    }

    public int[] batchInsert(List<FileConfig> list, RequestOptionCall<BulkRequestBuilder> call) {

      }
    }
  }

  @SuppressWarnings("GuardedBy")
  @Benchmark
  int time(int reps) {
    int dummy = 0;
    for (int i = 0; i < reps; i++) {
      // TODO(b/145386688): This access should be guarded by 'this.segment', which is not currently
      // held
      segment.removeEntryFromChain(chain, head);
      dummy += segment.count;
    }
    return dummy;
  }

  @Param({"1", "100", "10000", "1000000"})
  int size;

  @Param Traversal traversal;

  @Param({"1234"})
  SpecialRandom rng;

  @BeforeExperiment
  void setUp() {
    this.view = traversal.view(topology.createTree(size, rng).get(), VIEWER);
  }

  @Benchmark
  int traversal(int reps) {
    int tmp = 0;

    for (int i = 0; i < reps; i++) {
      for (BinaryNode node : view) {