operation ->> dep_func: Return from path operation
    Note over dep_func: Run code after yield
    Note over dep_func: ✅ Dependency closed
    dep_func ->> client: Send response to client
    Note over client: Response sent
    Note over dep_req: Run code after yield
    Note over dep_req: ✅ Dependency closed
```

@NullUnmarked
public class QuantilesBenchmark {

  private static final ContiguousSet<Integer> ALL_DECILE_INDEXES =
      ContiguousSet.create(Range.closed(0, 10), DiscreteDomain.integers());

  @Param({"10", "100", "1000", "10000", "100000"})
  int datasetSize;

  @Param QuantilesAlgorithm algorithm;

  private final double[][] datasets = new double[0x100][];

@NullUnmarked
public class QuantilesBenchmark {

  private static final ContiguousSet<Integer> ALL_DECILE_INDEXES =
      ContiguousSet.create(Range.closed(0, 10), DiscreteDomain.integers());

  @Param({"10", "100", "1000", "10000", "100000"})
  int datasetSize;

  @Param QuantilesAlgorithm algorithm;

  private final double[][] datasets = new double[0x100][];

 * ignore empty ranges and coalesce connected ranges. For example:
 *
 * {@snippet :
 * RangeSet<Integer> rangeSet = TreeRangeSet.create();
 * rangeSet.add(Range.closed(1, 10)); // {[1, 10]}
 * rangeSet.add(Range.closedOpen(11, 15)); // disconnected range; {[1, 10], [11, 15)}
 * rangeSet.add(Range.closedOpen(15, 20)); // connected range; {[1, 10], [11, 20)}

                if (witnessClient != null) {
                    try {
                        witnessClient.close();
                        witnessClient = null;
                        witnessEnabled = false;
                        log.debug("Witness client closed on session logoff");
                    } catch (Exception e) {
                        log.warn("Error closing witness client during logoff", e);

		}
		w.Close()
		return errMoreData
	}

	// Only interested in flushing the size_t not mtime/atime
	if err = Fdatasync(w); err != nil {
		w.Close()
		return err
	}

	// Dealing with error returns from close() - 'man 2 close'
	//
	// A careful programmer will check the return value of close(), since it is quite possible that

            positiveRangesByUpperBound
                .tailMap(
                    complementLowerBoundWindow.lowerEndpoint(),
                    complementLowerBoundWindow.lowerBoundType() == BoundType.CLOSED)
                .values();
      } else {
        positiveRanges = positiveRangesByUpperBound.values();
      }
      PeekingIterator<Range<C>> positiveItr = peekingIterator(positiveRanges.iterator());

		return grid.NewRemoteErr(err)
	}
	var buf bytes.Buffer
	enc := json.NewEncoder(&buf)
	for {
		select {
		case entry, ok := <-ch:
			if !ok {
				return grid.NewRemoteErrString("console log channel closed")
			}
			if !entry.SendLog("", madmin.LogMask(mask)) {
				continue
			}
			buf.Reset()
			if err := enc.Encode(entry); err != nil {
				return grid.NewRemoteErr(err)
			}

    assertEquals(map, Maps.subMap(map, Range.closed(0, 12)));
    assertEquals(ImmutableSortedMap.of(2, 0, 4, 0), Maps.subMap(map, Range.closed(0, 4)));
    assertEquals(ImmutableSortedMap.of(2, 0, 4, 0, 6, 0), Maps.subMap(map, Range.closed(2, 6)));
    assertEquals(ImmutableSortedMap.of(4, 0, 6, 0), Maps.subMap(map, Range.closed(3, 7)));
    assertEquals(empty, Maps.subMap(map, Range.closed(20, 30)));

A <code>nil</code> channel is never ready for communication.
</p>

<p>
A channel may be closed with the built-in function
<a href="#Close"><code>close</code></a>.
The multi-valued assignment form of the
<a href="#Receive_operator">receive operator</a>
reports whether a received value was sent before
the channel was closed.
</p>

<p>
A single channel may be used in