/*
 * Copyright 2025 mingliqiye
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * ProjectName mingli-utils
 * ModuleName mingli-utils.main
 * CurrentFile Maps.java
 * LastUpdate 2025-09-09 08:37:33
 * UpdateUser MingLiPro
 */

package com.mingliqiye.utils.collection;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import lombok.var;

/**
 * Maps工具类提供了一系列创建Map实现的便捷方法。
 *
 * @author MingLiPro
 */
public class Maps {

	/**
	 * 创建一个空的HashMap实例。
	 *
	 * @param <K> Map键的类型
	 * @param <V> Map值的类型
	 * @return 新创建的空HashMap实例
	 */
	public static <K, V> Map<K, V> newHashMap() {
		return new HashMap<>();
	}

	/**
	 * 创建一个指定初始容量的空HashMap实例。
	 *
	 * @param size 初始容量大小
	 * @param <K>  Map键的类型
	 * @param <V>  Map值的类型
	 * @return 指定初始容量的空HashMap实例
	 */
	public static <K, V> Map<K, V> newHashMap(int size) {
		return new HashMap<>(size);
	}

	/**
	 * 根据已有Map创建一个新的HashMap实例。
	 *
	 * @param map 要复制的Map
	 * @param <K> Map键的类型
	 * @param <V> Map值的类型
	 * @return 包含原Map所有元素的新HashMap实例
	 */
	public static <K, V> Map<K, V> newHashMap(Map<K, V> map) {
		Map<K, V> newMap = newHashMap();
		newMap.putAll(map);
		return newMap;
	}

	/**
	 * 创建一个空的LinkedHashMap实例。
	 *
	 * @param <K> Map键的类型
	 * @param <V> Map值的类型
	 * @return 新创建的空LinkedHashMap实例
	 */
	public static <K, V> Map<K, V> newLinkedHashMap() {
		return new LinkedHashMap<>();
	}

	/**
	 * 创建一个指定初始容量的空LinkedHashMap实例。
	 *
	 * @param size 初始容量大小
	 * @param <K>  Map键的类型
	 * @param <V>  Map值的类型
	 * @return 指定初始容量的空LinkedHashMap实例
	 */
	public static <K, V> Map<K, V> newLinkedHashMap(int size) {
		return new LinkedHashMap<>(size);
	}

	/**
	 * 根据已有Map创建一个新的LinkedHashMap实例。
	 *
	 * @param map 要复制的Map
	 * @param <K> Map键的类型
	 * @param <V> Map值的类型
	 * @return 包含原Map所有元素的新LinkedHashMap实例
	 */
	public static <K, V> Map<K, V> newLinkedHashMap(Map<K, V> map) {
		Map<K, V> newMap = newLinkedHashMap();
		newMap.putAll(map);
		return newMap;
	}

	/**
	 * 创建一个空的TreeMap实例。
	 *
	 * @param <K> Map键的类型，必须实现Comparable接口
	 * @param <V> Map值的类型
	 * @return 新创建的空TreeMap实例
	 */
	public static <K extends Comparable<K>, V> Map<K, V> newTreeMap() {
		return new TreeMap<>();
	}

	/**
	 * 根据已有Map创建一个新的TreeMap实例。
	 *
	 * @param map 要复制的Map
	 * @param <K> Map键的类型，必须实现Comparable接口
	 * @param <V> Map值的类型
	 * @return 包含原Map所有元素的新TreeMap实例
	 */
	public static <K extends Comparable<K>, V> Map<K, V> newTreeMap(
		Map<K, V> map
	) {
		Map<K, V> newMap = newTreeMap();
		newMap.putAll(map);
		return newMap;
	}

	/**
	 * 创建一个空的Hashtable实例。
	 *
	 * @param <K> Map键的类型
	 * @param <V> Map值的类型
	 * @return 新创建的空Hashtable实例
	 */
	public static <K, V> Map<K, V> newHashtable() {
		return new Hashtable<>();
	}

	/**
	 * 创建一个指定初始容量的空Hashtable实例。
	 *
	 * @param size 初始容量大小
	 * @param <K>  Map键的类型
	 * @param <V>  Map值的类型
	 * @return 指定初始容量的空Hashtable实例
	 */
	public static <K, V> Map<K, V> newHashtable(int size) {
		return new Hashtable<>(size);
	}

	/**
	 * 根据已有Map创建一个新的Hashtable实例。
	 *
	 * @param map 要复制的Map
	 * @param <K> Map键的类型
	 * @param <V> Map值的类型
	 * @return 包含原Map所有元素的新Hashtable实例
	 */
	public static <K, V> Map<K, V> newHashtable(Map<K, V> map) {
		Map<K, V> newMap = newHashtable();
		newMap.putAll(map);
		return newMap;
	}

	/**
	 * 创建一个空的ConcurrentHashMap实例。
	 *
	 * @param <K> Map键的类型
	 * @param <V> Map值的类型
	 * @return 新创建的空ConcurrentHashMap实例
	 */
	public static <K, V> Map<K, V> newConcurrentHashMap() {
		return new ConcurrentHashMap<>();
	}

	/**
	 * 创建一个指定初始容量的空ConcurrentHashMap实例。
	 *
	 * @param size 初始容量大小
	 * @param <K>  Map键的类型
	 * @param <V>  Map值的类型
	 * @return 指定初始容量的空ConcurrentHashMap实例
	 */
	public static <K, V> Map<K, V> newConcurrentHashMap(int size) {
		return new ConcurrentHashMap<>(size);
	}

	/**
	 * 根据已有Map创建一个新的ConcurrentHashMap实例。
	 *
	 * @param map 要复制的Map
	 * @param <K> Map键的类型
	 * @param <V> Map值的类型
	 * @return 包含原Map所有元素的新ConcurrentHashMap实例
	 */
	public static <K, V> Map<K, V> newConcurrentHashMap(Map<K, V> map) {
		Map<K, V> newMap = newConcurrentHashMap();
		newMap.putAll(map);
		return newMap;
	}

	/**
	 * 创建一个包含单个键值对的HashMap实例。
	 *
	 * @param key   键
	 * @param value 值
	 * @param <K>   键的类型
	 * @param <V>   值的类型
	 * @return 包含指定键值对的HashMap实例
	 */
	public static <K, V> Map<K, V> of(K key, V value) {
		var map = new HashMap<K, V>(5);
		map.put(key, value);
		return map;
	}

	public static <K, V> Map<K, V> of(K key, V value, K key2, V value2) {
		var map = new HashMap<K, V>(6);
		map.put(key, value);
		map.put(key2, value2);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3
	) {
		var map = new HashMap<K, V>(7);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4
	) {
		var map = new HashMap<K, V>(8);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5
	) {
		var map = new HashMap<K, V>(9);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6
	) {
		var map = new HashMap<K, V>(10);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7
	) {
		var map = new HashMap<K, V>(11);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8
	) {
		var map = new HashMap<K, V>(12);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9
	) {
		var map = new HashMap<K, V>(13);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10
	) {
		var map = new HashMap<K, V>(14);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11
	) {
		var map = new HashMap<K, V>(15);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12
	) {
		var map = new HashMap<K, V>(16);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13
	) {
		var map = new HashMap<K, V>(17);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14
	) {
		var map = new HashMap<K, V>(18);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15
	) {
		var map = new HashMap<K, V>(19);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16
	) {
		var map = new HashMap<K, V>(20);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17
	) {
		var map = new HashMap<K, V>(21);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18
	) {
		var map = new HashMap<K, V>(22);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19
	) {
		var map = new HashMap<K, V>(23);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20
	) {
		var map = new HashMap<K, V>(24);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21
	) {
		var map = new HashMap<K, V>(25);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22
	) {
		var map = new HashMap<K, V>(26);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23
	) {
		var map = new HashMap<K, V>(27);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24
	) {
		var map = new HashMap<K, V>(28);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25
	) {
		var map = new HashMap<K, V>(29);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26
	) {
		var map = new HashMap<K, V>(30);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27
	) {
		var map = new HashMap<K, V>(31);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28
	) {
		var map = new HashMap<K, V>(32);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29
	) {
		var map = new HashMap<K, V>(33);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30
	) {
		var map = new HashMap<K, V>(34);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31
	) {
		var map = new HashMap<K, V>(35);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32
	) {
		var map = new HashMap<K, V>(36);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33
	) {
		var map = new HashMap<K, V>(37);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34
	) {
		var map = new HashMap<K, V>(38);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35
	) {
		var map = new HashMap<K, V>(39);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36
	) {
		var map = new HashMap<K, V>(40);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37
	) {
		var map = new HashMap<K, V>(41);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38
	) {
		var map = new HashMap<K, V>(42);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39
	) {
		var map = new HashMap<K, V>(43);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40
	) {
		var map = new HashMap<K, V>(44);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41
	) {
		var map = new HashMap<K, V>(45);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42
	) {
		var map = new HashMap<K, V>(46);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43
	) {
		var map = new HashMap<K, V>(47);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44
	) {
		var map = new HashMap<K, V>(48);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45
	) {
		var map = new HashMap<K, V>(49);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46
	) {
		var map = new HashMap<K, V>(50);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47
	) {
		var map = new HashMap<K, V>(51);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48
	) {
		var map = new HashMap<K, V>(52);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49
	) {
		var map = new HashMap<K, V>(53);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50
	) {
		var map = new HashMap<K, V>(54);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51
	) {
		var map = new HashMap<K, V>(55);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52
	) {
		var map = new HashMap<K, V>(56);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53
	) {
		var map = new HashMap<K, V>(57);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54
	) {
		var map = new HashMap<K, V>(58);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55
	) {
		var map = new HashMap<K, V>(59);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55,
		K key56,
		V value56
	) {
		var map = new HashMap<K, V>(60);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		map.put(key56, value56);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55,
		K key56,
		V value56,
		K key57,
		V value57
	) {
		var map = new HashMap<K, V>(61);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		map.put(key56, value56);
		map.put(key57, value57);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55,
		K key56,
		V value56,
		K key57,
		V value57,
		K key58,
		V value58
	) {
		var map = new HashMap<K, V>(62);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		map.put(key56, value56);
		map.put(key57, value57);
		map.put(key58, value58);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55,
		K key56,
		V value56,
		K key57,
		V value57,
		K key58,
		V value58,
		K key59,
		V value59
	) {
		var map = new HashMap<K, V>(63);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		map.put(key56, value56);
		map.put(key57, value57);
		map.put(key58, value58);
		map.put(key59, value59);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55,
		K key56,
		V value56,
		K key57,
		V value57,
		K key58,
		V value58,
		K key59,
		V value59,
		K key60,
		V value60
	) {
		var map = new HashMap<K, V>(64);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		map.put(key56, value56);
		map.put(key57, value57);
		map.put(key58, value58);
		map.put(key59, value59);
		map.put(key60, value60);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55,
		K key56,
		V value56,
		K key57,
		V value57,
		K key58,
		V value58,
		K key59,
		V value59,
		K key60,
		V value60,
		K key61,
		V value61
	) {
		var map = new HashMap<K, V>(65);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		map.put(key56, value56);
		map.put(key57, value57);
		map.put(key58, value58);
		map.put(key59, value59);
		map.put(key60, value60);
		map.put(key61, value61);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55,
		K key56,
		V value56,
		K key57,
		V value57,
		K key58,
		V value58,
		K key59,
		V value59,
		K key60,
		V value60,
		K key61,
		V value61,
		K key62,
		V value62
	) {
		var map = new HashMap<K, V>(66);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		map.put(key56, value56);
		map.put(key57, value57);
		map.put(key58, value58);
		map.put(key59, value59);
		map.put(key60, value60);
		map.put(key61, value61);
		map.put(key62, value62);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55,
		K key56,
		V value56,
		K key57,
		V value57,
		K key58,
		V value58,
		K key59,
		V value59,
		K key60,
		V value60,
		K key61,
		V value61,
		K key62,
		V value62,
		K key63,
		V value63
	) {
		var map = new HashMap<K, V>(67);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		map.put(key56, value56);
		map.put(key57, value57);
		map.put(key58, value58);
		map.put(key59, value59);
		map.put(key60, value60);
		map.put(key61, value61);
		map.put(key62, value62);
		map.put(key63, value63);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55,
		K key56,
		V value56,
		K key57,
		V value57,
		K key58,
		V value58,
		K key59,
		V value59,
		K key60,
		V value60,
		K key61,
		V value61,
		K key62,
		V value62,
		K key63,
		V value63,
		K key64,
		V value64
	) {
		var map = new HashMap<K, V>(68);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		map.put(key56, value56);
		map.put(key57, value57);
		map.put(key58, value58);
		map.put(key59, value59);
		map.put(key60, value60);
		map.put(key61, value61);
		map.put(key62, value62);
		map.put(key63, value63);
		map.put(key64, value64);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55,
		K key56,
		V value56,
		K key57,
		V value57,
		K key58,
		V value58,
		K key59,
		V value59,
		K key60,
		V value60,
		K key61,
		V value61,
		K key62,
		V value62,
		K key63,
		V value63,
		K key64,
		V value64,
		K key65,
		V value65
	) {
		var map = new HashMap<K, V>(69);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		map.put(key56, value56);
		map.put(key57, value57);
		map.put(key58, value58);
		map.put(key59, value59);
		map.put(key60, value60);
		map.put(key61, value61);
		map.put(key62, value62);
		map.put(key63, value63);
		map.put(key64, value64);
		map.put(key65, value65);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55,
		K key56,
		V value56,
		K key57,
		V value57,
		K key58,
		V value58,
		K key59,
		V value59,
		K key60,
		V value60,
		K key61,
		V value61,
		K key62,
		V value62,
		K key63,
		V value63,
		K key64,
		V value64,
		K key65,
		V value65,
		K key66,
		V value66
	) {
		var map = new HashMap<K, V>(70);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		map.put(key56, value56);
		map.put(key57, value57);
		map.put(key58, value58);
		map.put(key59, value59);
		map.put(key60, value60);
		map.put(key61, value61);
		map.put(key62, value62);
		map.put(key63, value63);
		map.put(key64, value64);
		map.put(key65, value65);
		map.put(key66, value66);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55,
		K key56,
		V value56,
		K key57,
		V value57,
		K key58,
		V value58,
		K key59,
		V value59,
		K key60,
		V value60,
		K key61,
		V value61,
		K key62,
		V value62,
		K key63,
		V value63,
		K key64,
		V value64,
		K key65,
		V value65,
		K key66,
		V value66,
		K key67,
		V value67
	) {
		var map = new HashMap<K, V>(71);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		map.put(key56, value56);
		map.put(key57, value57);
		map.put(key58, value58);
		map.put(key59, value59);
		map.put(key60, value60);
		map.put(key61, value61);
		map.put(key62, value62);
		map.put(key63, value63);
		map.put(key64, value64);
		map.put(key65, value65);
		map.put(key66, value66);
		map.put(key67, value67);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55,
		K key56,
		V value56,
		K key57,
		V value57,
		K key58,
		V value58,
		K key59,
		V value59,
		K key60,
		V value60,
		K key61,
		V value61,
		K key62,
		V value62,
		K key63,
		V value63,
		K key64,
		V value64,
		K key65,
		V value65,
		K key66,
		V value66,
		K key67,
		V value67,
		K key68,
		V value68
	) {
		var map = new HashMap<K, V>(72);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		map.put(key56, value56);
		map.put(key57, value57);
		map.put(key58, value58);
		map.put(key59, value59);
		map.put(key60, value60);
		map.put(key61, value61);
		map.put(key62, value62);
		map.put(key63, value63);
		map.put(key64, value64);
		map.put(key65, value65);
		map.put(key66, value66);
		map.put(key67, value67);
		map.put(key68, value68);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55,
		K key56,
		V value56,
		K key57,
		V value57,
		K key58,
		V value58,
		K key59,
		V value59,
		K key60,
		V value60,
		K key61,
		V value61,
		K key62,
		V value62,
		K key63,
		V value63,
		K key64,
		V value64,
		K key65,
		V value65,
		K key66,
		V value66,
		K key67,
		V value67,
		K key68,
		V value68,
		K key69,
		V value69
	) {
		var map = new HashMap<K, V>(73);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		map.put(key56, value56);
		map.put(key57, value57);
		map.put(key58, value58);
		map.put(key59, value59);
		map.put(key60, value60);
		map.put(key61, value61);
		map.put(key62, value62);
		map.put(key63, value63);
		map.put(key64, value64);
		map.put(key65, value65);
		map.put(key66, value66);
		map.put(key67, value67);
		map.put(key68, value68);
		map.put(key69, value69);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55,
		K key56,
		V value56,
		K key57,
		V value57,
		K key58,
		V value58,
		K key59,
		V value59,
		K key60,
		V value60,
		K key61,
		V value61,
		K key62,
		V value62,
		K key63,
		V value63,
		K key64,
		V value64,
		K key65,
		V value65,
		K key66,
		V value66,
		K key67,
		V value67,
		K key68,
		V value68,
		K key69,
		V value69,
		K key70,
		V value70
	) {
		var map = new HashMap<K, V>(74);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		map.put(key56, value56);
		map.put(key57, value57);
		map.put(key58, value58);
		map.put(key59, value59);
		map.put(key60, value60);
		map.put(key61, value61);
		map.put(key62, value62);
		map.put(key63, value63);
		map.put(key64, value64);
		map.put(key65, value65);
		map.put(key66, value66);
		map.put(key67, value67);
		map.put(key68, value68);
		map.put(key69, value69);
		map.put(key70, value70);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55,
		K key56,
		V value56,
		K key57,
		V value57,
		K key58,
		V value58,
		K key59,
		V value59,
		K key60,
		V value60,
		K key61,
		V value61,
		K key62,
		V value62,
		K key63,
		V value63,
		K key64,
		V value64,
		K key65,
		V value65,
		K key66,
		V value66,
		K key67,
		V value67,
		K key68,
		V value68,
		K key69,
		V value69,
		K key70,
		V value70,
		K key71,
		V value71
	) {
		var map = new HashMap<K, V>(75);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		map.put(key56, value56);
		map.put(key57, value57);
		map.put(key58, value58);
		map.put(key59, value59);
		map.put(key60, value60);
		map.put(key61, value61);
		map.put(key62, value62);
		map.put(key63, value63);
		map.put(key64, value64);
		map.put(key65, value65);
		map.put(key66, value66);
		map.put(key67, value67);
		map.put(key68, value68);
		map.put(key69, value69);
		map.put(key70, value70);
		map.put(key71, value71);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55,
		K key56,
		V value56,
		K key57,
		V value57,
		K key58,
		V value58,
		K key59,
		V value59,
		K key60,
		V value60,
		K key61,
		V value61,
		K key62,
		V value62,
		K key63,
		V value63,
		K key64,
		V value64,
		K key65,
		V value65,
		K key66,
		V value66,
		K key67,
		V value67,
		K key68,
		V value68,
		K key69,
		V value69,
		K key70,
		V value70,
		K key71,
		V value71,
		K key72,
		V value72
	) {
		var map = new HashMap<K, V>(76);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		map.put(key56, value56);
		map.put(key57, value57);
		map.put(key58, value58);
		map.put(key59, value59);
		map.put(key60, value60);
		map.put(key61, value61);
		map.put(key62, value62);
		map.put(key63, value63);
		map.put(key64, value64);
		map.put(key65, value65);
		map.put(key66, value66);
		map.put(key67, value67);
		map.put(key68, value68);
		map.put(key69, value69);
		map.put(key70, value70);
		map.put(key71, value71);
		map.put(key72, value72);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55,
		K key56,
		V value56,
		K key57,
		V value57,
		K key58,
		V value58,
		K key59,
		V value59,
		K key60,
		V value60,
		K key61,
		V value61,
		K key62,
		V value62,
		K key63,
		V value63,
		K key64,
		V value64,
		K key65,
		V value65,
		K key66,
		V value66,
		K key67,
		V value67,
		K key68,
		V value68,
		K key69,
		V value69,
		K key70,
		V value70,
		K key71,
		V value71,
		K key72,
		V value72,
		K key73,
		V value73
	) {
		var map = new HashMap<K, V>(77);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		map.put(key56, value56);
		map.put(key57, value57);
		map.put(key58, value58);
		map.put(key59, value59);
		map.put(key60, value60);
		map.put(key61, value61);
		map.put(key62, value62);
		map.put(key63, value63);
		map.put(key64, value64);
		map.put(key65, value65);
		map.put(key66, value66);
		map.put(key67, value67);
		map.put(key68, value68);
		map.put(key69, value69);
		map.put(key70, value70);
		map.put(key71, value71);
		map.put(key72, value72);
		map.put(key73, value73);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55,
		K key56,
		V value56,
		K key57,
		V value57,
		K key58,
		V value58,
		K key59,
		V value59,
		K key60,
		V value60,
		K key61,
		V value61,
		K key62,
		V value62,
		K key63,
		V value63,
		K key64,
		V value64,
		K key65,
		V value65,
		K key66,
		V value66,
		K key67,
		V value67,
		K key68,
		V value68,
		K key69,
		V value69,
		K key70,
		V value70,
		K key71,
		V value71,
		K key72,
		V value72,
		K key73,
		V value73,
		K key74,
		V value74
	) {
		var map = new HashMap<K, V>(78);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		map.put(key56, value56);
		map.put(key57, value57);
		map.put(key58, value58);
		map.put(key59, value59);
		map.put(key60, value60);
		map.put(key61, value61);
		map.put(key62, value62);
		map.put(key63, value63);
		map.put(key64, value64);
		map.put(key65, value65);
		map.put(key66, value66);
		map.put(key67, value67);
		map.put(key68, value68);
		map.put(key69, value69);
		map.put(key70, value70);
		map.put(key71, value71);
		map.put(key72, value72);
		map.put(key73, value73);
		map.put(key74, value74);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55,
		K key56,
		V value56,
		K key57,
		V value57,
		K key58,
		V value58,
		K key59,
		V value59,
		K key60,
		V value60,
		K key61,
		V value61,
		K key62,
		V value62,
		K key63,
		V value63,
		K key64,
		V value64,
		K key65,
		V value65,
		K key66,
		V value66,
		K key67,
		V value67,
		K key68,
		V value68,
		K key69,
		V value69,
		K key70,
		V value70,
		K key71,
		V value71,
		K key72,
		V value72,
		K key73,
		V value73,
		K key74,
		V value74,
		K key75,
		V value75
	) {
		var map = new HashMap<K, V>(79);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		map.put(key56, value56);
		map.put(key57, value57);
		map.put(key58, value58);
		map.put(key59, value59);
		map.put(key60, value60);
		map.put(key61, value61);
		map.put(key62, value62);
		map.put(key63, value63);
		map.put(key64, value64);
		map.put(key65, value65);
		map.put(key66, value66);
		map.put(key67, value67);
		map.put(key68, value68);
		map.put(key69, value69);
		map.put(key70, value70);
		map.put(key71, value71);
		map.put(key72, value72);
		map.put(key73, value73);
		map.put(key74, value74);
		map.put(key75, value75);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55,
		K key56,
		V value56,
		K key57,
		V value57,
		K key58,
		V value58,
		K key59,
		V value59,
		K key60,
		V value60,
		K key61,
		V value61,
		K key62,
		V value62,
		K key63,
		V value63,
		K key64,
		V value64,
		K key65,
		V value65,
		K key66,
		V value66,
		K key67,
		V value67,
		K key68,
		V value68,
		K key69,
		V value69,
		K key70,
		V value70,
		K key71,
		V value71,
		K key72,
		V value72,
		K key73,
		V value73,
		K key74,
		V value74,
		K key75,
		V value75,
		K key76,
		V value76
	) {
		var map = new HashMap<K, V>(80);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		map.put(key56, value56);
		map.put(key57, value57);
		map.put(key58, value58);
		map.put(key59, value59);
		map.put(key60, value60);
		map.put(key61, value61);
		map.put(key62, value62);
		map.put(key63, value63);
		map.put(key64, value64);
		map.put(key65, value65);
		map.put(key66, value66);
		map.put(key67, value67);
		map.put(key68, value68);
		map.put(key69, value69);
		map.put(key70, value70);
		map.put(key71, value71);
		map.put(key72, value72);
		map.put(key73, value73);
		map.put(key74, value74);
		map.put(key75, value75);
		map.put(key76, value76);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55,
		K key56,
		V value56,
		K key57,
		V value57,
		K key58,
		V value58,
		K key59,
		V value59,
		K key60,
		V value60,
		K key61,
		V value61,
		K key62,
		V value62,
		K key63,
		V value63,
		K key64,
		V value64,
		K key65,
		V value65,
		K key66,
		V value66,
		K key67,
		V value67,
		K key68,
		V value68,
		K key69,
		V value69,
		K key70,
		V value70,
		K key71,
		V value71,
		K key72,
		V value72,
		K key73,
		V value73,
		K key74,
		V value74,
		K key75,
		V value75,
		K key76,
		V value76,
		K key77,
		V value77
	) {
		var map = new HashMap<K, V>(81);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		map.put(key56, value56);
		map.put(key57, value57);
		map.put(key58, value58);
		map.put(key59, value59);
		map.put(key60, value60);
		map.put(key61, value61);
		map.put(key62, value62);
		map.put(key63, value63);
		map.put(key64, value64);
		map.put(key65, value65);
		map.put(key66, value66);
		map.put(key67, value67);
		map.put(key68, value68);
		map.put(key69, value69);
		map.put(key70, value70);
		map.put(key71, value71);
		map.put(key72, value72);
		map.put(key73, value73);
		map.put(key74, value74);
		map.put(key75, value75);
		map.put(key76, value76);
		map.put(key77, value77);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55,
		K key56,
		V value56,
		K key57,
		V value57,
		K key58,
		V value58,
		K key59,
		V value59,
		K key60,
		V value60,
		K key61,
		V value61,
		K key62,
		V value62,
		K key63,
		V value63,
		K key64,
		V value64,
		K key65,
		V value65,
		K key66,
		V value66,
		K key67,
		V value67,
		K key68,
		V value68,
		K key69,
		V value69,
		K key70,
		V value70,
		K key71,
		V value71,
		K key72,
		V value72,
		K key73,
		V value73,
		K key74,
		V value74,
		K key75,
		V value75,
		K key76,
		V value76,
		K key77,
		V value77,
		K key78,
		V value78
	) {
		var map = new HashMap<K, V>(82);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		map.put(key56, value56);
		map.put(key57, value57);
		map.put(key58, value58);
		map.put(key59, value59);
		map.put(key60, value60);
		map.put(key61, value61);
		map.put(key62, value62);
		map.put(key63, value63);
		map.put(key64, value64);
		map.put(key65, value65);
		map.put(key66, value66);
		map.put(key67, value67);
		map.put(key68, value68);
		map.put(key69, value69);
		map.put(key70, value70);
		map.put(key71, value71);
		map.put(key72, value72);
		map.put(key73, value73);
		map.put(key74, value74);
		map.put(key75, value75);
		map.put(key76, value76);
		map.put(key77, value77);
		map.put(key78, value78);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55,
		K key56,
		V value56,
		K key57,
		V value57,
		K key58,
		V value58,
		K key59,
		V value59,
		K key60,
		V value60,
		K key61,
		V value61,
		K key62,
		V value62,
		K key63,
		V value63,
		K key64,
		V value64,
		K key65,
		V value65,
		K key66,
		V value66,
		K key67,
		V value67,
		K key68,
		V value68,
		K key69,
		V value69,
		K key70,
		V value70,
		K key71,
		V value71,
		K key72,
		V value72,
		K key73,
		V value73,
		K key74,
		V value74,
		K key75,
		V value75,
		K key76,
		V value76,
		K key77,
		V value77,
		K key78,
		V value78,
		K key79,
		V value79
	) {
		var map = new HashMap<K, V>(83);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		map.put(key56, value56);
		map.put(key57, value57);
		map.put(key58, value58);
		map.put(key59, value59);
		map.put(key60, value60);
		map.put(key61, value61);
		map.put(key62, value62);
		map.put(key63, value63);
		map.put(key64, value64);
		map.put(key65, value65);
		map.put(key66, value66);
		map.put(key67, value67);
		map.put(key68, value68);
		map.put(key69, value69);
		map.put(key70, value70);
		map.put(key71, value71);
		map.put(key72, value72);
		map.put(key73, value73);
		map.put(key74, value74);
		map.put(key75, value75);
		map.put(key76, value76);
		map.put(key77, value77);
		map.put(key78, value78);
		map.put(key79, value79);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55,
		K key56,
		V value56,
		K key57,
		V value57,
		K key58,
		V value58,
		K key59,
		V value59,
		K key60,
		V value60,
		K key61,
		V value61,
		K key62,
		V value62,
		K key63,
		V value63,
		K key64,
		V value64,
		K key65,
		V value65,
		K key66,
		V value66,
		K key67,
		V value67,
		K key68,
		V value68,
		K key69,
		V value69,
		K key70,
		V value70,
		K key71,
		V value71,
		K key72,
		V value72,
		K key73,
		V value73,
		K key74,
		V value74,
		K key75,
		V value75,
		K key76,
		V value76,
		K key77,
		V value77,
		K key78,
		V value78,
		K key79,
		V value79,
		K key80,
		V value80
	) {
		var map = new HashMap<K, V>(84);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		map.put(key56, value56);
		map.put(key57, value57);
		map.put(key58, value58);
		map.put(key59, value59);
		map.put(key60, value60);
		map.put(key61, value61);
		map.put(key62, value62);
		map.put(key63, value63);
		map.put(key64, value64);
		map.put(key65, value65);
		map.put(key66, value66);
		map.put(key67, value67);
		map.put(key68, value68);
		map.put(key69, value69);
		map.put(key70, value70);
		map.put(key71, value71);
		map.put(key72, value72);
		map.put(key73, value73);
		map.put(key74, value74);
		map.put(key75, value75);
		map.put(key76, value76);
		map.put(key77, value77);
		map.put(key78, value78);
		map.put(key79, value79);
		map.put(key80, value80);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55,
		K key56,
		V value56,
		K key57,
		V value57,
		K key58,
		V value58,
		K key59,
		V value59,
		K key60,
		V value60,
		K key61,
		V value61,
		K key62,
		V value62,
		K key63,
		V value63,
		K key64,
		V value64,
		K key65,
		V value65,
		K key66,
		V value66,
		K key67,
		V value67,
		K key68,
		V value68,
		K key69,
		V value69,
		K key70,
		V value70,
		K key71,
		V value71,
		K key72,
		V value72,
		K key73,
		V value73,
		K key74,
		V value74,
		K key75,
		V value75,
		K key76,
		V value76,
		K key77,
		V value77,
		K key78,
		V value78,
		K key79,
		V value79,
		K key80,
		V value80,
		K key81,
		V value81
	) {
		var map = new HashMap<K, V>(85);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		map.put(key56, value56);
		map.put(key57, value57);
		map.put(key58, value58);
		map.put(key59, value59);
		map.put(key60, value60);
		map.put(key61, value61);
		map.put(key62, value62);
		map.put(key63, value63);
		map.put(key64, value64);
		map.put(key65, value65);
		map.put(key66, value66);
		map.put(key67, value67);
		map.put(key68, value68);
		map.put(key69, value69);
		map.put(key70, value70);
		map.put(key71, value71);
		map.put(key72, value72);
		map.put(key73, value73);
		map.put(key74, value74);
		map.put(key75, value75);
		map.put(key76, value76);
		map.put(key77, value77);
		map.put(key78, value78);
		map.put(key79, value79);
		map.put(key80, value80);
		map.put(key81, value81);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55,
		K key56,
		V value56,
		K key57,
		V value57,
		K key58,
		V value58,
		K key59,
		V value59,
		K key60,
		V value60,
		K key61,
		V value61,
		K key62,
		V value62,
		K key63,
		V value63,
		K key64,
		V value64,
		K key65,
		V value65,
		K key66,
		V value66,
		K key67,
		V value67,
		K key68,
		V value68,
		K key69,
		V value69,
		K key70,
		V value70,
		K key71,
		V value71,
		K key72,
		V value72,
		K key73,
		V value73,
		K key74,
		V value74,
		K key75,
		V value75,
		K key76,
		V value76,
		K key77,
		V value77,
		K key78,
		V value78,
		K key79,
		V value79,
		K key80,
		V value80,
		K key81,
		V value81,
		K key82,
		V value82
	) {
		var map = new HashMap<K, V>(86);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		map.put(key56, value56);
		map.put(key57, value57);
		map.put(key58, value58);
		map.put(key59, value59);
		map.put(key60, value60);
		map.put(key61, value61);
		map.put(key62, value62);
		map.put(key63, value63);
		map.put(key64, value64);
		map.put(key65, value65);
		map.put(key66, value66);
		map.put(key67, value67);
		map.put(key68, value68);
		map.put(key69, value69);
		map.put(key70, value70);
		map.put(key71, value71);
		map.put(key72, value72);
		map.put(key73, value73);
		map.put(key74, value74);
		map.put(key75, value75);
		map.put(key76, value76);
		map.put(key77, value77);
		map.put(key78, value78);
		map.put(key79, value79);
		map.put(key80, value80);
		map.put(key81, value81);
		map.put(key82, value82);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55,
		K key56,
		V value56,
		K key57,
		V value57,
		K key58,
		V value58,
		K key59,
		V value59,
		K key60,
		V value60,
		K key61,
		V value61,
		K key62,
		V value62,
		K key63,
		V value63,
		K key64,
		V value64,
		K key65,
		V value65,
		K key66,
		V value66,
		K key67,
		V value67,
		K key68,
		V value68,
		K key69,
		V value69,
		K key70,
		V value70,
		K key71,
		V value71,
		K key72,
		V value72,
		K key73,
		V value73,
		K key74,
		V value74,
		K key75,
		V value75,
		K key76,
		V value76,
		K key77,
		V value77,
		K key78,
		V value78,
		K key79,
		V value79,
		K key80,
		V value80,
		K key81,
		V value81,
		K key82,
		V value82,
		K key83,
		V value83
	) {
		var map = new HashMap<K, V>(87);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		map.put(key56, value56);
		map.put(key57, value57);
		map.put(key58, value58);
		map.put(key59, value59);
		map.put(key60, value60);
		map.put(key61, value61);
		map.put(key62, value62);
		map.put(key63, value63);
		map.put(key64, value64);
		map.put(key65, value65);
		map.put(key66, value66);
		map.put(key67, value67);
		map.put(key68, value68);
		map.put(key69, value69);
		map.put(key70, value70);
		map.put(key71, value71);
		map.put(key72, value72);
		map.put(key73, value73);
		map.put(key74, value74);
		map.put(key75, value75);
		map.put(key76, value76);
		map.put(key77, value77);
		map.put(key78, value78);
		map.put(key79, value79);
		map.put(key80, value80);
		map.put(key81, value81);
		map.put(key82, value82);
		map.put(key83, value83);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55,
		K key56,
		V value56,
		K key57,
		V value57,
		K key58,
		V value58,
		K key59,
		V value59,
		K key60,
		V value60,
		K key61,
		V value61,
		K key62,
		V value62,
		K key63,
		V value63,
		K key64,
		V value64,
		K key65,
		V value65,
		K key66,
		V value66,
		K key67,
		V value67,
		K key68,
		V value68,
		K key69,
		V value69,
		K key70,
		V value70,
		K key71,
		V value71,
		K key72,
		V value72,
		K key73,
		V value73,
		K key74,
		V value74,
		K key75,
		V value75,
		K key76,
		V value76,
		K key77,
		V value77,
		K key78,
		V value78,
		K key79,
		V value79,
		K key80,
		V value80,
		K key81,
		V value81,
		K key82,
		V value82,
		K key83,
		V value83,
		K key84,
		V value84
	) {
		var map = new HashMap<K, V>(88);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		map.put(key56, value56);
		map.put(key57, value57);
		map.put(key58, value58);
		map.put(key59, value59);
		map.put(key60, value60);
		map.put(key61, value61);
		map.put(key62, value62);
		map.put(key63, value63);
		map.put(key64, value64);
		map.put(key65, value65);
		map.put(key66, value66);
		map.put(key67, value67);
		map.put(key68, value68);
		map.put(key69, value69);
		map.put(key70, value70);
		map.put(key71, value71);
		map.put(key72, value72);
		map.put(key73, value73);
		map.put(key74, value74);
		map.put(key75, value75);
		map.put(key76, value76);
		map.put(key77, value77);
		map.put(key78, value78);
		map.put(key79, value79);
		map.put(key80, value80);
		map.put(key81, value81);
		map.put(key82, value82);
		map.put(key83, value83);
		map.put(key84, value84);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55,
		K key56,
		V value56,
		K key57,
		V value57,
		K key58,
		V value58,
		K key59,
		V value59,
		K key60,
		V value60,
		K key61,
		V value61,
		K key62,
		V value62,
		K key63,
		V value63,
		K key64,
		V value64,
		K key65,
		V value65,
		K key66,
		V value66,
		K key67,
		V value67,
		K key68,
		V value68,
		K key69,
		V value69,
		K key70,
		V value70,
		K key71,
		V value71,
		K key72,
		V value72,
		K key73,
		V value73,
		K key74,
		V value74,
		K key75,
		V value75,
		K key76,
		V value76,
		K key77,
		V value77,
		K key78,
		V value78,
		K key79,
		V value79,
		K key80,
		V value80,
		K key81,
		V value81,
		K key82,
		V value82,
		K key83,
		V value83,
		K key84,
		V value84,
		K key85,
		V value85
	) {
		var map = new HashMap<K, V>(89);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		map.put(key56, value56);
		map.put(key57, value57);
		map.put(key58, value58);
		map.put(key59, value59);
		map.put(key60, value60);
		map.put(key61, value61);
		map.put(key62, value62);
		map.put(key63, value63);
		map.put(key64, value64);
		map.put(key65, value65);
		map.put(key66, value66);
		map.put(key67, value67);
		map.put(key68, value68);
		map.put(key69, value69);
		map.put(key70, value70);
		map.put(key71, value71);
		map.put(key72, value72);
		map.put(key73, value73);
		map.put(key74, value74);
		map.put(key75, value75);
		map.put(key76, value76);
		map.put(key77, value77);
		map.put(key78, value78);
		map.put(key79, value79);
		map.put(key80, value80);
		map.put(key81, value81);
		map.put(key82, value82);
		map.put(key83, value83);
		map.put(key84, value84);
		map.put(key85, value85);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55,
		K key56,
		V value56,
		K key57,
		V value57,
		K key58,
		V value58,
		K key59,
		V value59,
		K key60,
		V value60,
		K key61,
		V value61,
		K key62,
		V value62,
		K key63,
		V value63,
		K key64,
		V value64,
		K key65,
		V value65,
		K key66,
		V value66,
		K key67,
		V value67,
		K key68,
		V value68,
		K key69,
		V value69,
		K key70,
		V value70,
		K key71,
		V value71,
		K key72,
		V value72,
		K key73,
		V value73,
		K key74,
		V value74,
		K key75,
		V value75,
		K key76,
		V value76,
		K key77,
		V value77,
		K key78,
		V value78,
		K key79,
		V value79,
		K key80,
		V value80,
		K key81,
		V value81,
		K key82,
		V value82,
		K key83,
		V value83,
		K key84,
		V value84,
		K key85,
		V value85,
		K key86,
		V value86
	) {
		var map = new HashMap<K, V>(90);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		map.put(key56, value56);
		map.put(key57, value57);
		map.put(key58, value58);
		map.put(key59, value59);
		map.put(key60, value60);
		map.put(key61, value61);
		map.put(key62, value62);
		map.put(key63, value63);
		map.put(key64, value64);
		map.put(key65, value65);
		map.put(key66, value66);
		map.put(key67, value67);
		map.put(key68, value68);
		map.put(key69, value69);
		map.put(key70, value70);
		map.put(key71, value71);
		map.put(key72, value72);
		map.put(key73, value73);
		map.put(key74, value74);
		map.put(key75, value75);
		map.put(key76, value76);
		map.put(key77, value77);
		map.put(key78, value78);
		map.put(key79, value79);
		map.put(key80, value80);
		map.put(key81, value81);
		map.put(key82, value82);
		map.put(key83, value83);
		map.put(key84, value84);
		map.put(key85, value85);
		map.put(key86, value86);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55,
		K key56,
		V value56,
		K key57,
		V value57,
		K key58,
		V value58,
		K key59,
		V value59,
		K key60,
		V value60,
		K key61,
		V value61,
		K key62,
		V value62,
		K key63,
		V value63,
		K key64,
		V value64,
		K key65,
		V value65,
		K key66,
		V value66,
		K key67,
		V value67,
		K key68,
		V value68,
		K key69,
		V value69,
		K key70,
		V value70,
		K key71,
		V value71,
		K key72,
		V value72,
		K key73,
		V value73,
		K key74,
		V value74,
		K key75,
		V value75,
		K key76,
		V value76,
		K key77,
		V value77,
		K key78,
		V value78,
		K key79,
		V value79,
		K key80,
		V value80,
		K key81,
		V value81,
		K key82,
		V value82,
		K key83,
		V value83,
		K key84,
		V value84,
		K key85,
		V value85,
		K key86,
		V value86,
		K key87,
		V value87
	) {
		var map = new HashMap<K, V>(91);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		map.put(key56, value56);
		map.put(key57, value57);
		map.put(key58, value58);
		map.put(key59, value59);
		map.put(key60, value60);
		map.put(key61, value61);
		map.put(key62, value62);
		map.put(key63, value63);
		map.put(key64, value64);
		map.put(key65, value65);
		map.put(key66, value66);
		map.put(key67, value67);
		map.put(key68, value68);
		map.put(key69, value69);
		map.put(key70, value70);
		map.put(key71, value71);
		map.put(key72, value72);
		map.put(key73, value73);
		map.put(key74, value74);
		map.put(key75, value75);
		map.put(key76, value76);
		map.put(key77, value77);
		map.put(key78, value78);
		map.put(key79, value79);
		map.put(key80, value80);
		map.put(key81, value81);
		map.put(key82, value82);
		map.put(key83, value83);
		map.put(key84, value84);
		map.put(key85, value85);
		map.put(key86, value86);
		map.put(key87, value87);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55,
		K key56,
		V value56,
		K key57,
		V value57,
		K key58,
		V value58,
		K key59,
		V value59,
		K key60,
		V value60,
		K key61,
		V value61,
		K key62,
		V value62,
		K key63,
		V value63,
		K key64,
		V value64,
		K key65,
		V value65,
		K key66,
		V value66,
		K key67,
		V value67,
		K key68,
		V value68,
		K key69,
		V value69,
		K key70,
		V value70,
		K key71,
		V value71,
		K key72,
		V value72,
		K key73,
		V value73,
		K key74,
		V value74,
		K key75,
		V value75,
		K key76,
		V value76,
		K key77,
		V value77,
		K key78,
		V value78,
		K key79,
		V value79,
		K key80,
		V value80,
		K key81,
		V value81,
		K key82,
		V value82,
		K key83,
		V value83,
		K key84,
		V value84,
		K key85,
		V value85,
		K key86,
		V value86,
		K key87,
		V value87,
		K key88,
		V value88
	) {
		var map = new HashMap<K, V>(92);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		map.put(key56, value56);
		map.put(key57, value57);
		map.put(key58, value58);
		map.put(key59, value59);
		map.put(key60, value60);
		map.put(key61, value61);
		map.put(key62, value62);
		map.put(key63, value63);
		map.put(key64, value64);
		map.put(key65, value65);
		map.put(key66, value66);
		map.put(key67, value67);
		map.put(key68, value68);
		map.put(key69, value69);
		map.put(key70, value70);
		map.put(key71, value71);
		map.put(key72, value72);
		map.put(key73, value73);
		map.put(key74, value74);
		map.put(key75, value75);
		map.put(key76, value76);
		map.put(key77, value77);
		map.put(key78, value78);
		map.put(key79, value79);
		map.put(key80, value80);
		map.put(key81, value81);
		map.put(key82, value82);
		map.put(key83, value83);
		map.put(key84, value84);
		map.put(key85, value85);
		map.put(key86, value86);
		map.put(key87, value87);
		map.put(key88, value88);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55,
		K key56,
		V value56,
		K key57,
		V value57,
		K key58,
		V value58,
		K key59,
		V value59,
		K key60,
		V value60,
		K key61,
		V value61,
		K key62,
		V value62,
		K key63,
		V value63,
		K key64,
		V value64,
		K key65,
		V value65,
		K key66,
		V value66,
		K key67,
		V value67,
		K key68,
		V value68,
		K key69,
		V value69,
		K key70,
		V value70,
		K key71,
		V value71,
		K key72,
		V value72,
		K key73,
		V value73,
		K key74,
		V value74,
		K key75,
		V value75,
		K key76,
		V value76,
		K key77,
		V value77,
		K key78,
		V value78,
		K key79,
		V value79,
		K key80,
		V value80,
		K key81,
		V value81,
		K key82,
		V value82,
		K key83,
		V value83,
		K key84,
		V value84,
		K key85,
		V value85,
		K key86,
		V value86,
		K key87,
		V value87,
		K key88,
		V value88,
		K key89,
		V value89
	) {
		var map = new HashMap<K, V>(93);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		map.put(key56, value56);
		map.put(key57, value57);
		map.put(key58, value58);
		map.put(key59, value59);
		map.put(key60, value60);
		map.put(key61, value61);
		map.put(key62, value62);
		map.put(key63, value63);
		map.put(key64, value64);
		map.put(key65, value65);
		map.put(key66, value66);
		map.put(key67, value67);
		map.put(key68, value68);
		map.put(key69, value69);
		map.put(key70, value70);
		map.put(key71, value71);
		map.put(key72, value72);
		map.put(key73, value73);
		map.put(key74, value74);
		map.put(key75, value75);
		map.put(key76, value76);
		map.put(key77, value77);
		map.put(key78, value78);
		map.put(key79, value79);
		map.put(key80, value80);
		map.put(key81, value81);
		map.put(key82, value82);
		map.put(key83, value83);
		map.put(key84, value84);
		map.put(key85, value85);
		map.put(key86, value86);
		map.put(key87, value87);
		map.put(key88, value88);
		map.put(key89, value89);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55,
		K key56,
		V value56,
		K key57,
		V value57,
		K key58,
		V value58,
		K key59,
		V value59,
		K key60,
		V value60,
		K key61,
		V value61,
		K key62,
		V value62,
		K key63,
		V value63,
		K key64,
		V value64,
		K key65,
		V value65,
		K key66,
		V value66,
		K key67,
		V value67,
		K key68,
		V value68,
		K key69,
		V value69,
		K key70,
		V value70,
		K key71,
		V value71,
		K key72,
		V value72,
		K key73,
		V value73,
		K key74,
		V value74,
		K key75,
		V value75,
		K key76,
		V value76,
		K key77,
		V value77,
		K key78,
		V value78,
		K key79,
		V value79,
		K key80,
		V value80,
		K key81,
		V value81,
		K key82,
		V value82,
		K key83,
		V value83,
		K key84,
		V value84,
		K key85,
		V value85,
		K key86,
		V value86,
		K key87,
		V value87,
		K key88,
		V value88,
		K key89,
		V value89,
		K key90,
		V value90
	) {
		var map = new HashMap<K, V>(94);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		map.put(key56, value56);
		map.put(key57, value57);
		map.put(key58, value58);
		map.put(key59, value59);
		map.put(key60, value60);
		map.put(key61, value61);
		map.put(key62, value62);
		map.put(key63, value63);
		map.put(key64, value64);
		map.put(key65, value65);
		map.put(key66, value66);
		map.put(key67, value67);
		map.put(key68, value68);
		map.put(key69, value69);
		map.put(key70, value70);
		map.put(key71, value71);
		map.put(key72, value72);
		map.put(key73, value73);
		map.put(key74, value74);
		map.put(key75, value75);
		map.put(key76, value76);
		map.put(key77, value77);
		map.put(key78, value78);
		map.put(key79, value79);
		map.put(key80, value80);
		map.put(key81, value81);
		map.put(key82, value82);
		map.put(key83, value83);
		map.put(key84, value84);
		map.put(key85, value85);
		map.put(key86, value86);
		map.put(key87, value87);
		map.put(key88, value88);
		map.put(key89, value89);
		map.put(key90, value90);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55,
		K key56,
		V value56,
		K key57,
		V value57,
		K key58,
		V value58,
		K key59,
		V value59,
		K key60,
		V value60,
		K key61,
		V value61,
		K key62,
		V value62,
		K key63,
		V value63,
		K key64,
		V value64,
		K key65,
		V value65,
		K key66,
		V value66,
		K key67,
		V value67,
		K key68,
		V value68,
		K key69,
		V value69,
		K key70,
		V value70,
		K key71,
		V value71,
		K key72,
		V value72,
		K key73,
		V value73,
		K key74,
		V value74,
		K key75,
		V value75,
		K key76,
		V value76,
		K key77,
		V value77,
		K key78,
		V value78,
		K key79,
		V value79,
		K key80,
		V value80,
		K key81,
		V value81,
		K key82,
		V value82,
		K key83,
		V value83,
		K key84,
		V value84,
		K key85,
		V value85,
		K key86,
		V value86,
		K key87,
		V value87,
		K key88,
		V value88,
		K key89,
		V value89,
		K key90,
		V value90,
		K key91,
		V value91
	) {
		var map = new HashMap<K, V>(95);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		map.put(key56, value56);
		map.put(key57, value57);
		map.put(key58, value58);
		map.put(key59, value59);
		map.put(key60, value60);
		map.put(key61, value61);
		map.put(key62, value62);
		map.put(key63, value63);
		map.put(key64, value64);
		map.put(key65, value65);
		map.put(key66, value66);
		map.put(key67, value67);
		map.put(key68, value68);
		map.put(key69, value69);
		map.put(key70, value70);
		map.put(key71, value71);
		map.put(key72, value72);
		map.put(key73, value73);
		map.put(key74, value74);
		map.put(key75, value75);
		map.put(key76, value76);
		map.put(key77, value77);
		map.put(key78, value78);
		map.put(key79, value79);
		map.put(key80, value80);
		map.put(key81, value81);
		map.put(key82, value82);
		map.put(key83, value83);
		map.put(key84, value84);
		map.put(key85, value85);
		map.put(key86, value86);
		map.put(key87, value87);
		map.put(key88, value88);
		map.put(key89, value89);
		map.put(key90, value90);
		map.put(key91, value91);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55,
		K key56,
		V value56,
		K key57,
		V value57,
		K key58,
		V value58,
		K key59,
		V value59,
		K key60,
		V value60,
		K key61,
		V value61,
		K key62,
		V value62,
		K key63,
		V value63,
		K key64,
		V value64,
		K key65,
		V value65,
		K key66,
		V value66,
		K key67,
		V value67,
		K key68,
		V value68,
		K key69,
		V value69,
		K key70,
		V value70,
		K key71,
		V value71,
		K key72,
		V value72,
		K key73,
		V value73,
		K key74,
		V value74,
		K key75,
		V value75,
		K key76,
		V value76,
		K key77,
		V value77,
		K key78,
		V value78,
		K key79,
		V value79,
		K key80,
		V value80,
		K key81,
		V value81,
		K key82,
		V value82,
		K key83,
		V value83,
		K key84,
		V value84,
		K key85,
		V value85,
		K key86,
		V value86,
		K key87,
		V value87,
		K key88,
		V value88,
		K key89,
		V value89,
		K key90,
		V value90,
		K key91,
		V value91,
		K key92,
		V value92
	) {
		var map = new HashMap<K, V>(96);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		map.put(key56, value56);
		map.put(key57, value57);
		map.put(key58, value58);
		map.put(key59, value59);
		map.put(key60, value60);
		map.put(key61, value61);
		map.put(key62, value62);
		map.put(key63, value63);
		map.put(key64, value64);
		map.put(key65, value65);
		map.put(key66, value66);
		map.put(key67, value67);
		map.put(key68, value68);
		map.put(key69, value69);
		map.put(key70, value70);
		map.put(key71, value71);
		map.put(key72, value72);
		map.put(key73, value73);
		map.put(key74, value74);
		map.put(key75, value75);
		map.put(key76, value76);
		map.put(key77, value77);
		map.put(key78, value78);
		map.put(key79, value79);
		map.put(key80, value80);
		map.put(key81, value81);
		map.put(key82, value82);
		map.put(key83, value83);
		map.put(key84, value84);
		map.put(key85, value85);
		map.put(key86, value86);
		map.put(key87, value87);
		map.put(key88, value88);
		map.put(key89, value89);
		map.put(key90, value90);
		map.put(key91, value91);
		map.put(key92, value92);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55,
		K key56,
		V value56,
		K key57,
		V value57,
		K key58,
		V value58,
		K key59,
		V value59,
		K key60,
		V value60,
		K key61,
		V value61,
		K key62,
		V value62,
		K key63,
		V value63,
		K key64,
		V value64,
		K key65,
		V value65,
		K key66,
		V value66,
		K key67,
		V value67,
		K key68,
		V value68,
		K key69,
		V value69,
		K key70,
		V value70,
		K key71,
		V value71,
		K key72,
		V value72,
		K key73,
		V value73,
		K key74,
		V value74,
		K key75,
		V value75,
		K key76,
		V value76,
		K key77,
		V value77,
		K key78,
		V value78,
		K key79,
		V value79,
		K key80,
		V value80,
		K key81,
		V value81,
		K key82,
		V value82,
		K key83,
		V value83,
		K key84,
		V value84,
		K key85,
		V value85,
		K key86,
		V value86,
		K key87,
		V value87,
		K key88,
		V value88,
		K key89,
		V value89,
		K key90,
		V value90,
		K key91,
		V value91,
		K key92,
		V value92,
		K key93,
		V value93
	) {
		var map = new HashMap<K, V>(97);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		map.put(key56, value56);
		map.put(key57, value57);
		map.put(key58, value58);
		map.put(key59, value59);
		map.put(key60, value60);
		map.put(key61, value61);
		map.put(key62, value62);
		map.put(key63, value63);
		map.put(key64, value64);
		map.put(key65, value65);
		map.put(key66, value66);
		map.put(key67, value67);
		map.put(key68, value68);
		map.put(key69, value69);
		map.put(key70, value70);
		map.put(key71, value71);
		map.put(key72, value72);
		map.put(key73, value73);
		map.put(key74, value74);
		map.put(key75, value75);
		map.put(key76, value76);
		map.put(key77, value77);
		map.put(key78, value78);
		map.put(key79, value79);
		map.put(key80, value80);
		map.put(key81, value81);
		map.put(key82, value82);
		map.put(key83, value83);
		map.put(key84, value84);
		map.put(key85, value85);
		map.put(key86, value86);
		map.put(key87, value87);
		map.put(key88, value88);
		map.put(key89, value89);
		map.put(key90, value90);
		map.put(key91, value91);
		map.put(key92, value92);
		map.put(key93, value93);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55,
		K key56,
		V value56,
		K key57,
		V value57,
		K key58,
		V value58,
		K key59,
		V value59,
		K key60,
		V value60,
		K key61,
		V value61,
		K key62,
		V value62,
		K key63,
		V value63,
		K key64,
		V value64,
		K key65,
		V value65,
		K key66,
		V value66,
		K key67,
		V value67,
		K key68,
		V value68,
		K key69,
		V value69,
		K key70,
		V value70,
		K key71,
		V value71,
		K key72,
		V value72,
		K key73,
		V value73,
		K key74,
		V value74,
		K key75,
		V value75,
		K key76,
		V value76,
		K key77,
		V value77,
		K key78,
		V value78,
		K key79,
		V value79,
		K key80,
		V value80,
		K key81,
		V value81,
		K key82,
		V value82,
		K key83,
		V value83,
		K key84,
		V value84,
		K key85,
		V value85,
		K key86,
		V value86,
		K key87,
		V value87,
		K key88,
		V value88,
		K key89,
		V value89,
		K key90,
		V value90,
		K key91,
		V value91,
		K key92,
		V value92,
		K key93,
		V value93,
		K key94,
		V value94
	) {
		var map = new HashMap<K, V>(98);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		map.put(key56, value56);
		map.put(key57, value57);
		map.put(key58, value58);
		map.put(key59, value59);
		map.put(key60, value60);
		map.put(key61, value61);
		map.put(key62, value62);
		map.put(key63, value63);
		map.put(key64, value64);
		map.put(key65, value65);
		map.put(key66, value66);
		map.put(key67, value67);
		map.put(key68, value68);
		map.put(key69, value69);
		map.put(key70, value70);
		map.put(key71, value71);
		map.put(key72, value72);
		map.put(key73, value73);
		map.put(key74, value74);
		map.put(key75, value75);
		map.put(key76, value76);
		map.put(key77, value77);
		map.put(key78, value78);
		map.put(key79, value79);
		map.put(key80, value80);
		map.put(key81, value81);
		map.put(key82, value82);
		map.put(key83, value83);
		map.put(key84, value84);
		map.put(key85, value85);
		map.put(key86, value86);
		map.put(key87, value87);
		map.put(key88, value88);
		map.put(key89, value89);
		map.put(key90, value90);
		map.put(key91, value91);
		map.put(key92, value92);
		map.put(key93, value93);
		map.put(key94, value94);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55,
		K key56,
		V value56,
		K key57,
		V value57,
		K key58,
		V value58,
		K key59,
		V value59,
		K key60,
		V value60,
		K key61,
		V value61,
		K key62,
		V value62,
		K key63,
		V value63,
		K key64,
		V value64,
		K key65,
		V value65,
		K key66,
		V value66,
		K key67,
		V value67,
		K key68,
		V value68,
		K key69,
		V value69,
		K key70,
		V value70,
		K key71,
		V value71,
		K key72,
		V value72,
		K key73,
		V value73,
		K key74,
		V value74,
		K key75,
		V value75,
		K key76,
		V value76,
		K key77,
		V value77,
		K key78,
		V value78,
		K key79,
		V value79,
		K key80,
		V value80,
		K key81,
		V value81,
		K key82,
		V value82,
		K key83,
		V value83,
		K key84,
		V value84,
		K key85,
		V value85,
		K key86,
		V value86,
		K key87,
		V value87,
		K key88,
		V value88,
		K key89,
		V value89,
		K key90,
		V value90,
		K key91,
		V value91,
		K key92,
		V value92,
		K key93,
		V value93,
		K key94,
		V value94,
		K key95,
		V value95
	) {
		var map = new HashMap<K, V>(99);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		map.put(key56, value56);
		map.put(key57, value57);
		map.put(key58, value58);
		map.put(key59, value59);
		map.put(key60, value60);
		map.put(key61, value61);
		map.put(key62, value62);
		map.put(key63, value63);
		map.put(key64, value64);
		map.put(key65, value65);
		map.put(key66, value66);
		map.put(key67, value67);
		map.put(key68, value68);
		map.put(key69, value69);
		map.put(key70, value70);
		map.put(key71, value71);
		map.put(key72, value72);
		map.put(key73, value73);
		map.put(key74, value74);
		map.put(key75, value75);
		map.put(key76, value76);
		map.put(key77, value77);
		map.put(key78, value78);
		map.put(key79, value79);
		map.put(key80, value80);
		map.put(key81, value81);
		map.put(key82, value82);
		map.put(key83, value83);
		map.put(key84, value84);
		map.put(key85, value85);
		map.put(key86, value86);
		map.put(key87, value87);
		map.put(key88, value88);
		map.put(key89, value89);
		map.put(key90, value90);
		map.put(key91, value91);
		map.put(key92, value92);
		map.put(key93, value93);
		map.put(key94, value94);
		map.put(key95, value95);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55,
		K key56,
		V value56,
		K key57,
		V value57,
		K key58,
		V value58,
		K key59,
		V value59,
		K key60,
		V value60,
		K key61,
		V value61,
		K key62,
		V value62,
		K key63,
		V value63,
		K key64,
		V value64,
		K key65,
		V value65,
		K key66,
		V value66,
		K key67,
		V value67,
		K key68,
		V value68,
		K key69,
		V value69,
		K key70,
		V value70,
		K key71,
		V value71,
		K key72,
		V value72,
		K key73,
		V value73,
		K key74,
		V value74,
		K key75,
		V value75,
		K key76,
		V value76,
		K key77,
		V value77,
		K key78,
		V value78,
		K key79,
		V value79,
		K key80,
		V value80,
		K key81,
		V value81,
		K key82,
		V value82,
		K key83,
		V value83,
		K key84,
		V value84,
		K key85,
		V value85,
		K key86,
		V value86,
		K key87,
		V value87,
		K key88,
		V value88,
		K key89,
		V value89,
		K key90,
		V value90,
		K key91,
		V value91,
		K key92,
		V value92,
		K key93,
		V value93,
		K key94,
		V value94,
		K key95,
		V value95,
		K key96,
		V value96
	) {
		var map = new HashMap<K, V>(100);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		map.put(key56, value56);
		map.put(key57, value57);
		map.put(key58, value58);
		map.put(key59, value59);
		map.put(key60, value60);
		map.put(key61, value61);
		map.put(key62, value62);
		map.put(key63, value63);
		map.put(key64, value64);
		map.put(key65, value65);
		map.put(key66, value66);
		map.put(key67, value67);
		map.put(key68, value68);
		map.put(key69, value69);
		map.put(key70, value70);
		map.put(key71, value71);
		map.put(key72, value72);
		map.put(key73, value73);
		map.put(key74, value74);
		map.put(key75, value75);
		map.put(key76, value76);
		map.put(key77, value77);
		map.put(key78, value78);
		map.put(key79, value79);
		map.put(key80, value80);
		map.put(key81, value81);
		map.put(key82, value82);
		map.put(key83, value83);
		map.put(key84, value84);
		map.put(key85, value85);
		map.put(key86, value86);
		map.put(key87, value87);
		map.put(key88, value88);
		map.put(key89, value89);
		map.put(key90, value90);
		map.put(key91, value91);
		map.put(key92, value92);
		map.put(key93, value93);
		map.put(key94, value94);
		map.put(key95, value95);
		map.put(key96, value96);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55,
		K key56,
		V value56,
		K key57,
		V value57,
		K key58,
		V value58,
		K key59,
		V value59,
		K key60,
		V value60,
		K key61,
		V value61,
		K key62,
		V value62,
		K key63,
		V value63,
		K key64,
		V value64,
		K key65,
		V value65,
		K key66,
		V value66,
		K key67,
		V value67,
		K key68,
		V value68,
		K key69,
		V value69,
		K key70,
		V value70,
		K key71,
		V value71,
		K key72,
		V value72,
		K key73,
		V value73,
		K key74,
		V value74,
		K key75,
		V value75,
		K key76,
		V value76,
		K key77,
		V value77,
		K key78,
		V value78,
		K key79,
		V value79,
		K key80,
		V value80,
		K key81,
		V value81,
		K key82,
		V value82,
		K key83,
		V value83,
		K key84,
		V value84,
		K key85,
		V value85,
		K key86,
		V value86,
		K key87,
		V value87,
		K key88,
		V value88,
		K key89,
		V value89,
		K key90,
		V value90,
		K key91,
		V value91,
		K key92,
		V value92,
		K key93,
		V value93,
		K key94,
		V value94,
		K key95,
		V value95,
		K key96,
		V value96,
		K key97,
		V value97
	) {
		var map = new HashMap<K, V>(101);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		map.put(key56, value56);
		map.put(key57, value57);
		map.put(key58, value58);
		map.put(key59, value59);
		map.put(key60, value60);
		map.put(key61, value61);
		map.put(key62, value62);
		map.put(key63, value63);
		map.put(key64, value64);
		map.put(key65, value65);
		map.put(key66, value66);
		map.put(key67, value67);
		map.put(key68, value68);
		map.put(key69, value69);
		map.put(key70, value70);
		map.put(key71, value71);
		map.put(key72, value72);
		map.put(key73, value73);
		map.put(key74, value74);
		map.put(key75, value75);
		map.put(key76, value76);
		map.put(key77, value77);
		map.put(key78, value78);
		map.put(key79, value79);
		map.put(key80, value80);
		map.put(key81, value81);
		map.put(key82, value82);
		map.put(key83, value83);
		map.put(key84, value84);
		map.put(key85, value85);
		map.put(key86, value86);
		map.put(key87, value87);
		map.put(key88, value88);
		map.put(key89, value89);
		map.put(key90, value90);
		map.put(key91, value91);
		map.put(key92, value92);
		map.put(key93, value93);
		map.put(key94, value94);
		map.put(key95, value95);
		map.put(key96, value96);
		map.put(key97, value97);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55,
		K key56,
		V value56,
		K key57,
		V value57,
		K key58,
		V value58,
		K key59,
		V value59,
		K key60,
		V value60,
		K key61,
		V value61,
		K key62,
		V value62,
		K key63,
		V value63,
		K key64,
		V value64,
		K key65,
		V value65,
		K key66,
		V value66,
		K key67,
		V value67,
		K key68,
		V value68,
		K key69,
		V value69,
		K key70,
		V value70,
		K key71,
		V value71,
		K key72,
		V value72,
		K key73,
		V value73,
		K key74,
		V value74,
		K key75,
		V value75,
		K key76,
		V value76,
		K key77,
		V value77,
		K key78,
		V value78,
		K key79,
		V value79,
		K key80,
		V value80,
		K key81,
		V value81,
		K key82,
		V value82,
		K key83,
		V value83,
		K key84,
		V value84,
		K key85,
		V value85,
		K key86,
		V value86,
		K key87,
		V value87,
		K key88,
		V value88,
		K key89,
		V value89,
		K key90,
		V value90,
		K key91,
		V value91,
		K key92,
		V value92,
		K key93,
		V value93,
		K key94,
		V value94,
		K key95,
		V value95,
		K key96,
		V value96,
		K key97,
		V value97,
		K key98,
		V value98
	) {
		var map = new HashMap<K, V>(102);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		map.put(key56, value56);
		map.put(key57, value57);
		map.put(key58, value58);
		map.put(key59, value59);
		map.put(key60, value60);
		map.put(key61, value61);
		map.put(key62, value62);
		map.put(key63, value63);
		map.put(key64, value64);
		map.put(key65, value65);
		map.put(key66, value66);
		map.put(key67, value67);
		map.put(key68, value68);
		map.put(key69, value69);
		map.put(key70, value70);
		map.put(key71, value71);
		map.put(key72, value72);
		map.put(key73, value73);
		map.put(key74, value74);
		map.put(key75, value75);
		map.put(key76, value76);
		map.put(key77, value77);
		map.put(key78, value78);
		map.put(key79, value79);
		map.put(key80, value80);
		map.put(key81, value81);
		map.put(key82, value82);
		map.put(key83, value83);
		map.put(key84, value84);
		map.put(key85, value85);
		map.put(key86, value86);
		map.put(key87, value87);
		map.put(key88, value88);
		map.put(key89, value89);
		map.put(key90, value90);
		map.put(key91, value91);
		map.put(key92, value92);
		map.put(key93, value93);
		map.put(key94, value94);
		map.put(key95, value95);
		map.put(key96, value96);
		map.put(key97, value97);
		map.put(key98, value98);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55,
		K key56,
		V value56,
		K key57,
		V value57,
		K key58,
		V value58,
		K key59,
		V value59,
		K key60,
		V value60,
		K key61,
		V value61,
		K key62,
		V value62,
		K key63,
		V value63,
		K key64,
		V value64,
		K key65,
		V value65,
		K key66,
		V value66,
		K key67,
		V value67,
		K key68,
		V value68,
		K key69,
		V value69,
		K key70,
		V value70,
		K key71,
		V value71,
		K key72,
		V value72,
		K key73,
		V value73,
		K key74,
		V value74,
		K key75,
		V value75,
		K key76,
		V value76,
		K key77,
		V value77,
		K key78,
		V value78,
		K key79,
		V value79,
		K key80,
		V value80,
		K key81,
		V value81,
		K key82,
		V value82,
		K key83,
		V value83,
		K key84,
		V value84,
		K key85,
		V value85,
		K key86,
		V value86,
		K key87,
		V value87,
		K key88,
		V value88,
		K key89,
		V value89,
		K key90,
		V value90,
		K key91,
		V value91,
		K key92,
		V value92,
		K key93,
		V value93,
		K key94,
		V value94,
		K key95,
		V value95,
		K key96,
		V value96,
		K key97,
		V value97,
		K key98,
		V value98,
		K key99,
		V value99
	) {
		var map = new HashMap<K, V>(103);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		map.put(key56, value56);
		map.put(key57, value57);
		map.put(key58, value58);
		map.put(key59, value59);
		map.put(key60, value60);
		map.put(key61, value61);
		map.put(key62, value62);
		map.put(key63, value63);
		map.put(key64, value64);
		map.put(key65, value65);
		map.put(key66, value66);
		map.put(key67, value67);
		map.put(key68, value68);
		map.put(key69, value69);
		map.put(key70, value70);
		map.put(key71, value71);
		map.put(key72, value72);
		map.put(key73, value73);
		map.put(key74, value74);
		map.put(key75, value75);
		map.put(key76, value76);
		map.put(key77, value77);
		map.put(key78, value78);
		map.put(key79, value79);
		map.put(key80, value80);
		map.put(key81, value81);
		map.put(key82, value82);
		map.put(key83, value83);
		map.put(key84, value84);
		map.put(key85, value85);
		map.put(key86, value86);
		map.put(key87, value87);
		map.put(key88, value88);
		map.put(key89, value89);
		map.put(key90, value90);
		map.put(key91, value91);
		map.put(key92, value92);
		map.put(key93, value93);
		map.put(key94, value94);
		map.put(key95, value95);
		map.put(key96, value96);
		map.put(key97, value97);
		map.put(key98, value98);
		map.put(key99, value99);
		return map;
	}

	public static <K, V> Map<K, V> of(
		K key,
		V value,
		K key2,
		V value2,
		K key3,
		V value3,
		K key4,
		V value4,
		K key5,
		V value5,
		K key6,
		V value6,
		K key7,
		V value7,
		K key8,
		V value8,
		K key9,
		V value9,
		K key10,
		V value10,
		K key11,
		V value11,
		K key12,
		V value12,
		K key13,
		V value13,
		K key14,
		V value14,
		K key15,
		V value15,
		K key16,
		V value16,
		K key17,
		V value17,
		K key18,
		V value18,
		K key19,
		V value19,
		K key20,
		V value20,
		K key21,
		V value21,
		K key22,
		V value22,
		K key23,
		V value23,
		K key24,
		V value24,
		K key25,
		V value25,
		K key26,
		V value26,
		K key27,
		V value27,
		K key28,
		V value28,
		K key29,
		V value29,
		K key30,
		V value30,
		K key31,
		V value31,
		K key32,
		V value32,
		K key33,
		V value33,
		K key34,
		V value34,
		K key35,
		V value35,
		K key36,
		V value36,
		K key37,
		V value37,
		K key38,
		V value38,
		K key39,
		V value39,
		K key40,
		V value40,
		K key41,
		V value41,
		K key42,
		V value42,
		K key43,
		V value43,
		K key44,
		V value44,
		K key45,
		V value45,
		K key46,
		V value46,
		K key47,
		V value47,
		K key48,
		V value48,
		K key49,
		V value49,
		K key50,
		V value50,
		K key51,
		V value51,
		K key52,
		V value52,
		K key53,
		V value53,
		K key54,
		V value54,
		K key55,
		V value55,
		K key56,
		V value56,
		K key57,
		V value57,
		K key58,
		V value58,
		K key59,
		V value59,
		K key60,
		V value60,
		K key61,
		V value61,
		K key62,
		V value62,
		K key63,
		V value63,
		K key64,
		V value64,
		K key65,
		V value65,
		K key66,
		V value66,
		K key67,
		V value67,
		K key68,
		V value68,
		K key69,
		V value69,
		K key70,
		V value70,
		K key71,
		V value71,
		K key72,
		V value72,
		K key73,
		V value73,
		K key74,
		V value74,
		K key75,
		V value75,
		K key76,
		V value76,
		K key77,
		V value77,
		K key78,
		V value78,
		K key79,
		V value79,
		K key80,
		V value80,
		K key81,
		V value81,
		K key82,
		V value82,
		K key83,
		V value83,
		K key84,
		V value84,
		K key85,
		V value85,
		K key86,
		V value86,
		K key87,
		V value87,
		K key88,
		V value88,
		K key89,
		V value89,
		K key90,
		V value90,
		K key91,
		V value91,
		K key92,
		V value92,
		K key93,
		V value93,
		K key94,
		V value94,
		K key95,
		V value95,
		K key96,
		V value96,
		K key97,
		V value97,
		K key98,
		V value98,
		K key99,
		V value99,
		K key100,
		V value100
	) {
		var map = new HashMap<K, V>(104);
		map.put(key, value);
		map.put(key2, value2);
		map.put(key3, value3);
		map.put(key4, value4);
		map.put(key5, value5);
		map.put(key6, value6);
		map.put(key7, value7);
		map.put(key8, value8);
		map.put(key9, value9);
		map.put(key10, value10);
		map.put(key11, value11);
		map.put(key12, value12);
		map.put(key13, value13);
		map.put(key14, value14);
		map.put(key15, value15);
		map.put(key16, value16);
		map.put(key17, value17);
		map.put(key18, value18);
		map.put(key19, value19);
		map.put(key20, value20);
		map.put(key21, value21);
		map.put(key22, value22);
		map.put(key23, value23);
		map.put(key24, value24);
		map.put(key25, value25);
		map.put(key26, value26);
		map.put(key27, value27);
		map.put(key28, value28);
		map.put(key29, value29);
		map.put(key30, value30);
		map.put(key31, value31);
		map.put(key32, value32);
		map.put(key33, value33);
		map.put(key34, value34);
		map.put(key35, value35);
		map.put(key36, value36);
		map.put(key37, value37);
		map.put(key38, value38);
		map.put(key39, value39);
		map.put(key40, value40);
		map.put(key41, value41);
		map.put(key42, value42);
		map.put(key43, value43);
		map.put(key44, value44);
		map.put(key45, value45);
		map.put(key46, value46);
		map.put(key47, value47);
		map.put(key48, value48);
		map.put(key49, value49);
		map.put(key50, value50);
		map.put(key51, value51);
		map.put(key52, value52);
		map.put(key53, value53);
		map.put(key54, value54);
		map.put(key55, value55);
		map.put(key56, value56);
		map.put(key57, value57);
		map.put(key58, value58);
		map.put(key59, value59);
		map.put(key60, value60);
		map.put(key61, value61);
		map.put(key62, value62);
		map.put(key63, value63);
		map.put(key64, value64);
		map.put(key65, value65);
		map.put(key66, value66);
		map.put(key67, value67);
		map.put(key68, value68);
		map.put(key69, value69);
		map.put(key70, value70);
		map.put(key71, value71);
		map.put(key72, value72);
		map.put(key73, value73);
		map.put(key74, value74);
		map.put(key75, value75);
		map.put(key76, value76);
		map.put(key77, value77);
		map.put(key78, value78);
		map.put(key79, value79);
		map.put(key80, value80);
		map.put(key81, value81);
		map.put(key82, value82);
		map.put(key83, value83);
		map.put(key84, value84);
		map.put(key85, value85);
		map.put(key86, value86);
		map.put(key87, value87);
		map.put(key88, value88);
		map.put(key89, value89);
		map.put(key90, value90);
		map.put(key91, value91);
		map.put(key92, value92);
		map.put(key93, value93);
		map.put(key94, value94);
		map.put(key95, value95);
		map.put(key96, value96);
		map.put(key97, value97);
		map.put(key98, value98);
		map.put(key99, value99);
		map.put(key100, value100);
		return map;
	}

	/**
	 * 使用Entry对象创建Map的替代方案
	 *
	 * @param entries Entry对象数组
	 * @param <K>     键的类型
	 * @param <V>     值的类型
	 * @return 包含指定键值对的HashMap实例
	 */
	public static <K, V> Map<K, V> ofEntries(Map.Entry<K, V>... entries) {
		var map = new HashMap<K, V>(entries.length + 2);
		for (Map.Entry<K, V> entry : entries) {
			map.put(entry.getKey(), entry.getValue());
		}
		return map;
	}

	public static <K, V> Map<K, V> ofEntries(List<Map.Entry<K, V>> entries) {
		var map = new HashMap<K, V>(entries.size() + 2);
		for (Map.Entry<K, V> entry : entries) {
			map.put(entry.getKey(), entry.getValue());
		}
		return map;
	}
}