*
 * <p><b>Important:</b> although the first interpretation resembles how most multimaps are
 * <i>implemented</i>, the design of the {@code Multimap} API is based on the <i>second</i> form.
 * So, using the multimap shown above as an example, the {@link #size} is {@code 3}, not {@code 2},
 * and the {@link #values} collection is {@code [1, 2, 3]}, not {@code [[1, 2], [3]]}. For those

	ast1, err := parser.ParseFile(fset, name, src, flags)
	if err != nil {
		if list, ok := err.(scanner.ErrorList); ok {
			// If err is a scanner.ErrorList, its String will print just
			// the first error and then (+n more errors).
			// Instead, turn it into a new Error that will return
			// details for all the errors.
			for _, e := range list {
				fmt.Fprintln(os.Stderr, e)
			}
			os.Exit(2)
		}

    assertThat(set.subSet("c", "f")).isSameInstanceAs(set);
  }

  public void testEmpty_first() {
    SortedSet<String> set = of();
    assertThrows(NoSuchElementException.class, () -> set.first());
  }

  public void testEmpty_last() {
    SortedSet<String> set = of();
    assertThrows(NoSuchElementException.class, () -> set.last());
  }

  @J2ktIncompatible

  /** The [Buffer] of [sink]. Write to this and then flush/emit [sink]. */
  private val sinkBuffer: Buffer = sink.buffer
  private var writerClosed = false

  /** Lazily initialized on first use. */
  private var messageDeflater: MessageDeflater? = null

  // Masks are only a concern for client writers.
  private val maskKey: ByteArray? = if (isClient) ByteArray(4) else null

        assertNotNull("Encoded result should not be null", encoded);
        final byte[] decoded = Base64Util.decode(encoded);
        assertEquals("Decoded should have same length", 2, decoded.length);
        assertEquals("First byte should match", twoBytes[0], decoded[0]);
        assertEquals("Second byte should match", twoBytes[1], decoded[1]);
    }

    /**
     * Test backward compatibility with standard Base64
     *

        final int namesLength = numberOfNames * 18;
        final int statsLength = rDataLength - namesLength - 1;
        numberOfNames = src[srcIndex] & 0xFF;
        srcIndex++;
        // gotta read the mac first so we can populate addressArray with it
        System.arraycopy(src, srcIndex + namesLength, macAddress, 0, 6);
        srcIndex += readNodeNameArray(src, srcIndex);
        stats = new byte[statsLength];

the object metadata on MinIO.

The data on the backend is stored under the `bucket/prefix` specified in the tier configuration with a custom name derived from a randomly generated uuid - e.g. `0b/c4/0bc4fab7-2daf-4d2f-8e39-5c6c6fb7e2d3`. The first two prefixes are characters 1-2,3-4 from the uuid. This format allows tiering to any cloud irrespective of whether the cloud in question supports versioning. The reference to the transitioned object name and transitioned tier is stored as part of the...

                        .joinToString(",") { "%dep.${it.id}.env.BUILD_ID%" }

                val dependencyBaselines =
                    performanceTestProject.performanceTests
                        .first {
                            it.testProjects.isNotEmpty()
                        }.let { "%dep.${it.id}.performance.baselines%" }

                gradleRunnerStep(
                    model,

 * slowing down building documentation.
 *
 * All this would be so much simpler if the Kotlin extensions to the Gradle API
 * were generated at build time instead.
 *
 * This is a first step to get the doc to be complete and will be revisited.
 */
@CacheableTask
public abstract class GradleKotlinDslRuntimeGeneratedSources extends DefaultTask {

    @Classpath

final class EmptyContiguousSet<C extends Comparable> extends ContiguousSet<C> {
  EmptyContiguousSet(DiscreteDomain<C> domain) {
    super(domain);
  }

  @Override
  public C first() {
    throw new NoSuchElementException();
  }

  @Override
  public C last() {
    throw new NoSuchElementException();
  }

  @Override
  public int size() {
    return 0;
  }

  @Override