@Benchmark
  int hashMultiset(int reps) {
    int sum = 0;
    for (int i = 0; i < reps; i++) {
      for (Object value : hashMultiset) {
        sum += value.hashCode();
      }
    }
    return sum;
  }

  @Benchmark
  int linkedHashMultiset(int reps) {
    int sum = 0;
    for (int i = 0; i < reps; i++) {
      for (Object value : linkedHashMultiset) {
        sum += value.hashCode();
      }
    }

    add(-1L);
  }

  /**
   * Returns the current sum. The returned value is NOT an atomic snapshot; invocation in
   * the absence of concurrent updates returns an accurate result, but concurrent updates that occur
   * while the sum is being calculated might not be incorporated.
   *
   * @return the sum
   */
  @Override
  public long sum() {
    long sum = base;
    Cell[] as = cells;
    if (as != null) {

    powerSet = Sets.powerSet(set);
  }

  @Benchmark
  int iteration(int reps) {
    int sum = 0;
    for (int i = 0; i < reps; i++) {
      for (Set<Integer> subset : powerSet) {
        for (Integer value : subset) {
          sum += value;
        }
      }
    }
    return sum;
  }

            opLambda.callback(builder);
        }
    }

    public void setAvailable_Sum() {
        setAvailable_Sum(null);
    }

    public void setAvailable_Sum(ConditionOptionCall<SumAggregationBuilder> opLambda) {
        setAvailable_Sum("available", opLambda);
    }

    public void setAvailable_Sum(String name, ConditionOptionCall<SumAggregationBuilder> opLambda) {

      return new CacheStats(
          negativeToMaxValue(hitCount.sum()),
          negativeToMaxValue(missCount.sum()),
          negativeToMaxValue(loadSuccessCount.sum()),
          negativeToMaxValue(loadExceptionCount.sum()),
          negativeToMaxValue(totalLoadTime.sum()),
          negativeToMaxValue(evictionCount.sum()));
    }

            opLambda.callback(builder);
        }
    }

    public void setCreatedTime_Sum() {
        setCreatedTime_Sum(null);
    }

    public void setCreatedTime_Sum(ConditionOptionCall<SumAggregationBuilder> opLambda) {
        setCreatedTime_Sum("createdTime", opLambda);
    }

    public void setCreatedTime_Sum(String name, ConditionOptionCall<SumAggregationBuilder> opLambda) {

    CacheStats sum = two.plus(one);
    assertEquals(124, sum.requestCount());
    assertEquals(64, sum.hitCount());
    assertEquals(64.0 / 124, sum.hitRate());
    assertEquals(60, sum.missCount());
    assertEquals(60.0 / 124, sum.missRate());
    assertEquals(56, sum.loadSuccessCount());
    assertEquals(52, sum.loadExceptionCount());
    assertEquals(52.0 / 108, sum.loadExceptionRate());

        sum += array[index].hashCode();
      }
    }
    return sum;
  }

  @Benchmark
  int arrayFor(int reps) {
    int sum = 0;
    for (int i = 0; i < reps; i++) {
      for (Object value : array) {
        sum += value.hashCode();
      }
    }
    return sum;
  }

  @Benchmark
  int arrayListIndexed(int reps) {
    int sum = 0;
    for (int i = 0; i < reps; i++) {

      }
    }
  }

  /**
   * Returns the sum of all values in this map.
   *
   * <p>This method is not atomic: the sum may or may not include other concurrent operations.
   */
  public long sum() {
    long sum = 0L;
    for (AtomicLong value : map.values()) {
      sum = sum + value.get();
    }
    return sum;
  }

  @LazyInit @CheckForNull private transient Map<K, Long> asMap;

  public void testSum() {
    assertThat(emptyAccumulator.sum()).isWithin(0.0).of(0.0);
    assertThat(emptyAccumulatorByAddAllEmptyIterable.sum()).isWithin(0.0).of(0.0);
    assertThat(emptyAccumulatorByAddAllEmptyStats.sum()).isWithin(0.0).of(0.0);
    assertThat(oneValueAccumulator.sum()).isWithin(ALLOWED_ERROR).of(ONE_VALUE);
    assertThat(oneValueAccumulatorByAddAllEmptyStats.sum()).isWithin(ALLOWED_ERROR).of(ONE_VALUE);