Map<K, V> newHashMapWithExpectedSize(int expectedSize) {
    return Maps.newHashMapWithExpectedSize(expectedSize);
  }

  /**
   * Returns the platform preferred implementation of an insertion ordered map based on a hash
   * table.
   */
  static <K extends @Nullable Object, V extends @Nullable Object>
      Map<K, V> newLinkedHashMapWithExpectedSize(int expectedSize) {

                                <div class="row">
                                    <div class="col-sm-12">
                                        <table class="table table-bordered table-striped">
                                            <thead>
                                            <tr>
                                                <th><la:message

                                    <la:errors/>
                                </div>
                                    <%-- Form Fields --%>
                                <table class="table table-bordered">
                                    <tbody>
                                    <tr>
                                        <th style="width: 25%"><la:message

    default Stream<Phase> allPhases() {
        return phases().stream().flatMap(Phase::allPhases);
    }

    /**
     * Collection of aliases.
     */
    Collection<Alias> aliases();

    /**
     * Pre-ordered list of phases.
     * If not provided, a default order will be computed.
     */
    default Optional<List<String>> orderedPhases() {
        return Optional.empty();
    }

    /**

            )
        )
    }

    @Test
    fun `verify AlphabeticalAcceptedApiChangesTask accepts properly ordered changes`() {
        //language=JSON
        firstAcceptedApiChangesFile.writeText(
            """
                {
                    "acceptedApiChanges": [
                        {

    Helpers.testComparator(comparator, ordered);
    assertThat(SerializableTester.reserialize(comparator)).isSameInstanceAs(comparator);

    // The Java implementation.
    Comparator<byte[]> javaImpl = UnsignedBytes.lexicographicalComparatorJavaImpl();
    Helpers.testComparator(javaImpl, ordered);
    assertThat(SerializableTester.reserialize(javaImpl)).isSameInstanceAs(javaImpl);
  }

            // 2.0.X == 2-X == 2.0.0.X for any string x
            checkVersionsEqual("2-" + x, "2.0." + x); // previously ordered, now equals
            checkVersionsEqual("2-" + x, "2.0.0." + x); // previously ordered, now equals
            checkVersionsEqual("2.0." + x, "2.0.0." + x); // previously ordered, now equals
        }
    }

    @Test
    public void testMng7714() {

                                    <la:errors/>
                                </div>
                                    <%-- Form Fields --%>
                                <table class="table table-bordered">
                                    <tbody>
                                    <tr>
                                        <th style="width: 25%"><la:message

                                </div>
                            </c:if>
                            <c:if test="${fn:length(dictFiles) > 0}">
                                <table class="table table-bordered table-striped">
                                    <thead>
                                    <tr>
                                        <th><la:message key="labels.dictionary_name"/></th>

  }

  /**
   * LinkedHashMultimap entries are in no less than three coexisting linked lists: a bucket in the
   * hash table for a {@code Set<V>} associated with a key, the linked list of insertion-ordered
   * entries in that {@code Set<V>}, and the linked list of entries in the LinkedHashMultimap as a
   * whole.
   */
  @VisibleForTesting