}

  protected MinimalCollection<E> emptyCollection() {
    return MinimalCollection.<E>of();
  }

  protected final E e0() {
    return samples.e0();
  }

  protected final E e1() {
    return samples.e1();
  }

  protected final E e2() {
    return samples.e2();
  }

  protected final E e3() {
    return samples.e3();
  }

  protected final E e4() {

      return new SampleElements<>(
          mapEntry(sampleKeys.e0(), createCollection(sampleValues.e0())),
          mapEntry(sampleKeys.e1(), createCollection(sampleValues.e1())),
          mapEntry(sampleKeys.e2(), createCollection(sampleValues.e2())),
          mapEntry(sampleKeys.e3(), createCollection(sampleValues.e3())),

   * inserted into the multiset must implement the {@code Comparable} interface. Furthermore, all
   * such elements must be <i>mutually comparable</i>: {@code e1.compareTo(e2)} must not throw a
   * {@code ClassCastException} for any elements {@code e1} and {@code e2} in the multiset. If the
   * user attempts to add an element to the multiset that violates this constraint (for example, the

      SampleElements<E> samples = gen.samples();
      return new SampleElements<>(
          Multisets.immutableEntry(samples.e0(), 3),
          Multisets.immutableEntry(samples.e1(), 4),
          Multisets.immutableEntry(samples.e2(), 1),
          Multisets.immutableEntry(samples.e3(), 5),
          Multisets.immutableEntry(samples.e4(), 2));
    }

    @Override

      placeholder: |
        e.g.,
        public static <E> ImmutableList<E> of();
        public static <E> ImmutableList<E> of(E element);
        public static <E> ImmutableList<E> of(E e1, E e2);
        ...
      render: java
    validations:
      required: false

  - type: markdown
    attributes:
      value: >
        #### Ubiquity: provide concrete use cases

            return;
        }

        // Find oldest leases by last access time
        leases.entrySet()
                .stream()
                .sorted((e1, e2) -> Long.compare(e1.getValue().getLastAccessTime(), e2.getValue().getLastAccessTime()))
                .limit(count)
                .forEach(entry -> {
                    Smb2LeaseKey key = entry.getKey();

                    }
                }
            }
        }

        final var docs = scoreDocMap.values()
                .stream()
                .sorted((e1, e2) -> Float.compare(toFloat(e2.get(scoreField)), toFloat(e1.get(scoreField))))
                .toList();
        int offset = 0;
        for (int i = 0; i < windowSize / 2 && i < docs.size(); i++) {

        } catch (final CIFSException e) {
            log.warn("Enumeration failed", e);
            this.next = null;
            try {
                doClose();
            } catch (final CIFSException e1) {
                log.debug("Failed to close enum", e);
            }
        }
        return n;
    }

    /**
     * {@inheritDoc}
     *
     * @see java.lang.AutoCloseable#close()

                    }
                }
            }
        } catch (SmbException e) {
            throw e;
        } catch (IOException e1) {
            log.debug("Ignoring invalid initial token", e1);
        }

        return new SpnegoContext(tc.getConfig(), setupTargetName(tc, host, new NtlmContext(tc, this, doSigning)));
    }

     * 00020: 41 43 41 43 41 43 41 43 41 43 41 41 44 00 00 20  |ACACACACACAAD.. |
     * 00030: 00 01 c0 0c 00 20 00 01 00 00 00 00 00 06 20 00  |..... ........ .|
     * 00040: ac 22 22 e1                                      |."".            |
     * </pre>
     *
     * @param ps the PrintStream to write the hexdump output to
     * @param src the source byte array containing the data to dump