lpeak = math.Max(math.Max(v[Large].Peak, lpeak), v[Large].Curr)
		speak = math.Max(math.Max(v[Small].Peak, speak), v[Small].Curr)
		if lpeak > 0 || speak > 0 {
			count++
		}
	}
	if count > 0 {
		lrg := XferStats{
			Avg:  lavg / float64(count),
			Curr: lcurr / float64(count),
			Peak: lpeak,
		}
		sml := XferStats{
			Avg:  savg / float64(count),
			Curr: scurr / float64(count),

}

type latencyStat struct {
	lastmin lastMinuteLatency
	curr    time.Duration
	avg     time.Duration
	peak    time.Duration
	N       int64
}

func (l *latencyStat) update(d time.Duration) {
	l.lastmin.add(d)
	l.N++
	if d > l.peak {
		l.peak = d
	}
	l.curr = l.lastmin.getTotal().avg()
	l.avg = time.Duration((int64(l.avg)*(l.N-1) + int64(l.curr)) / l.N)
}

    SettableFuture<String> orig = SettableFuture.create();
    SettableFuture<String> prev = orig;
    for (int i = 0; i < 100000; i++) {
      SettableFuture<String> curr = SettableFuture.create();
      prev.setFuture(curr);
      prev = curr;
    }
    // prev represents the 'innermost' future
    prev.set("done");
    assertTrue(orig.isDone());
  }

    while (true) {
      Waiter pred = null;
      Waiter curr = waitersField;
      if (curr == Waiter.TOMBSTONE) {
        return; // give up if someone is calling complete
      }
      Waiter succ;
      while (curr != null) {
        succ = curr.next;
        if (curr.thread != null) { // we aren't unlinking this node, update pred.
          pred = curr;

    while (true) {
      Waiter pred = null;
      Waiter curr = waitersField;
      if (curr == Waiter.TOMBSTONE) {
        return; // give up if someone is calling complete
      }
      Waiter succ;
      while (curr != null) {
        succ = curr.next;
        if (curr.thread != null) { // we aren't unlinking this node, update pred.
          pred = curr;

  var i = 0
  while (i < ranges.size) {
    val curr = ranges[i]
    if (curr is MappedRange.InlineDelta) {
      val j = i + 1
      mergeAdjacent@ while (j < ranges.size) {
        val next = ranges[j]
        if (next is MappedRange.InlineDelta &&
          curr.codepointDelta == next.codepointDelta
        ) {
          ranges.removeAt(j)
        } else {

			metric.TotalDowntime = epHealth.offlineDuration
			metric.LastOnline = epHealth.lastOnline
			metric.Online = epHealth.Online
			metric.Latency = madmin.LatencyStat{
				Curr: epHealth.latency.curr,
				Avg:  epHealth.latency.avg,
				Max:  epHealth.latency.peak,
			}
		}
		m[dID] = metric
	}
	return m
}

func (srs *SRStatus) updateXferRate(sz int64, duration time.Duration) {

    SettableFuture<String> orig = SettableFuture.create();
    SettableFuture<String> prev = orig;
    for (int i = 0; i < 100000; i++) {
      SettableFuture<String> curr = SettableFuture.create();
      prev.setFuture(curr);
      prev = curr;
    }
    // prev represents the 'innermost' future
    prev.set("done");
    assertTrue(orig.isDone());
  }

func (r *ReplicationStats) ActiveWorkers() ActiveWorkerStat {
	if r == nil {
		return ActiveWorkerStat{}
	}
	r.wlock.RLock()
	defer r.wlock.RUnlock()
	w := r.workers.get()
	return ActiveWorkerStat{
		Curr: w.Curr,
		Max:  w.Max,
		Avg:  w.Avg,
	}
}

func (r *ReplicationStats) collectWorkerMetrics(ctx context.Context) {
	if r == nil {
		return
	}
	for {
		select {
		case <-ctx.Done():

    for (int i = 0; i < 2; i++) {
      typesLists.add(POSSIBLE_PARAM_TYPES);
      for (List<Class<?>> curr : Lists.cartesianProduct(typesLists)) {
        allOverloads.add(
            ImmutableList.<Class<?>>builder()
                .add(predicateType)
                .add(String.class) // the format string
                .addAll(curr)
                .build());
      }
    }
    return allOverloads.build().asList();
  }