From 49c3b76250c6b07ffb5c6b12035f15adc6af79ba Mon Sep 17 00:00:00 2001 From: minglipro Date: Fri, 5 Sep 2025 17:56:00 +0800 Subject: [PATCH] =?UTF-8?q?refactor(mingli-utils):=E9=87=8D=E6=9E=84?= =?UTF-8?q?=E5=B9=B6=E6=B7=BB=E5=8A=A0=E5=A4=9A=E4=B8=AA=E5=AE=9E=E7=94=A8?= =?UTF-8?q?=E5=B7=A5=E5=85=B7=E7=B1=BB-=20=E9=87=8D=E6=9E=84=20AutoConfigu?= =?UTF-8?q?ration=20=E7=B1=BB=EF=BC=8C=E4=BC=98=E5=8C=96=E5=90=AF=E5=8A=A8?= =?UTF-8?q?=E6=97=B6=E6=89=93=E5=8D=B0=E9=80=BB=E8=BE=91=20-=20=E6=96=B0?= =?UTF-8?q?=E5=A2=9E=20OsPath=20=E7=B1=BB=EF=BC=8C=E6=8F=90=E4=BE=9B?= =?UTF-8?q?=E8=B7=A8=E5=B9=B3=E5=8F=B0=E8=B7=AF=E5=BE=84=E6=93=8D=E4=BD=9C?= =?UTF-8?q?=E6=94=AF=E6=8C=81=20-=20=E6=96=B0=E5=A2=9E=20VersionUtils=20?= =?UTF-8?q?=E7=B1=BB=EF=BC=8C=E5=AE=9E=E7=8E=B0=E7=89=88=E6=9C=AC=E5=8F=B7?= =?UTF-8?q?=E6=AF=94=E8=BE=83=E5=8A=9F=E8=83=BD-=20=E6=96=B0=E5=A2=9E=20P1?= =?UTF-8?q?R1Function=20=E6=8E=A5=E5=8F=A3=EF=BC=8C=E7=AE=80=E5=8C=96?= =?UTF-8?q?=E5=87=BD=E6=95=B0=E5=BC=8F=E7=BC=96=E7=A8=8B=20-=20=E4=BC=98?= =?UTF-8?q?=E5=8C=96=20Base64Utils=E3=80=81Lists=E3=80=81NetWorkUtil?= =?UTF-8?q?=E3=80=81StringUtil=20=E5=92=8C=20SystemUtil=20=E7=B1=BB=20-=20?= =?UTF-8?q?=E6=9B=B4=E6=96=B0=E9=A1=B9=E7=9B=AE=E7=89=88=E6=9C=AC=E5=8F=B7?= =?UTF-8?q?=E8=87=B3=202.0.4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- gradle.properties | 2 +- .../mingliqiye/utils/base64/Base64Utils.java | 4 + .../utils/callback/P1R1Function.java | 23 + .../mingliqiye/utils/collection/Lists.java | 167 +- src/com/mingliqiye/utils/collection/Maps.java | 15769 ++++++++++++++++ .../utils/jna/time/WinKernel32.java | 3 + .../mingliqiye/utils/network/NetWorkUtil.java | 10 - src/com/mingliqiye/utils/path/OsPath.java | 194 + .../autoconfigure/AutoConfiguration.java | 13 +- .../mingliqiye/utils/string/StringUtil.java | 24 +- .../mingliqiye/utils/system/SystemUtil.java | 4 +- .../utils/version/VersionUtils.java | 80 + 12 files changed, 16252 insertions(+), 41 deletions(-) create mode 100644 src/com/mingliqiye/utils/callback/P1R1Function.java delete mode 100644 src/com/mingliqiye/utils/network/NetWorkUtil.java create mode 100644 src/com/mingliqiye/utils/path/OsPath.java create mode 100644 src/com/mingliqiye/utils/version/VersionUtils.java diff --git a/gradle.properties b/gradle.properties index 7ac874f..60efbdf 100644 --- a/gradle.properties +++ b/gradle.properties @@ -1,4 +1,4 @@ JDKVERSIONS=1.8 GROUPSID=com.mingliqiye.utils ARTIFACTID=mingli-utils -VERSIONS=2.0.0 +VERSIONS=2.0.4 diff --git a/src/com/mingliqiye/utils/base64/Base64Utils.java b/src/com/mingliqiye/utils/base64/Base64Utils.java index d6b47b7..2f0d5a0 100644 --- a/src/com/mingliqiye/utils/base64/Base64Utils.java +++ b/src/com/mingliqiye/utils/base64/Base64Utils.java @@ -169,4 +169,8 @@ public class Base64Utils { System.arraycopy(bytes, offset, data, 0, length); return encode(data); } + + public static String encodeBytes(byte[] bytes) { + return encodeBytes(bytes, 0, bytes.length); + } } diff --git a/src/com/mingliqiye/utils/callback/P1R1Function.java b/src/com/mingliqiye/utils/callback/P1R1Function.java new file mode 100644 index 0000000..1a5dd0a --- /dev/null +++ b/src/com/mingliqiye/utils/callback/P1R1Function.java @@ -0,0 +1,23 @@ +package com.mingliqiye.utils.callback; + +/** + * PRFunction接口表示一个接收参数P并返回结果R的函数式接口 + *

+ * 该接口使用@，表明它是一个函数式接口， + * 只包含一个抽象方法FunctionalInterface注解标记call，可用于Lambda表达式和方法引用 + *

+ * + * @author MingLiPro + * @param

函数接收的参数类型 + * @param 函数返回的结果类型 + */ +@FunctionalInterface +public interface P1R1Function { + /** + * 执行函数调用 + * + * @param p 输入参数 + * @return 函数执行结果 + */ + R call(P p); +} diff --git a/src/com/mingliqiye/utils/collection/Lists.java b/src/com/mingliqiye/utils/collection/Lists.java index 0968218..23b182e 100644 --- a/src/com/mingliqiye/utils/collection/Lists.java +++ b/src/com/mingliqiye/utils/collection/Lists.java @@ -1,9 +1,10 @@ package com.mingliqiye.utils.collection; -import java.util.*; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import java.util.*; + /** * Lists工具类提供了一系列创建List实现的便捷方法。 * @@ -247,6 +248,13 @@ public class Lists { return newList.toArray(new String[0]); } + /** + * 将列表转换为数组 + * + * @param ts 要转换的列表 + * @param 数组元素的类型 + * @return 包含列表中所有元素的数组，如果列表为null则返回null + */ @Nullable public static T[] toArray(List ts) { if (ts == null) { @@ -258,4 +266,161 @@ public class Lists { }); return items; } + + /** + * 将数组转换为列表 + * + * @param ts 要转换的数组 + * @param 列表元素的类型 + * @return 包含数组中所有元素的列表，如果数组为null则返回null + */ + // 原始的方法 - 用于引用类型 + @Nullable + public static List toList(T[] ts) { + return ts == null ? null : new ArrayList<>(Arrays.asList(ts)); + } + + /** + * 将int数组转换为Integer列表 + * + * @param array 要转换的int数组 + * @return 包含数组中所有元素的Integer列表，如果数组为null则返回null + */ + @Nullable + public static List toList(int[] array) { + if (array == null) { + return null; + } + List list = new ArrayList<>(array.length); + for (int value : array) { + list.add(value); + } + return list; + } + + /** + * 将long数组转换为Long列表 + * + * @param array 要转换的long数组 + * @return 包含数组中所有元素的Long列表，如果数组为null则返回null + */ + @Nullable + public static List toList(long[] array) { + if (array == null) { + return null; + } + List list = new ArrayList<>(array.length); + for (long value : array) { + list.add(value); + } + return list; + } + + /** + * 将double数组转换为Double列表 + * + * @param array 要转换的double数组 + * @return 包含数组中所有元素的Double列表，如果数组为null则返回null + */ + @Nullable + public static List toList(double[] array) { + if (array == null) { + return null; + } + List list = new ArrayList<>(array.length); + for (double value : array) { + list.add(value); + } + return list; + } + + /** + * 将float数组转换为Float列表 + * + * @param array 要转换的float数组 + * @return 包含数组中所有元素的Float列表，如果数组为null则返回null + */ + @Nullable + public static List toList(float[] array) { + if (array == null) { + return null; + } + List list = new ArrayList<>(array.length); + for (float value : array) { + list.add(value); + } + return list; + } + + /** + * 将boolean数组转换为Boolean列表 + * + * @param array 要转换的boolean数组 + * @return 包含数组中所有元素的Boolean列表，如果数组为null则返回null + */ + @Nullable + public static List toList(boolean[] array) { + if (array == null) { + return null; + } + List list = new ArrayList<>(array.length); + for (boolean value : array) { + list.add(value); + } + return list; + } + + /** + * 将char数组转换为Character列表 + * + * @param array 要转换的char数组 + * @return 包含数组中所有元素的Character列表，如果数组为null则返回null + */ + @Nullable + public static List toList(char[] array) { + if (array == null) { + return null; + } + List list = new ArrayList<>(array.length); + for (char value : array) { + list.add(value); + } + return list; + } + + /** + * 将byte数组转换为Byte列表 + * + * @param array 要转换的byte数组 + * @return 包含数组中所有元素的Byte列表，如果数组为null则返回null + */ + @Nullable + public static List toList(byte[] array) { + if (array == null) { + return null; + } + List list = new ArrayList<>(array.length); + for (byte value : array) { + list.add(value); + } + return list; + } + + /** + * 将short数组转换为Short列表 + * + * @param array 要转换的short数组 + * @return 包含数组中所有元素的Short列表，如果数组为null则返回null + */ + @Nullable + public static List toList(short[] array) { + if (array == null) { + return null; + } + List list = new ArrayList<>(array.length); + for (short value : array) { + list.add(value); + } + return list; + } } diff --git a/src/com/mingliqiye/utils/collection/Maps.java b/src/com/mingliqiye/utils/collection/Maps.java index 3342c6b..29db9c1 100644 --- a/src/com/mingliqiye/utils/collection/Maps.java +++ b/src/com/mingliqiye/utils/collection/Maps.java @@ -1,5 +1,7 @@ package com.mingliqiye.utils.collection; +import lombok.var; + import java.util.*; import java.util.concurrent.ConcurrentHashMap; @@ -184,4 +186,15771 @@ public class Maps { newMap.putAll(map); return newMap; } + + /** + * 创建一个包含单个键值对的HashMap实例。 + * + * @param key 键 + * @param value 值 + * @param 键的类型 + * @param 值的类型 + * @return 包含指定键值对的HashMap实例 + */ + public static Map of(K key, V value) { + var map = new HashMap(5); + map.put(key, value); + return map; + } + + public static Map of(K key, V value, K key2, V value2) { + var map = new HashMap(6); + map.put(key, value); + map.put(key2, value2); + return map; + } + + public static Map of( + K key, + V value, + K key2, + V value2, + K key3, + V value3 + ) { + var map = new HashMap(7); + map.put(key, value); + map.put(key2, value2); + map.put(key3, value3); + return map; + } + + public static Map of( + K key, + V value, + K key2, + V value2, + K key3, + V value3, + K key4, + V value4 + ) { + var map = new HashMap(8); + map.put(key, value); + map.put(key2, value2); + map.put(key3, value3); + map.put(key4, value4); + return map; + } + + public static Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 Map 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(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 键的类型 + * @param 值的类型 + * @return 包含指定键值对的HashMap实例 + */ + public static Map ofEntries(Map.Entry... entries) { + var map = new HashMap(entries.length + 2); + for (Map.Entry entry : entries) { + map.put(entry.getKey(), entry.getValue()); + } + return map; + } } diff --git a/src/com/mingliqiye/utils/jna/time/WinKernel32.java b/src/com/mingliqiye/utils/jna/time/WinKernel32.java index b20de88..ab9a63a 100644 --- a/src/com/mingliqiye/utils/jna/time/WinKernel32.java +++ b/src/com/mingliqiye/utils/jna/time/WinKernel32.java @@ -4,6 +4,9 @@ import com.sun.jna.Library; import com.sun.jna.Native; import com.sun.jna.ptr.LongByReference; +/** + * @author MingLiPro + */ public interface WinKernel32 extends Library { static WinKernel32 load() { return Native.load("kernel32", WinKernel32.class); diff --git a/src/com/mingliqiye/utils/network/NetWorkUtil.java b/src/com/mingliqiye/utils/network/NetWorkUtil.java deleted file mode 100644 index 61534e0..0000000 --- a/src/com/mingliqiye/utils/network/NetWorkUtil.java +++ /dev/null @@ -1,10 +0,0 @@ -package com.mingliqiye.utils.network; - -public class NetWorkUtil { - - public static void main(String[] args) { - System.out.println(NetworkEndpoint.of("127.0.0.1", 25565)); - System.out.println(NetworkEndpoint.of("127.0.0.1:25565")); - System.out.println(NetworkEndpoint.of("127.0.0.1:25565")); - } -} diff --git a/src/com/mingliqiye/utils/path/OsPath.java b/src/com/mingliqiye/utils/path/OsPath.java new file mode 100644 index 0000000..0a2c020 --- /dev/null +++ b/src/com/mingliqiye/utils/path/OsPath.java @@ -0,0 +1,194 @@ +package com.mingliqiye.utils.path; + +import java.io.File; +import java.io.IOException; +import java.net.URI; +import java.nio.file.*; +import java.util.Iterator; +import java.util.Spliterator; +import java.util.function.Consumer; +import org.jetbrains.annotations.NotNull; + +public class OsPath implements Path { + + private final Path path; + + private OsPath(Path path) { + this.path = path; + } + + public static OsPath of(String path) { + return of(Paths.get(path)); + } + + public static OsPath of(Path path) { + return new OsPath(path); + } + + @Override + public @NotNull FileSystem getFileSystem() { + return path.getFileSystem(); + } + + @Override + public boolean isAbsolute() { + return path.isAbsolute(); + } + + @Override + public Path getRoot() { + return path.getRoot(); + } + + @Override + public Path getFileName() { + return path.getFileName(); + } + + @Override + public Path getParent() { + Path a = path.getParent(); + if (a == null) { + a = path.toAbsolutePath().getParent(); + } + return a; + } + + @Override + public int getNameCount() { + return path.getNameCount(); + } + + @Override + public @NotNull Path getName(int index) { + return path.getName(index); + } + + @Override + public @NotNull Path subpath(int beginIndex, int endIndex) { + return path.subpath(beginIndex, endIndex); + } + + @Override + public boolean startsWith(@NotNull Path other) { + return path.startsWith(other); + } + + @Override + public boolean startsWith(@NotNull String other) { + return path.startsWith(other); + } + + @Override + public boolean endsWith(@NotNull Path other) { + return path.endsWith(other); + } + + @Override + public boolean endsWith(@NotNull String other) { + return path.endsWith(other); + } + + @Override + public @NotNull Path normalize() { + return path.normalize(); + } + + @Override + public @NotNull Path resolve(@NotNull Path other) { + return path.resolve(other); + } + + @Override + public @NotNull Path resolve(@NotNull String other) { + return path.resolve(other); + } + + @Override + public @NotNull Path resolveSibling(@NotNull Path other) { + return path.resolveSibling(other); + } + + @Override + public @NotNull Path resolveSibling(@NotNull String other) { + return path.resolveSibling(other); + } + + @Override + public @NotNull Path relativize(@NotNull Path other) { + return path.relativize(other); + } + + @Override + public @NotNull URI toUri() { + return path.toUri(); + } + + @Override + public @NotNull Path toAbsolutePath() { + return path.toAbsolutePath(); + } + + @Override + public @NotNull Path toRealPath(@NotNull LinkOption... options) + throws IOException { + return path.toRealPath(options); + } + + @Override + public @NotNull File toFile() { + return path.toFile(); + } + + @Override + public @NotNull WatchKey register( + @NotNull WatchService watcher, + WatchEvent.@NotNull Kind[] events, + @NotNull WatchEvent.Modifier... modifiers + ) throws IOException { + return path.register(watcher, events, modifiers); + } + + @Override + public @NotNull WatchKey register( + @NotNull WatchService watcher, + WatchEvent.@NotNull Kind... events + ) throws IOException { + return path.register(watcher, events); + } + + @Override + public @NotNull Iterator<@NotNull Path> iterator() { + return path.iterator(); + } + + @Override + public int compareTo(@NotNull Path other) { + return path.compareTo(other); + } + + @Override + public boolean equals(Object other) { + return path.equals(other); + } + + @Override + public int hashCode() { + return path.hashCode(); + } + + @Override + public @NotNull String toString() { + return path.toString(); + } + + @Override + public void forEach(Consumer action) { + path.forEach(action); + } + + @Override + public Spliterator spliterator() { + return path.spliterator(); + } +} diff --git a/src/com/mingliqiye/utils/springboot/autoconfigure/AutoConfiguration.java b/src/com/mingliqiye/utils/springboot/autoconfigure/AutoConfiguration.java index 8416024..f76a04b 100644 --- a/src/com/mingliqiye/utils/springboot/autoconfigure/AutoConfiguration.java +++ b/src/com/mingliqiye/utils/springboot/autoconfigure/AutoConfiguration.java @@ -10,7 +10,6 @@ import org.springframework.boot.context.properties.EnableConfigurationProperties import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.Configuration; -import javax.annotation.PostConstruct; import java.io.IOException; import java.io.InputStream; @@ -23,7 +22,7 @@ import java.io.InputStream; @ComponentScan({ SpringBeanUtil.PACKAGE_NAME }) public class AutoConfiguration { - private static String banner = + private static final String banner = "---------------------------------------------------------\n" + "| $$\\ $$\\ $$\\ $$\\ $$\\ $$$$$$$$\\ $$$$$$\\ |\n" + "| $$$\\ $$$ |$$ | $$ | $$ |\\__$$ __|$$ __$$\\ |\n" + @@ -33,6 +32,7 @@ public class AutoConfiguration { "| $$ |\\$ /$$ |$$ | $$ | $$ | $$ | $$\\ $$ | |\n" + "| $$ | \\_/ $$ |$$$$$$$$\\\\$$$$$$ | $$ | \\$$$$$$ | |\n" + "| \\__| \\__|\\________|\\______/ \\__| \\______/ |\n"; + private static String banner2; private boolean isloadObjMapper; public AutoConfiguration() throws IOException { @@ -48,9 +48,9 @@ public class AutoConfiguration { "Jackson ObjectMapper not found in classpath. Jackson serialization features will be disabled." ); } + init(); } - @PostConstruct public void init() { if (isloadObjMapper) { log.info("init ObjectMapper"); @@ -66,6 +66,7 @@ public class AutoConfiguration { } public void print() throws IOException { + banner2 = banner; InputStream inputStream = AutoConfiguration.class.getResourceAsStream( "/META-INF/meta-data" ); @@ -87,14 +88,14 @@ public class AutoConfiguration { for (int ia = 0; ia < spacesNeeded; ia++) { da.append(" "); } - banner += da + "|\n"; + banner2 += da + "|\n"; } else { - banner += content.substring(0, targetLength) + "|\n"; + banner2 += content.substring(0, targetLength) + "|\n"; } } }); System.out.printf( - banner, + banner2, DateTime.now().format(Formatter.STANDARD_DATETIME_MILLISECOUND7) ); System.out.println( diff --git a/src/com/mingliqiye/utils/string/StringUtil.java b/src/com/mingliqiye/utils/string/StringUtil.java index c9744ab..e4e4e22 100644 --- a/src/com/mingliqiye/utils/string/StringUtil.java +++ b/src/com/mingliqiye/utils/string/StringUtil.java @@ -1,5 +1,6 @@ package com.mingliqiye.utils.string; +import com.mingliqiye.utils.callback.P1R1Function; import com.mingliqiye.utils.collection.Lists; import java.text.MessageFormat; import java.util.ArrayList; @@ -136,7 +137,7 @@ public class StringUtil { public static

String join( String separator, List

list, - PRFunction fun + P1R1Function fun ) { // 处理空列表情况 if (list == null || list.isEmpty()) { @@ -189,25 +190,4 @@ public class StringUtil { public static StringBuilder stringBuilder(int i) { return new StringBuilder(i); } - - /** - * PRFunction接口表示一个接收参数P并返回结果R的函数式接口 - *

- * 该接口使用@FunctionalInterface注解标记，表明它是一个函数式接口， - * 只包含一个抽象方法call，可用于Lambda表达式和方法引用 - *

- * - * @param

函数接收的参数类型 - * @param 函数返回的结果类型 - */ - @FunctionalInterface - public interface PRFunction { - /** - * 执行函数调用 - * - * @param p 输入参数 - * @return 函数执行结果 - */ - R call(P p); - } } diff --git a/src/com/mingliqiye/utils/system/SystemUtil.java b/src/com/mingliqiye/utils/system/SystemUtil.java index f3a70bf..61ae4d9 100644 --- a/src/com/mingliqiye/utils/system/SystemUtil.java +++ b/src/com/mingliqiye/utils/system/SystemUtil.java @@ -50,7 +50,9 @@ public class SystemUtil { return ( osName.startsWith("Linux") || osName.startsWith("AIX") || - osName.startsWith("SunOS") + osName.startsWith("SunOS") || + osName.startsWith("Mac OS X") || + osName.startsWith("FreeBSD") ); } diff --git a/src/com/mingliqiye/utils/version/VersionUtils.java b/src/com/mingliqiye/utils/version/VersionUtils.java new file mode 100644 index 0000000..fefa0dc --- /dev/null +++ b/src/com/mingliqiye/utils/version/VersionUtils.java @@ -0,0 +1,80 @@ +package com.mingliqiye.utils.version; + +import java.util.Objects; + +/** + * 版本工具类，提供版本比较相关的方法 + */ +public class VersionUtils { + + /** + * 判断当前版本是否比另一个版本新 + * + * @param now 当前版本号字符串，格式如"1.0.0" + * @param other 要比较的版本号字符串，格式如"2.0.0" + * @return 如果当前版本更新则返回true，否则返回false + */ + public static boolean isNew(String now, String other) { + String[] currentParts = now.split("\\."); + String[] minimumParts = other.split("\\."); + + for ( + int i = 0; + i < Math.max(currentParts.length, minimumParts.length); + i++ + ) { + int currentNum = i < currentParts.length + ? Integer.parseInt(currentParts[i]) + : 0; + int minimumNum = i < minimumParts.length + ? Integer.parseInt(minimumParts[i]) + : 0; + + if (currentNum < minimumNum) { + return true; + } else if (currentNum > minimumNum) { + return false; + } + } + return false; + } + + /** + * 判断当前版本是否比另一个版本旧 + * + * @param now 当前版本号字符串，格式如"1.0.0" + * @param other 要比较的版本号字符串，格式如"2.0.0" + * @return 如果当前版本更旧则返回true，否则返回false + */ + public static boolean isOld(String now, String other) { + return !equals(now, other) && !isNew(now, other); + } + + /** + * 判断两个版本号是否相等 + * + * @param now 当前版本号字符串，格式如"1.0.0" + * @param other 要比较的版本号字符串，格式如"2.0.0" + * @return 如果两个版本号相等则返回true，否则返回false + */ + public static boolean equals(String now, String other) { + return Objects.equals(now, other); + } + + /** + * 比较两个版本号的大小关系 + * + * @param now 当前版本号字符串，格式如"1.0.0" + * @param other 要比较的版本号字符串，格式如"2.0.0" + * @return 如果当前版本更新返回2，如果更旧返回0，如果相等返回1 + */ + public static byte is(String now, String other) { + if (isNew(now, other)) { + return 2; + } else if (isOld(now, other)) { + return 0; + } else { + return 1; + } + } +}