* Creates and returns a new instance of {@link LinkedHashMap}.
     *
     * @param <K> the key type of {@link LinkedHashMap}
     * @param <V> the value type of {@link LinkedHashMap}
     * @return a new instance of {@link LinkedHashMap}
     * @see LinkedHashMap#LinkedHashMap()
     */
    public static <K, V> LinkedHashMap<K, V> newLinkedHashMap() {
        return new LinkedHashMap<>();
    }

    /**

    Map<R, Integer> rowIndex = Maps.indexMap(rowSpace);
    Map<R, Map<C, V>> rows = new LinkedHashMap<>();
    for (R row : rowSpace) {
      rows.put(row, new LinkedHashMap<C, V>());
    }
    Map<C, Map<R, V>> columns = new LinkedHashMap<>();
    for (C col : columnSpace) {
      columns.put(col, new LinkedHashMap<R, V>());
    }
    int[] cellRowIndices = new int[cellList.size()];

 *
 * <p>As compared with {@link java.util.LinkedHashMap}, this structure places significantly reduced
 * load on the garbage collector by only using a constant number of internal objects.
 *
 * <p>This class should not be assumed to be universally superior to {@code
 * java.util.LinkedHashMap}. Generally speaking, this class reduces object allocation and memory

        fun wrap(a: kotlin.collections.Map<String, String>, b: kotlin.collections.Map.Entry<String, String>): Unit = Unit

        fun wrap(a: kotlin.collections.HashMap<String, String>, b: kotlin.collections.LinkedHashMap<String, String>): Unit = Unit

    """

    @Language("kotlin")
    private
    val annotatedKotlinMembers = """

        /** @since 2.0 */
        @Incubating
        fun foo() {}

     * @param value the value to be added to the <code>Map</code>
     * @return a {@literal Maps} for constructing a {@link LinkedHashMap} with the specified key and value
     */
    public static <KEY, VALUE> Maps<KEY, VALUE> linkedHashMap(final KEY key, final VALUE value) {
        return new Maps<>(new LinkedHashMap<KEY, VALUE>()).$(key, value);
    }

    /**

 * under the License.
 */
package org.apache.maven.model.normalization;

import javax.inject.Named;
import javax.inject.Singleton;

import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import org.apache.maven.model.Build;
import org.apache.maven.model.Dependency;
import org.apache.maven.model.Model;
import org.apache.maven.model.Plugin;

        final Map<String, String> configConfigMap = new LinkedHashMap<>();
        final Map<String, String> clientConfigMap = new LinkedHashMap<>();
        final Map<String, String> xpathConfigMap = new LinkedHashMap<>();
        final Map<String, String> metaConfigMap = new LinkedHashMap<>();
        final Map<String, String> valueConfigMap = new LinkedHashMap<>();
        final Map<String, String> scriptConfigMap = new LinkedHashMap<>();

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.util;

import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import org.codelibs.fess.Constants;
import org.opensearch.search.aggregations.Aggregations;
import org.opensearch.search.aggregations.bucket.filter.Filter;

 *
 * <p>As compared with {@link java.util.LinkedHashMap}, this structure places significantly reduced
 * load on the garbage collector by only using a constant number of internal objects.
 *
 * <p>This class should not be assumed to be universally superior to {@code
 * java.util.LinkedHashMap}. Generally speaking, this class reduces object allocation and memory

                context.logger.debug("  - " + extension.getId() + " -> " + formatLocation(extension.getLocation("")));
            }
        }

        LinkedHashMap<String, CoreExtension> selectedExtensions = new LinkedHashMap<>();
        List<String> conflicts = new ArrayList<>();
        for (CoreExtensions coreExtensions : configuredCoreExtensions) {