@Override
  public boolean equals(@Nullable Object object) {
    return Multimaps.equalsImpl(this, object);
  }

  /**
   * Returns the hash code for this multimap.
   *
   * <p>The hash code of a multimap is defined as the hash code of the map view, as returned by
   * {@link Multimap#asMap}.
   *
   * @see Map#hashCode
   */
  @Override
  public int hashCode() {

When there's a first translation for a language, it will have a `docs/{lang code}/docs/index.md` translated file and a `docs/{lang code}/mkdocs.yml`.

For example, for Bosnian, it would be:

* `docs/bs/docs/index.md`
* `docs/bs/mkdocs.yml`

The `mkdocs.yml` file will have only the following content:

```YAML
INHERIT: ../en/mkdocs.yml
```

* **Uvicorn**:
    * Bietet die beste Leistung, da außer dem Server selbst nicht viel zusätzlicher Code vorhanden ist.

 * service. Subclasses should override one or more methods to modify the behavior of the backing
 * executor service as desired per the <a
 * href="http://en.wikipedia.org/wiki/Decorator_pattern">decorator pattern</a>.
 *
 * <p><b>{@code default} method warning:</b> This class does <i>not</i> forward calls to {@code
 * default} methods. Instead, it inherits their default implementations. When those implementations

        } else {
            str
        }

    override fun createFunctionalTestsFor(
        model: CIBuildModel,
        stage: Stage,
        testCoverage: TestCoverage,
        bucketIndex: Int,
    ): FunctionalTest =
        FunctionalTest(
            model,
            testCoverage.getBucketUuid(model, bucketIndex),
            getName(testCoverage),
            getDescription(testCoverage),

 * An iterator which forwards all its method calls to another iterator. Subclasses should override
 * one or more methods to modify the behavior of the backing iterator as desired per the <a
 * href="http://en.wikipedia.org/wiki/Decorator_pattern">decorator pattern</a>.
 *
 * <p><b>{@code default} method warning:</b> This class forwards calls to <i>only some</i> {@code
 * default} methods. Specifically, it forwards calls only for methods that existed <a

   * @return {@code string} if it is not null; {@code ""} otherwise
   */
  static String nullToEmpty(@Nullable String string) {
    return (string == null) ? "" : string;
  }

  /**
   * Returns the string if it is not empty, or a null string otherwise.
   *
   * @param string the string to test and possibly return
   * @return {@code string} if it is not empty; {@code null} otherwise
   */

    }

    /**
     * Returns the default flags for a generic Type-2 message in the
     * current environment.
     *
     * @param tc
     *            context to use
     * @return An <code>int</code> containing the default flags.
     */
    public static int getDefaultFlags(final CIFSContext tc) {
        return NTLMSSP_NEGOTIATE_NTLM | NTLMSSP_NEGOTIATE_VERSION

    return of(collector, Objects::equals);
  }

  /**
   * Creates a {@code CollectorTester} for the specified {@code Collector}. The result of the {@code
   * Collector} will be compared to the expected value using the specified {@code equivalence}.
   */
  public static <T extends @Nullable Object, A extends @Nullable Object, R extends @Nullable Object>
      CollectorTester<T, A, R> of(

   *
   * Note that transport-layer success (receiving a HTTP response code, headers and body) does not
   * necessarily indicate application-layer success: `response` may still indicate an unhappy HTTP
   * response code like 404 or 500.
   *
   * @throws IOException if the request could not be executed due to cancellation, a connectivity