diff --git a/build.gradle.kts b/build.gradle.kts index 111798f..59cb4e5 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -16,7 +16,7 @@ * ProjectName mingli-utils * ModuleName mingli-utils * CurrentFile build.gradle.kts - * LastUpdate 2026-03-12 10:29:17 + * LastUpdate 2026-06-20 21:49:36 * UpdateUser MingLiPro */ @@ -59,6 +59,7 @@ kotlin { dependencies { implementation("org.slf4j:slf4j-api:2.0.17") implementation(kotlin("reflect")) + api("com.mingliqiye.utils.aliasfor:alias-for:1.0.1") compileOnly("org.mindrot:jbcrypt:0.4") compileOnly("com.squareup.okhttp3:okhttp:5.3.2") compileOnly("com.fasterxml.jackson.core:jackson-databind:2.21.0") @@ -69,17 +70,25 @@ dependencies { compileOnly(fileTree("libs")) compileOnly("com.google.code.gson:gson:2.13.2") compileOnly("org.mybatis:mybatis:3.5.19") - compileOnly("io.netty:netty-all:4.1.130.Final") + compileOnly("io.netty:netty-all:4.2.15.Final") compileOnly("com.baomidou:mybatis-plus-core:3.5.15") compileOnly("net.java.dev.jna:jna:5.17.0") compileOnly("org.springdoc:springdoc-openapi-starter-webmvc-ui:2.8.8") compileOnly("com.baomidou:mybatis-plus-extension:3.5.15") testImplementation("org.junit.jupiter:junit-jupiter:5.7.1") testRuntimeOnly("org.junit.platform:junit-platform-launcher") - testImplementation("com.mingliqiye.logger:logger-log4j2:1.0.5") + testImplementation("com.mingliqiye.logger:logger-log4j2:1.0.9") testImplementation("com.google.code.gson:gson:2.13.2") + testImplementation("com.fasterxml.jackson.core:jackson-databind:2.21.0") testImplementation("com.fasterxml.jackson.module:jackson-module-kotlin:2.21.0") + + testImplementation("tools.jackson.module:jackson-module-kotlin:3.1.0") + testImplementation("tools.jackson.core:jackson-databind:3.1.0") +} + +repositories { + mavenLocal() } @@ -154,11 +163,11 @@ tasks.register("kotlinDocJar") { publishing { repositories { maven { - name = "MavenRepositoryRaw" - url = uri("https://localhost:3000/") + name = "mingliqiye" + url = uri("https://repository.mingliqiye.com/repository/maven") credentials { - username = System.getenv("sonatype.username") - password = System.getenv("sonatype.password") + username = System.getenv("mingliqiye.username") + password = System.getenv("mingliqiye.password") } } } @@ -221,6 +230,7 @@ tasks.processResources { signing { val secretKeyRingFile = System.getenv("SIGNING_SECRET_KEY_RING_FILE") val keyId = System.getenv("SIGNING_KEY_ID") + useGpgCmd() project.ext.set("signing.secretKeyRingFile", secretKeyRingFile) project.ext.set("signing.keyId", keyId) project.ext.set("signing.password", "") diff --git a/gradle.properties b/gradle.properties index cf8b229..595c789 100644 --- a/gradle.properties +++ b/gradle.properties @@ -16,10 +16,10 @@ # ProjectName mingli-utils # ModuleName mingli-utils # CurrentFile gradle.properties -# LastUpdate 2026-03-12 10:34:01 +# LastUpdate 2026-06-21 10:39:07 # UpdateUser MingLiPro # JDKVERSIONS=17 GROUPSID=com.mingliqiye.utils ARTIFACTID=mingli-utils -VERSIONS=5.0.9 +VERSIONS=5.2.6 diff --git a/src/main/java/com/mingliqiye/utils/json/Jackson3ApiJavaHelper.java b/src/main/java/com/mingliqiye/utils/json/api/Jackson3ApiJavaHelper.java similarity index 89% rename from src/main/java/com/mingliqiye/utils/json/Jackson3ApiJavaHelper.java rename to src/main/java/com/mingliqiye/utils/json/api/Jackson3ApiJavaHelper.java index ebb260f..086cfb1 100644 --- a/src/main/java/com/mingliqiye/utils/json/Jackson3ApiJavaHelper.java +++ b/src/main/java/com/mingliqiye/utils/json/api/Jackson3ApiJavaHelper.java @@ -16,16 +16,18 @@ * ProjectName mingli-utils * ModuleName mingli-utils.main * CurrentFile Jackson3ApiJavaHelper.java - * LastUpdate 2026-02-26 12:02:13 + * LastUpdate 2026-03-18 08:32:31 * UpdateUser MingLiPro */ -package com.mingliqiye.utils.json; +package com.mingliqiye.utils.json.api; import tools.jackson.databind.ObjectMapper; import tools.jackson.databind.cfg.MapperBuilder; + public class Jackson3ApiJavaHelper { + @SuppressWarnings("rawtypes") static MapperBuilder rebuild(ObjectMapper objectMapper) { return objectMapper.rebuild(); } diff --git a/src/main/java/com/mingliqiye/utils/stream/SuperStream.java b/src/main/java/com/mingliqiye/utils/stream/SuperStream.java index 3b440a5..c3ac4ed 100644 --- a/src/main/java/com/mingliqiye/utils/stream/SuperStream.java +++ b/src/main/java/com/mingliqiye/utils/stream/SuperStream.java @@ -16,7 +16,7 @@ * ProjectName mingli-utils * ModuleName mingli-utils.main * CurrentFile SuperStream.java - * LastUpdate 2026-01-20 13:27:09 + * LastUpdate 2026-04-14 12:00:05 * UpdateUser MingLiPro */ @@ -696,7 +696,7 @@ public class SuperStream implements Stream { * @param 输入元素的类型 * @return 产生List的收集器 */ - public static Collector> toList() { + public static Collector> toListCollector() { return Collectors.toList(); } @@ -1219,7 +1219,7 @@ public class SuperStream implements Stream { * @return 包含流中所有元素的List */ public List toAList() { - return collect(toList()); + return collect(toListCollector()); } } diff --git a/src/main/kotlin/com/mingliqiye/utils/buffer/ByteBufferWrapper.kt b/src/main/kotlin/com/mingliqiye/utils/buffer/ByteBufferWrapper.kt new file mode 100644 index 0000000..c9d768f --- /dev/null +++ b/src/main/kotlin/com/mingliqiye/utils/buffer/ByteBufferWrapper.kt @@ -0,0 +1,1320 @@ +/* + * Copyright 2026 mingliqiye + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * ProjectName mingli-utils + * ModuleName mingli-utils.main + * CurrentFile ByteBufferWrapper.kt + * LastUpdate 2026-06-21 10:37:47 + * UpdateUser MingLiPro + */ + +package com.mingliqiye.utils.buffer + +import com.mingliqiye.utils.buffer.convertor.ByteBufferWrapperConvertor +import com.mingliqiye.utils.bytes.* +import com.mingliqiye.utils.netty.toByteBuffer +import com.mingliqiye.utils.time.DateTime +import com.mingliqiye.utils.time.DateTime.Companion.toDateTime +import com.mingliqiye.utils.uuid.UUID +import com.mingliqiye.utils.uuid.UUID.Companion.toMLUUID +import io.netty.buffer.ByteBuf +import java.math.BigDecimal +import java.math.BigInteger +import java.nio.ByteBuffer +import java.nio.ByteOrder +import java.nio.charset.Charset +import java.time.Instant +import java.time.LocalDateTime +import java.time.ZoneId +import java.util.* +import java.util.concurrent.ConcurrentHashMap + +/** + * ByteBuffer 包装器 + * + * 提供对 java.nio.ByteBuffer 的完整封装,支持链式调用和丰富的数据类型读写。 + * 包含基础类型、大数、时间、UUID 等多种数据类型的读写方法。 + * 100000 iterations took 52ms + * + * 使用示例: + * ``` + * // 写入数据 + * val wrapper = ByteBufferWrapper.allocate(1024) + * .putInt(100) + * .putString("Hello") + * .putUUID(UUID.randomUUID()) + * .flip() // 切换到读模式 + * + * // 读取数据 + * val intValue = wrapper.getInt() + * val strValue = wrapper.getString() + * val uuidValue = wrapper.getUUID() + * ``` + * + * @param buffer 底层的 ByteBuffer 实例(私有构造,通过工厂方法创建) + */ +class ByteBufferWrapper private constructor(private val buffer: ByteBuffer) { + /** + * 缓冲区容量(总大小) + */ + @get:JvmName("capacity") + val capacity: Int get() = buffer.capacity() + + /** + * 当前位置(读写位置) + */ + @get:JvmName("position") + val position: Int get() = buffer.position() + + /** + * 剩余可读写字节数 + */ + @get:JvmName("remaining") + val remaining: Int get() = buffer.remaining() + + /** + * 是否还有剩余字节 + */ + @get:JvmName("hasRemaining") + val hasRemaining: Boolean get() = buffer.hasRemaining() + + /** + * 限制位置 + */ + @get:JvmName("limit") + val limit: Int get() = buffer.limit() + + /** + * 标记位置(实际 ByteBuffer 没有直接获取 mark 的方法,这里返回当前position) + */ + @get:JvmName("mark") + val mark: Int get() = remaining + + /** + * 是否具有可访问的底层数组 + */ + @get:JvmName("hasArray") + val hasArray: Boolean get() = buffer.hasArray() + + /** + * 获取底层数组(如果存在) + * + * @return 底层字节数组 + * @throws UnsupportedOperationException 如果没有底层数组(如直接缓冲区) + */ + @get:JvmName("array") + val array: ByteArray get() = buffer.array() + + /** + * 转换为整个字节数组 + * + * @return 数组偏移量 + * @throws UnsupportedOperationException 如果没有底层数组 + */ + fun toByteArray(): ByteArray = getByteArray(remaining) + + /** + * 获取底层数组的偏移量 + * + * @return 数组偏移量 + * @throws UnsupportedOperationException 如果没有底层数组 + */ + + @get:JvmName("arrayOffset") + val arrayOffset: Int get() = buffer.arrayOffset() + + /** + * 是否为只读缓冲区 + */ + @get:JvmName("isReadOnly") + val isReadOnly: Boolean get() = buffer.isReadOnly + + /** + * 是否为直接缓冲区(堆外内存) + */ + @get:JvmName("isDirect") + val isDirect: Boolean get() = buffer.isDirect + + /** + * 当前字节序(大端/小端) + */ + @get:JvmName("order") + val byteOrder: ByteOrder get() = buffer.order() + + /** + * 是否为大端字节序 + */ + @get:JvmName("isBigEndian") + val isBigEndian: Boolean get() = byteOrder == ByteOrder.BIG_ENDIAN + + /** + * 是否为小端字节序 + */ + @get:JvmName("isLittleEndian") + val isLittleEndian: Boolean get() = byteOrder == ByteOrder.LITTLE_ENDIAN + + /** + * 缓冲区是否为空(无剩余字节) + */ + @get:JvmName("isEmpty") + val isEmpty: Boolean get() = !hasRemaining + + /** + * 缓冲区是否已满(position == capacity) + */ + @get:JvmName("isFull") + val isFull: Boolean get() = position == capacity + + /** + * 当前位置是否在限制之内 + */ + @get:JvmName("isWithinLimit") + val isWithinLimit: Boolean get() = position < limit + + /** + * 是否已到达限制位置 + */ + @get:JvmName("isAtLimit") + val isAtLimit: Boolean get() = position == limit + + /** + * 获取缓冲区的字符串表示 + * + * @return 格式化的字符串信息 + */ + override fun toString(): String { + return "ByteBufferWrapper(capacity=$capacity, position=$position, limit=$limit, remaining=$remaining)#${hashCode()}" + } + + companion object { + /** + * 包装现有的 ByteBuffer + * + * @param buffer 要包装的 ByteBuffer + * @return 新的 ByteBufferWrapper 实例 + */ + @JvmStatic + fun wrap(buffer: ByteBuffer): ByteBufferWrapper { + return ByteBufferWrapper(buffer) + } + + /** + * 包装现有的 ByteBuf + * + * @param buffer 要包装的 ByteBuf + * @return 新的 ByteBufferWrapper 实例 + */ + @JvmStatic + fun wrap(buffer: ByteBuf): ByteBufferWrapper { + return ByteBufferWrapper(buffer.toByteBuffer()) + } + + /** + * 包装字节数组 + * + * @param array 要包装的字节数组 + * @return 新的 ByteBufferWrapper 实例 + */ + @JvmStatic + fun wrap(array: ByteArray): ByteBufferWrapper { + return ByteBufferWrapper(ByteBuffer.wrap(array)) + } + + /** + * 包装字节数组的一部分 + * + * @param array 要包装的字节数组 + * @param offset 起始偏移量 + * @param length 长度 + * @return 新的 ByteBufferWrapper 实例 + */ + @JvmStatic + fun wrap(array: ByteArray, offset: Int, length: Int): ByteBufferWrapper { + return ByteBufferWrapper(ByteBuffer.wrap(array, offset, length)) + } + + /** + * 分配堆内缓冲区 + * + * @param capacity 缓冲区容量 + * @return 新的 ByteBufferWrapper 实例 + */ + @JvmStatic + fun allocate(capacity: Int): ByteBufferWrapper { + return ByteBufferWrapper(ByteBuffer.allocate(capacity)) + } + + /** + * 分配直接缓冲区(堆外内存) + * 适用于高性能 I/O 场景,但分配和释放成本较高 + * + * @param capacity 缓冲区容量 + * @return 新的 ByteBufferWrapper 实例 + */ + @JvmStatic + fun allocateDirect(capacity: Int): ByteBufferWrapper { + return ByteBufferWrapper(ByteBuffer.allocateDirect(capacity)) + } + + /** + * 添加转换器到映射表,转换器内部通过 getType() 提供自己的类型信息 + * + * @param byteBufferWrapperConvertor 要添加的转换器实例,其泛型类型信息通过 getType() 方法获取 + */ + @JvmStatic + fun addConvertor(byteBufferWrapperConvertor: ByteBufferWrapperConvertor<*>) { + _ByteBufferWrapperConvertorMap[byteBufferWrapperConvertor.getType().kotlin.javaObjectType] = + byteBufferWrapperConvertor + } + + @JvmName("inline_addConvertor") + inline fun > addConvertor() { + addConvertor(ByteBufferWrapperConvertor.getInstantiation()) + } + + /** + * 添加转换器到映射表,显式指定要处理的类型 Class + * + * @param clazz 要处理的类型对应的 Class 对象 + * @param byteBufferWrapperConvertor 与指定类型匹配的转换器实例 + * @param T 要处理的数据类型 + */ + @JvmStatic + fun addConvertor(clazz: Class, byteBufferWrapperConvertor: ByteBufferWrapperConvertor) { + _ByteBufferWrapperConvertorMap[clazz.kotlin.javaObjectType] = byteBufferWrapperConvertor + } + + /** + * 根据类型 Class 从映射表中获取对应的转换器,并进行类型转换 + * + * @param clazz 要获取转换器的类型对应的 Class 对象 + * @param T 要处理的数据类型 + * @return 与指定类型匹配的转换器实例,如果不存在则返回 null + */ + @JvmStatic + @Suppress("UNCHECKED_CAST") + fun getConvertor(clazz: Class): ByteBufferWrapperConvertor? { + return _ByteBufferWrapperConvertorMap[clazz] as? ByteBufferWrapperConvertor + } + + /** + * 从映射表中移除指定类型的转换器 + * + * @param clazz 要移除转换器的类型对应的 Class 对象 + */ + @JvmStatic + fun delectConvertor(clazz: Class<*>) { + _ByteBufferWrapperConvertorMap.remove(clazz) + } + + /** + * 存储类型与转换器映射关系的线程安全哈希表 + * 键:要处理的类型 Class<*> + * 值:对应的转换器实例 ByteBufferWrapperConvertor<*> + */ + private val _ByteBufferWrapperConvertorMap = + ConcurrentHashMap, ByteBufferWrapperConvertor<*>>(64, 1.5f) + + + init { + ByteBufferWrapperConvertor.defaultConvertorInstall() + } + } + + + /** + * 将对象写入 ByteBufferWrapper + * + * 根据对象的实际类型获取对应的转换器,使用该转换器将对象写入当前的 ByteBufferWrapper + * 支持方法链调用(返回 this) + * + * @param obj 要写入的对象,类型为 T + * @return 当前的 ByteBufferWrapper 实例,支持链式调用 + * @throws IllegalArgumentException 如果该对象类型没有注册对应的转换器 + */ + fun putObject(obj: Any): ByteBufferWrapper { + val convertor = getConvertor(obj.javaClass) + ?: throw IllegalArgumentException("${obj.javaClass.canonicalName} does not convertor exist") + convertor.write(obj, this) + return this + } + + /** + * 将一个字节写入缓冲区。 + * + * @param byte 要写入的字节值 + * @return 当前包装器实例,支持链式调用 + */ + fun put(byte: Byte): ByteBufferWrapper = putByte(byte) + + /** + * 将一个字符写入缓冲区(2字节)。 + * + * @param char 要写入的字符值 + * @return 当前包装器实例,支持链式调用 + */ + fun put(char: Char): ByteBufferWrapper = putChar(char) + + /** + * 将一个短整数写入缓冲区(2字节)。 + * + * @param short 要写入的短整数 + * @return 当前包装器实例,支持链式调用 + */ + fun put(short: Short): ByteBufferWrapper = putShort(short) + + /** + * 将一个整数写入缓冲区(4字节)。 + * + * @param int 要写入的长整数 + * @return 当前包装器实例,支持链式调用 + */ + fun put(int: Int): ByteBufferWrapper = putInt(int) + + /** + * 将一个长整数写入缓冲区(8字节)。 + * + * @param long 要写入的长整数 + * @return 当前包装器实例,支持链式调用 + */ + fun put(long: Long): ByteBufferWrapper = putLong(long) + + /** + * 将一个布尔值写入缓冲区(1字节)。 + * 通常编码为:true = 0x01,false = 0x00。 + * + * @param boolean 要写入的布尔值 + * @return 当前包装器实例,支持链式调用 + */ + fun put(boolean: Boolean): ByteBufferWrapper = putBoolean(boolean) + + /** + * 将一个单精度浮点数写入缓冲区(4字节)。 + * + * @param float 要写入的单精度浮点数 + * @return 当前包装器实例,支持链式调用 + */ + fun put(float: Float): ByteBufferWrapper = putFloat(float) + + /** + * 将一个双精度浮点数写入缓冲区(8字节)。 + * + * @param double 要写入的双精度浮点数 + * @return 当前包装器实例,支持链式调用 + */ + fun put(double: Double): ByteBufferWrapper = putDouble(double) + + /** + * 将字节数组完整写入缓冲区。 + * + * @param byteArray 要写入的字节数组 + * @return 当前包装器实例,支持链式调用 + */ + fun put(byteArray: ByteArray): ByteBufferWrapper = putByteArray(byteArray) + + /** + * 将字符数组完整写入缓冲区(每个字符2字节)。 + * + * @param charArray 要写入的字符数组 + * @return 当前包装器实例,支持链式调用 + */ + fun put(charArray: CharArray): ByteBufferWrapper = putCharArray(charArray) + + /** + * 将短整数数组完整写入缓冲区(每个短整数2字节)。 + * + * @param shortArray 要写入的短整数数组 + * @return 当前包装器实例,支持链式调用 + */ + fun put(shortArray: ShortArray): ByteBufferWrapper = putShortArray(shortArray) + + /** + * 将整数数组完整写入缓冲区(每个长整数4字节)。 + * + * @param intArray 要写入的长整数数组 + * @return 当前包装器实例,支持链式调用 + */ + fun put(intArray: IntArray): ByteBufferWrapper = putIntArray(intArray) + + /** + * 将长整数数组完整写入缓冲区(每个长整数8字节)。 + * + * @param longArray 要写入的长整数数组 + * @return 当前包装器实例,支持链式调用 + */ + fun put(longArray: LongArray): ByteBufferWrapper = putLongArray(longArray) + + /** + * 将布尔数组完整写入缓冲区(每个布尔值1字节)。 + * + * @param booleanArray 要写入的布尔数组 + * @return 当前包装器实例,支持链式调用 + */ + fun put(booleanArray: BooleanArray): ByteBufferWrapper = putBooleanArray(booleanArray) + + /** + * 将单精度浮点数数组完整写入缓冲区(每个浮点数4字节)。 + * + * @param floatArray 要写入的单精度浮点数数组 + * @return 当前包装器实例,支持链式调用 + */ + fun put(floatArray: FloatArray): ByteBufferWrapper = putFloatArray(floatArray) + + /** + * 将双精度浮点数数组完整写入缓冲区(每个双精度浮点数8字节)。 + * + * @param doubleArray 要写入的双精度浮点数数组 + * @return 当前包装器实例,支持链式调用 + */ + fun put(doubleArray: DoubleArray): ByteBufferWrapper = putDoubleArray(doubleArray) + + /** + * 将 DateTime 对象写入缓冲区。 + * + * @param dateTime 要写入的 DateTime 对象 + * @return 当前包装器实例,支持链式调用 + */ + fun put(dateTime: DateTime): ByteBufferWrapper = putDateTime(dateTime) + + /** + * 将 LocalDateTime 对象写入缓冲区。 + * + * @param localDateTime 要写入的 LocalDateTime 对象 + * @return 当前包装器实例,支持链式调用 + */ + fun put(localDateTime: LocalDateTime): ByteBufferWrapper = putLocalDateTime(localDateTime) + + /** + * 将 Date 对象写入缓冲区。 + * + * @param date 要写入的 Date 对象 + * @return 当前包装器实例,支持链式调用 + */ + fun put(date: Date): ByteBufferWrapper = putDate(date) + + /** + * 将字符串写入缓冲区。 + * + * @param string 要写入的字符串 + * @return 当前包装器实例,支持链式调用 + */ + fun put(string: String): ByteBufferWrapper = putString(string) + + /** + * 将 ByteFlags 标志位对象写入缓冲区。 + * + * @param byteFlags 要写入的标志位对象 + * @return 当前包装器实例,支持链式调用 + */ + fun put(byteFlags: ByteFlags): ByteBufferWrapper = putFlag(byteFlags) + + /** + * 从 ByteBufferWrapper 中读取指定类型的对象 + * + * 根据指定的类型获取对应的转换器,使用该转换器从当前的 ByteBufferWrapper 中读取对象 + * + * @param clazz 要读取的对象类型对应的 Class 对象 + * @param T 要读取的对象类型 + * @return 读取并转换后的 T 类型对象 + * @throws IllegalArgumentException 如果该类型没有注册对应的转换器 + */ + fun getObject(clazz: Class, parameters: Array): T { + + val convertor = + getConvertor(clazz) ?: throw IllegalArgumentException("${clazz.canonicalName} does not convertor exist") + return convertor.read(this, parameters) + } + + fun getObject(clazz: Class): T { + return getObject(clazz, emptyArray()) + } + + fun getObject(clazz: Class, size: Int): T { + return getObject(clazz, arrayOf(size)) + } + + @JvmName("inline_getObject") + inline fun getObject(parameters: Array): T { + return getObject(T::class.java, parameters) + } + + @JvmName("inline_getObject") + inline fun getObject(size: Int): T { + return getObject(T::class.java, size) + } + + @JvmName("inline_getObject") + inline fun getObject(): T { + return getObject(T::class.java) + } + + + /** + * 写入字节数组 + * + * @param byteArray 要写入的字节数组 + * @param offset 起始偏移量(默认为0) + * @param length 写入长度(默认为数组长度) + * @return 当前对象(支持链式调用) + */ + fun putByteArray(byteArray: ByteArray, offset: Int = 0, length: Int = byteArray.size): ByteBufferWrapper { + buffer.put(byteArray, offset, length) + return this + } + + fun putByteArray(size: Int, init: (Int) -> Byte): ByteBufferWrapper { + buffer.put(ByteArray(size, init)) + return this + } + + fun putCharArray(charArray: CharArray): ByteBufferWrapper { + putByteArray(charArray.size) { + charArray[it].code.toByte() + } + return this + } + + fun getCharArray(size: Int): CharArray { + return getByteArray(size).let { + CharArray(it.size) { s -> + it[s].toInt().toChar() + } + } + } + + fun putIntArray(intArray: IntArray): ByteBufferWrapper { + intArray.forEach(::putInt) + return this + } + + fun getIntArray(size: Int): IntArray { + return IntArray(size) { getInt() } + } + + fun putShortArray(shortArray: ShortArray): ByteBufferWrapper { + shortArray.forEach(::putShort) + return this + } + + fun getShortArray(size: Int): ShortArray { + return ShortArray(size) { getShort() } + } + + fun putLongArray(longArray: LongArray): ByteBufferWrapper { + longArray.forEach(::putLong) + return this + } + + fun getLongArray(size: Int): LongArray { + return LongArray(size) { getLong() } + } + + + fun putDoubleArray(doubleArray: DoubleArray): ByteBufferWrapper { + doubleArray.forEach(::putDouble) + return this + } + + fun getDoubleArray(size: Int): DoubleArray { + return DoubleArray(size) { getDouble() } + } + + fun putFloatArray(floatArray: FloatArray): ByteBufferWrapper { + floatArray.forEach(::putFloat) + return this + } + + fun getFloatArray(size: Int): FloatArray { + return FloatArray(size) { getFloat() } + } + + fun putBooleanArray(booleanArray: BooleanArray): ByteBufferWrapper { + putByteArray(booleanArray.size) { + if (booleanArray[it]) 0x01 else 0x00 + } + return this + } + + fun getBooleanArray(size: Int): BooleanArray { + return getByteArray(size).let { + BooleanArray(it.size) { index -> + when (val itm = it[index]) { + 0x00.toByte() -> false + 0x01.toByte() -> true + else -> throw IllegalArgumentException("$itm not Boolean") + } + } + } + } + + /** + * 写入单个字节 + * + * @param byte 要写入的字节 + * @return 当前对象(支持链式调用) + */ + fun putByte(byte: Byte): ByteBufferWrapper { + buffer.put(byte) + return this + } + + /** + * 写入字符(2字节) + * + * @param char 要写入的字符 + * @return 当前对象(支持链式调用) + */ + fun putChar(char: Char): ByteBufferWrapper { + buffer.putChar(char) + return this + } + + /** + * 写入短整数(2字节) + * + * @param short 要写入的短整数 + * @return 当前对象(支持链式调用) + */ + fun putShort(short: Short): ByteBufferWrapper { + buffer.putShort(short) + return this + } + + /** + * 写入整数(4字节) + * + * @param int 要写入的整数 + * @return 当前对象(支持链式调用) + */ + fun putInt(int: Int): ByteBufferWrapper { + buffer.putInt(int) + return this + } + + /** + * 写入长整数(8字节) + * + * @param long 要写入的长整数 + * @return 当前对象(支持链式调用) + */ + fun putLong(long: Long): ByteBufferWrapper { + buffer.putLong(long) + return this + } + + /** + * 写入 BigInteger(大整数) + * 格式:[长度:4字节] + [] + * + * @param bigInteger 要写入的 BigInteger + * @return 当前对象(支持链式调用) + */ + fun putBigInteger(bigInteger: BigInteger): ByteBufferWrapper { + val byteArray = bigInteger.toByteArray() + putInt(byteArray.size) + buffer.put(byteArray) + return this + } + + /** + * 写入单精度浮点数(4字节) + * + * @param float 要写入的浮点数 + * @return 当前对象(支持链式调用) + */ + fun putFloat(float: Float): ByteBufferWrapper { + buffer.putFloat(float) + return this + } + + /** + * 写入双精度浮点数(8字节) + * + * @param double 要写入的双精度浮点数 + * @return 当前对象(支持链式调用) + */ + fun putDouble(double: Double): ByteBufferWrapper { + buffer.putDouble(double) + return this + } + + /** + * 写入 BigDecimal(高精度小数) + * 格式:[scale:4字节] + [BigInteger] + * + * @param bigDecimal 要写入的 BigDecimal + * @return 当前对象(支持链式调用) + */ + fun putBigDecimal(bigDecimal: BigDecimal): ByteBufferWrapper { + putInt(bigDecimal.scale()) + putBigInteger(bigDecimal.unscaledValue()) + return this + } + + /** + * 写入布尔值(1字节) + * 0x00 = false, 0x01 = true + * + * @param boolean 要写入的布尔值 + * @return 当前对象(支持链式调用) + */ + fun putBoolean(boolean: Boolean): ByteBufferWrapper { + putByte(if (boolean) 0x01 else 0x00) + return this + } + + /** + * 写入标志位(ByteFlags) + * + * @param flags 要写入的标志位 + * @return 当前对象(支持链式调用) + */ + fun putFlag(flags: ByteFlags): ByteBufferWrapper { + putByte(flags.toByte()) + return this + } + + /** + * 写入字符串(带长度前缀) + * 格式:[长度:变长] + [UTF-8字节数组] + * + * @param string 要写入的字符串 + * @param charset 字符集(默认 UTF-8) + * @return 当前对象(支持链式调用) + */ + fun putString(string: String, charset: Charset = Charsets.UTF_8): ByteBufferWrapper { + buffer.putString(string, charset) + return this + } + + /** + * 写入变长编码的短整数 + * 使用 VarInt 编码节省空间 + * + * @param varShort 要写入的短整数 + * @return 当前对象(支持链式调用) + */ + fun putVarShort(varShort: Short): ByteBufferWrapper { + buffer.putVarShort(varShort) + return this + } + + /** + * 写入变长编码的整数 + * 使用 VarInt 编码节省空间 + * + * @param varInt 要写入的整数 + * @return 当前对象(支持链式调用) + */ + fun putVarInt(varInt: Int): ByteBufferWrapper { + buffer.putVarInt(varInt) + return this + } + + /** + * 写入变长编码的长整数 + * 使用 VarLong 编码节省空间 + * + * @param varLong 要写入的长整数 + * @return 当前对象(支持链式调用) + */ + fun putVarLong(varLong: Long): ByteBufferWrapper { + buffer.putVarLong(varLong) + return this + } + + /** + * 写入 Instant(时间戳) + * 格式:[seconds:8字节] + [nanos:4字节] + * + * @param instant 要写入的 Instant + * @return 当前对象(支持链式调用) + */ + fun putInstant(instant: Instant): ByteBufferWrapper { + putLong(instant.epochSecond) + putInt(instant.nano) + return this + } + + /** + * 写入 DateTime(Joda-Time) + * + * @param dateTime 要写入的 DateTime + * @return 当前对象(支持链式调用) + */ + fun putDateTime(dateTime: DateTime): ByteBufferWrapper { + putInstant(dateTime.toInstant()) + return this + } + + /** + * 写入 LocalDateTime(Java 8 时间) + * + * @param localDateTime 要写入的 LocalDateTime + * @return 当前对象(支持链式调用) + */ + fun putLocalDateTime(localDateTime: LocalDateTime): ByteBufferWrapper { + putDateTime(localDateTime.toDateTime()) + return this + } + + /** + * 写入 Date(传统 Java 日期) + * + * @param date 要写入的 Date + * @return 当前对象(支持链式调用) + */ + fun putDate(date: Date): ByteBufferWrapper { + putDateTime(date.toDateTime()) + return this + } + + /** + * 写入自定义 UUID + * + * @param uuid 要写入的 UUID + * @return 当前对象(支持链式调用) + */ + fun putUUID(uuid: UUID): ByteBufferWrapper { + putByteArray(uuid.toBytes()) + return this + } + + /** + * 写入 Java UUID + * + * @param uuid 要写入的 Java UUID + * @return 当前对象(支持链式调用) + */ + fun putUUID(uuid: java.util.UUID): ByteBufferWrapper { + putByteArray(uuid.toMLUUID().toBytes()) + return this + } + + /** + * 读取字节数组 + * + * @param size 要读取的字节数 + * @return 读取的字节数组 + */ + fun getByteArray(size: Int): ByteArray { + return ByteArray(size).let { + buffer.get(it) + it + } + } + + /** + * 读取单个字节 + * + * @return 读取的字节 + */ + fun getByte(): Byte { + return buffer.get() + } + + /** + * 读取字符 + * + * @return 读取的字符 + */ + fun getChar(): Char { + return buffer.getChar() + } + + /** + * 读取短整数 + * + * @return 读取的短整数 + */ + fun getShort(): Short { + return buffer.getShort() + } + + /** + * 读取整数 + * + * @return 读取的整数 + */ + fun getInt(): Int { + return buffer.getInt() + } + + /** + * 读取长整数 + * + * @return 读取的长整数 + */ + fun getLong(): Long { + return buffer.getLong() + } + + /** + * 读取 BigInteger + * + * @return 读取的 BigInteger + */ + fun getBigInteger(): BigInteger { + return BigInteger(getByteArray(getInt())) + } + + /** + * 读取单精度浮点数 + * + * @return 读取的浮点数 + */ + fun getFloat(): Float { + return buffer.getFloat() + } + + /** + * 读取双精度浮点数 + * + * @return 读取的双精度浮点数 + */ + fun getDouble(): Double { + return buffer.getDouble() + } + + /** + * 读取 BigDecimal + * + * @return 读取的 BigDecimal + */ + fun getBigDecimal(): BigDecimal { + val scale = getInt() + return BigDecimal(getBigInteger(), scale) + } + + /** + * 读取布尔值 + * + * @return 读取的布尔值 + * @throws IllegalArgumentException 如果字节值不是 0x00 或 0x01 + */ + fun getBoolean(): Boolean { + return when (getByte()) { + 0x00.toByte() -> false + 0x01.toByte() -> true + else -> throw java.lang.IllegalArgumentException("Not a boolean") + } + } + + /** + * 读取标志位 + * + * @return 读取的 ByteFlags + */ + fun getFlag(): ByteFlags { + return ByteFlags(getByte()) + } + + /** + * 读取字符串 + * + * @param charset 字符集(默认 UTF-8) + * @return 读取的字符串 + */ + fun getString(charset: Charset = Charsets.UTF_8): String { + return buffer.getString(charset) + } + + /** + * 读取变长编码的短整数 + * + * @return 读取的短整数 + */ + fun getVarShort(): Short { + return buffer.getVarShort() + } + + /** + * 读取变长编码的整数 + * + * @return 读取的整数 + */ + fun getVarInt(): Int { + return buffer.getVarInt() + } + + /** + * 读取变长编码的长整数 + * + * @return 读取的长整数 + */ + fun getVarLong(): Long { + return buffer.getVarLong() + } + + /** + * 读取 Instant + * + * @return 读取的 Instant + */ + fun getInstant(): Instant { + return Instant.ofEpochSecond(getLong(), getInt().toLong()) + } + + /** + * 读取 DateTime(Joda-Time) + * + * @param zoneId 时区(默认系统时区) + * @return 读取的 DateTime + */ + fun getDateTime(zoneId: ZoneId = ZoneId.systemDefault()): DateTime { + return DateTime.of(getInstant(), zoneId) + } + + /** + * 读取 LocalDateTime + * + * @param zoneId 时区(默认系统时区) + * @return 读取的 LocalDateTime + */ + fun getLocalDateTime(zoneId: ZoneId = ZoneId.systemDefault()): LocalDateTime { + return getDateTime(zoneId).toLocalDateTime() + } + + /** + * 读取 Date + * + * @param zoneId 时区(默认系统时区) + * @return 读取的 Date + */ + fun getDate(zoneId: ZoneId = ZoneId.systemDefault()): Date { + return getDateTime(zoneId).toDate() + } + + /** + * 读取自定义 UUID + * + * @return 读取的 UUID + */ + fun getUUID(): UUID { + return getByteArray(16).let { + UUID.of(it) + } + } + + /** + * 读取 Java UUID + * + * @return 读取的 Java UUID + */ + fun getJUUID(): java.util.UUID { + return getByteArray(16).let { + UUID.of(it).getUuid() + } + } + + /** + * 创建当前缓冲区的副本 + * 共享内容但拥有独立的位置、限制和标记 + * + * @return 新的 ByteBufferWrapper 实例 + */ + fun duplicate(): ByteBufferWrapper { + return ByteBufferWrapper(buffer.duplicate()) + } + + /** + * 创建当前缓冲区的只读视图 + * + * @return 只读的 ByteBufferWrapper 实例 + */ + fun asReadOnly(): ByteBufferWrapper { + return ByteBufferWrapper(buffer.asReadOnlyBuffer()) + } + + /** + * 创建当前缓冲区的切片 + * 从当前位置到限制的共享视图 + * + * @return 新的 ByteBufferWrapper 实例 + */ + fun slice(): ByteBufferWrapper { + return ByteBufferWrapper(buffer.slice()) + } + + /** + * 设置位置 + * + * @param newPosition 新的位置 + * @return 当前对象(支持链式调用) + * @throws IllegalArgumentException 如果位置超出范围 + */ + fun position(newPosition: Int): ByteBufferWrapper { + buffer.position(newPosition) + return this + } + + /** + * 设置限制 + * + * @param newLimit 新的限制 + * @return 当前对象(支持链式调用) + * @throws IllegalArgumentException 如果限制超出范围 + */ + fun limit(newLimit: Int): ByteBufferWrapper { + buffer.limit(newLimit) + return this + } + + /** + * 设置标记位置 + * + * @return 当前对象(支持链式调用) + */ + fun mark(): ByteBufferWrapper { + buffer.mark() + return this + } + + /** + * 重置到标记位置 + * + * @return 当前对象(支持链式调用) + * @throws java.nio.InvalidMarkException 如果没有标记 + */ + fun reset(): ByteBufferWrapper { + buffer.reset() + return this + } + + /** + * 设置字节序 + * + * @param byteOrder 字节序(BIG_ENDIAN 或 LITTLE_ENDIAN) + * @return 当前对象(支持链式调用) + */ + fun order(byteOrder: ByteOrder): ByteBufferWrapper { + buffer.order(byteOrder) + return this + } + + /** + * 设置为大端字节序 + * + * @return 当前对象(支持链式调用) + */ + fun asBigEndian(): ByteBufferWrapper { + buffer.order(ByteOrder.BIG_ENDIAN) + return this + } + + /** + * 设置为小端字节序 + * + * @return 当前对象(支持链式调用) + */ + fun asLittleEndian(): ByteBufferWrapper { + buffer.order(ByteOrder.LITTLE_ENDIAN) + return this + } + + /** + * 清除缓冲区 + * position = 0, limit = capacity, mark = -1 + * 准备重新写入 + * + * @return 当前对象(支持链式调用) + */ + fun clear(): ByteBufferWrapper { + buffer.clear() + return this + } + + /** + * 翻转缓冲区 + * limit = position, position = 0, mark = -1 + * 用于从写入模式切换到读取模式 + * + * @return 当前对象(支持链式调用) + */ + fun flip(): ByteBufferWrapper { + buffer.flip() + return this + } + + /** + * 重绕缓冲区 + * position = 0, mark = -1 + * 准备重新读取 + * + * @return 当前对象(支持链式调用) + */ + fun rewind(): ByteBufferWrapper { + buffer.rewind() + return this + } + + /** + * 压缩缓冲区 + * 将未读数据移到开头,position = 剩余字节数,limit = capacity + * 适用于部分读取后想继续写入的场景 + * + * @return 当前对象(支持链式调用) + */ + fun compact(): ByteBufferWrapper { + buffer.compact() + return this + } + + /** + * 跳过指定字节数 + * 相当于 position += bytes + * + * @param bytes 要跳过的字节数 + * @return 当前对象(支持链式调用) + * @throws IllegalArgumentException 如果跳过的字节数超出范围 + */ + fun skip(bytes: Int): ByteBufferWrapper { + buffer.position(buffer.position() + bytes) + return this + } + + /** + * 跳转到指定位置 + * + * @param newPosition 目标位置 + * @return 当前对象(支持链式调用) + */ + fun jumpTo(newPosition: Int): ByteBufferWrapper { + buffer.position(newPosition) + return this + } + + /** + * 回到开头 + * position = 0 + * + * @return 当前对象(支持链式调用) + */ + fun rewindToStart(): ByteBufferWrapper { + buffer.position(0) + return this + } + + /** + * 跳到末尾 + * position = limit + * + * @return 当前对象(支持链式调用) + */ + fun jumpToEnd(): ByteBufferWrapper { + buffer.position(buffer.limit()) + return this + } +} diff --git a/src/main/kotlin/com/mingliqiye/utils/buffer/convertor/ByteBufferWrapperConvertor.kt b/src/main/kotlin/com/mingliqiye/utils/buffer/convertor/ByteBufferWrapperConvertor.kt new file mode 100644 index 0000000..7a45a40 --- /dev/null +++ b/src/main/kotlin/com/mingliqiye/utils/buffer/convertor/ByteBufferWrapperConvertor.kt @@ -0,0 +1,276 @@ +/* + * Copyright 2026 mingliqiye + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * ProjectName mingli-utils + * ModuleName mingli-utils.main + * CurrentFile ByteBufferWrapperConvertor.kt + * LastUpdate 2026-03-15 11:05:48 + * UpdateUser MingLiPro + */ + +package com.mingliqiye.utils.buffer.convertor + +import com.mingliqiye.utils.buffer.ByteBufferWrapper +import com.mingliqiye.utils.bytes.ByteFlags +import com.mingliqiye.utils.time.DateTime +import com.mingliqiye.utils.uuid.UUID +import java.math.BigDecimal +import java.math.BigInteger +import java.time.LocalDateTime +import java.util.* +import java.util.concurrent.ConcurrentHashMap +import java.util.UUID as JUUID + +interface ByteBufferWrapperConvertorInterface { + fun write(obj: T, byteBufferWrapper: ByteBufferWrapper) + fun read(byteBufferWrapper: ByteBufferWrapper, parameters: Array): T + fun getType(): Class +} + +abstract class ByteBufferWrapperConvertor : ByteBufferWrapperConvertorInterface { + override fun toString(): String { + return "ByteBufferWrapperConvertor(type=${getType()})" + } + + companion object { + private val _instantiations = + ConcurrentHashMap>, ByteBufferWrapperConvertor<*>>() + + @JvmStatic + fun getInstantiation(clazz: Class>): ByteBufferWrapperConvertor<*> { + return _instantiations.getOrPut(clazz) { + clazz.getConstructor().newInstance() + } + } + + @JvmStatic + @Suppress("UNCHECKED_CAST") + inline fun > getInstantiation(): ByteBufferWrapperConvertor<*> { + return getInstantiation(T::class.java as Class>) + } + + fun defaultConvertorInstall() { + ByteBufferWrapper.addConvertor() + ByteBufferWrapper.addConvertor() + ByteBufferWrapper.addConvertor() + ByteBufferWrapper.addConvertor() + ByteBufferWrapper.addConvertor() + ByteBufferWrapper.addConvertor() + ByteBufferWrapper.addConvertor() + ByteBufferWrapper.addConvertor() + ByteBufferWrapper.addConvertor() + ByteBufferWrapper.addConvertor() + ByteBufferWrapper.addConvertor() + ByteBufferWrapper.addConvertor() + ByteBufferWrapper.addConvertor() + ByteBufferWrapper.addConvertor() + ByteBufferWrapper.addConvertor() + ByteBufferWrapper.addConvertor() + ByteBufferWrapper.addConvertor() + ByteBufferWrapper.addConvertor() + ByteBufferWrapper.addConvertor() + ByteBufferWrapper.addConvertor() + ByteBufferWrapper.addConvertor() + ByteBufferWrapper.addConvertor() + ByteBufferWrapper.addConvertor() + ByteBufferWrapper.addConvertor() + ByteBufferWrapper.addConvertor() + } + } +} + +abstract class ObjectBufferWrapperConvertor( + val write: ByteBufferWrapper.(obj: T) -> Unit, + val read: ByteBufferWrapper.() -> T, + val typer: Class, +) : ByteBufferWrapperConvertor() { + override fun write(obj: T, byteBufferWrapper: ByteBufferWrapper) = write.invoke(byteBufferWrapper, obj) + override fun read(byteBufferWrapper: ByteBufferWrapper, parameters: Array): T = + read.invoke(byteBufferWrapper) + + override fun getType(): Class = typer +} + + +class BytedBufferWrapperConvertor : ObjectBufferWrapperConvertor( + ByteBufferWrapper::putByte, + ByteBufferWrapper::getByte, + Byte::class.java, +) + +class CharBufferWrapperConvertor : ObjectBufferWrapperConvertor( + ByteBufferWrapper::putChar, + ByteBufferWrapper::getChar, + Char::class.java, +) + +class ShortBufferWrapperConvertor : ObjectBufferWrapperConvertor( + ByteBufferWrapper::putShort, + ByteBufferWrapper::getShort, + Short::class.java, +) + +class IntBufferWrapperConvertor : ObjectBufferWrapperConvertor( + ByteBufferWrapper::putInt, + ByteBufferWrapper::getInt, + Int::class.java, +) + +class LongBufferWrapperConvertor : ObjectBufferWrapperConvertor( + ByteBufferWrapper::putLong, + ByteBufferWrapper::getLong, + Long::class.java, +) + +class DoubleBufferWrapperConvertor : ObjectBufferWrapperConvertor( + ByteBufferWrapper::putDouble, + ByteBufferWrapper::getDouble, + Double::class.java, +) + +class FloatBufferWrapperConvertor : ObjectBufferWrapperConvertor( + ByteBufferWrapper::putFloat, + ByteBufferWrapper::getFloat, + Float::class.java, +) + +class BigIntegerBufferWrapperConvertor : ObjectBufferWrapperConvertor( + ByteBufferWrapper::putBigInteger, + ByteBufferWrapper::getBigInteger, + BigInteger::class.java, +) + +class BigDecimalBufferWrapperConvertor : ObjectBufferWrapperConvertor( + ByteBufferWrapper::putBigDecimal, + ByteBufferWrapper::getBigDecimal, + BigDecimal::class.java, +) + +class BooleanBufferWrapperConvertor : ObjectBufferWrapperConvertor( + ByteBufferWrapper::putBoolean, + ByteBufferWrapper::getBoolean, + Boolean::class.java, +) + +class StringBufferWrapperConvertor : ObjectBufferWrapperConvertor( + ByteBufferWrapper::putString, + ByteBufferWrapper::getString, + String::class.java, +) + +class ByteFlagsBufferWrapperConvertor : ObjectBufferWrapperConvertor( + ByteBufferWrapper::putFlag, + ByteBufferWrapper::getFlag, + ByteFlags::class.java, +) + + +class JUUIDBufferWrapperConvertor : ObjectBufferWrapperConvertor( + ByteBufferWrapper::putUUID, + ByteBufferWrapper::getJUUID, + JUUID::class.java, +) + +class UUIDBufferWrapperConvertor : ObjectBufferWrapperConvertor( + ByteBufferWrapper::putUUID, + ByteBufferWrapper::getUUID, + UUID::class.java, +) + +class DateTimeFlagsBufferWrapperConvertor : ObjectBufferWrapperConvertor( + ByteBufferWrapper::putDateTime, + ByteBufferWrapper::getDateTime, + DateTime::class.java, +) + +class LocalDateTimeBufferWrapperConvertor : ObjectBufferWrapperConvertor( + ByteBufferWrapper::putLocalDateTime, + ByteBufferWrapper::getLocalDateTime, + LocalDateTime::class.java, +) + +class DateBufferWrapperConvertor : ObjectBufferWrapperConvertor( + ByteBufferWrapper::putDate, + ByteBufferWrapper::getDate, + Date::class.java, +) + +abstract class ArrayBufferWrapperConvertor( + val write: ByteBufferWrapper.(obj: T) -> Unit, + val read: ByteBufferWrapper.(size: Int) -> T, + val typer: Class, +) : ByteBufferWrapperConvertor() { + override fun write(obj: T, byteBufferWrapper: ByteBufferWrapper) = write.invoke(byteBufferWrapper, obj) + override fun read(byteBufferWrapper: ByteBufferWrapper, parameters: Array): T { + if (parameters.isEmpty()) { + throw IllegalArgumentException("parameters cannot be empty, must has a Int") + } + val size = parameters[0] + if (size !is Int) + throw IllegalArgumentException("parameters[0] cannot be Int, must has a Int") + return read.invoke(byteBufferWrapper, size) + } + + override fun getType(): Class = typer +} + +class ByteArrayBufferWrapperConvertor : ArrayBufferWrapperConvertor( + ByteBufferWrapper::putByteArray, + ByteBufferWrapper::getByteArray, + ByteArray::class.java, +) + +class CharArrayBufferWrapperConvertor : ArrayBufferWrapperConvertor( + ByteBufferWrapper::putCharArray, + ByteBufferWrapper::getCharArray, + CharArray::class.java, +) + +class ShortArrayBufferWrapperConvertor : ArrayBufferWrapperConvertor( + ByteBufferWrapper::putShortArray, + ByteBufferWrapper::getShortArray, + ShortArray::class.java, +) + +class IntArrayBufferWrapperConvertor : ArrayBufferWrapperConvertor( + ByteBufferWrapper::putIntArray, + ByteBufferWrapper::getIntArray, + IntArray::class.java, +) + +class LongArrayBufferWrapperConvertor : ArrayBufferWrapperConvertor( + ByteBufferWrapper::putLongArray, + ByteBufferWrapper::getLongArray, + LongArray::class.java, +) + +class FloatArrayBufferWrapperConvertor : ArrayBufferWrapperConvertor( + ByteBufferWrapper::putFloatArray, + ByteBufferWrapper::getFloatArray, + FloatArray::class.java, +) + +class DoubleArrayBufferWrapperConvertor : ArrayBufferWrapperConvertor( + ByteBufferWrapper::putDoubleArray, + ByteBufferWrapper::getDoubleArray, + DoubleArray::class.java, +) + + +class BooleanArrayBufferWrapperConvertor : ArrayBufferWrapperConvertor( + ByteBufferWrapper::putBooleanArray, + ByteBufferWrapper::getBooleanArray, + BooleanArray::class.java, +) diff --git a/src/main/kotlin/com/mingliqiye/utils/bytes/ByteFlags.kt b/src/main/kotlin/com/mingliqiye/utils/bytes/ByteFlags.kt index 9225b4c..cd81821 100644 --- a/src/main/kotlin/com/mingliqiye/utils/bytes/ByteFlags.kt +++ b/src/main/kotlin/com/mingliqiye/utils/bytes/ByteFlags.kt @@ -16,7 +16,7 @@ * ProjectName mingli-utils * ModuleName mingli-utils.main * CurrentFile ByteFlags.kt - * LastUpdate 2026-01-07 09:37:09 + * LastUpdate 2026-06-21 10:40:58 * UpdateUser MingLiPro */ @@ -47,7 +47,7 @@ data class ByteFlags( /** 第 6 位(0x40) */ var b6: Boolean = false, /** 第 7 位(最高位,0x80) */ - var b7: Boolean = false + var b7: Boolean = false, ) { /** @@ -410,7 +410,7 @@ data class ByteFlags( * @return 全 1 的 ByteFlags(值为 0xFF) */ fun allTrue(): ByteFlags { - return ByteFlags(true, true, true, true, true, true, true, true) + return ByteFlags(b0 = true, b1 = true, b2 = true, b3 = true, b4 = true, b5 = true, b6 = true, b7 = true) } /** diff --git a/src/main/kotlin/com/mingliqiye/utils/bytes/ByteUtils.kt b/src/main/kotlin/com/mingliqiye/utils/bytes/ByteUtils.kt index 14d9a41..e9c9984 100644 --- a/src/main/kotlin/com/mingliqiye/utils/bytes/ByteUtils.kt +++ b/src/main/kotlin/com/mingliqiye/utils/bytes/ByteUtils.kt @@ -16,7 +16,7 @@ * ProjectName mingli-utils * ModuleName mingli-utils.main * CurrentFile ByteUtils.kt - * LastUpdate 2026-03-12 10:09:05 + * LastUpdate 2026-05-22 13:26:55 * UpdateUser MingLiPro */ @file:JvmName("ByteUtils") @@ -88,7 +88,7 @@ const val ESC_RESERVED: Byte = 0x06 */ fun ByteArray.getByteArrayString(): MutableList { return this.toList().stream().map { a -> String.format("0X%02X", a!!.toInt() and 0xFF) } - .collect(SuperStream.toList()) as MutableList + .collect(SuperStream.toListCollector()) as MutableList } diff --git a/src/main/kotlin/com/mingliqiye/utils/exception/NotFoundResourceException.kt b/src/main/kotlin/com/mingliqiye/utils/exception/NotFoundResourceException.kt new file mode 100644 index 0000000..644c8f0 --- /dev/null +++ b/src/main/kotlin/com/mingliqiye/utils/exception/NotFoundResourceException.kt @@ -0,0 +1,36 @@ +/* + * Copyright 2026 mingliqiye + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * ProjectName mingli-utils + * ModuleName mingli-utils.main + * CurrentFile NotFoundResourceException.kt + * LastUpdate 2026-05-22 13:20:00 + * UpdateUser MingLiPro + */ + +package com.mingliqiye.utils.exception + +class NotFoundResourceException : MingLiUtilsBaseException { + constructor() + constructor(message: String) : super(message) + constructor(throwable: Throwable) : super(throwable) + constructor(message: String, throwable: Throwable) : super(message, throwable) + constructor( + message: String? = null, + throwable: Throwable? = null, + enableSuppression: Boolean = false, + writableStackTrace: Boolean = false, + ) : super(message, throwable, enableSuppression, writableStackTrace) +} diff --git a/src/main/kotlin/com/mingliqiye/utils/functions/Debouncer.kt b/src/main/kotlin/com/mingliqiye/utils/functions/Debouncer.kt index a9aecd4..2eadaa2 100644 --- a/src/main/kotlin/com/mingliqiye/utils/functions/Debouncer.kt +++ b/src/main/kotlin/com/mingliqiye/utils/functions/Debouncer.kt @@ -16,12 +16,13 @@ * ProjectName mingli-utils * ModuleName mingli-utils.main * CurrentFile Debouncer.kt - * LastUpdate 2026-01-11 09:10:30 + * LastUpdate 2026-05-23 10:30:38 * UpdateUser MingLiPro */ package com.mingliqiye.utils.functions +import com.mingliqiye.utils.netty.NamedThreadFactory import java.util.concurrent.* /** @@ -31,7 +32,11 @@ import java.util.concurrent.* */ class Debouncer(private val delay: Long, unit: TimeUnit) { - private val scheduler: ScheduledExecutorService = Executors.newSingleThreadScheduledExecutor() + private val scheduler: ScheduledExecutorService = Executors.newSingleThreadScheduledExecutor( + NamedThreadFactory { clazz, poolNumber, threadNumber -> + "Debouncer-$poolNumber-$threadNumber" + } + ) private val delayedMap: ConcurrentHashMap> = ConcurrentHashMap() private val delayMillis: Long = unit.toMillis(delay) @@ -60,9 +65,7 @@ class Debouncer(private val delay: Long, unit: TimeUnit) { ) // 如果之前存在任务,则取消它 - if (prev != null) { - prev.cancel(true) - } + prev?.cancel(true) } /** diff --git a/src/main/kotlin/com/mingliqiye/utils/http/Response.kt b/src/main/kotlin/com/mingliqiye/utils/http/Response.kt index d254905..a04ff30 100644 --- a/src/main/kotlin/com/mingliqiye/utils/http/Response.kt +++ b/src/main/kotlin/com/mingliqiye/utils/http/Response.kt @@ -16,7 +16,7 @@ * ProjectName mingli-utils * ModuleName mingli-utils.main * CurrentFile Response.kt - * LastUpdate 2026-03-12 10:33:32 + * LastUpdate 2026-03-14 08:01:32 * UpdateUser MingLiPro */ @@ -49,10 +49,19 @@ data class Response( * 创建一个默认的成功响应对象 * 使用默认消息"操作成功",无数据,状态码200 * - * @return Response 默认的成功响应对象 + * @return Response 默认的成功响应对象 */ fun ok() = ok("操作成功") + + /** + * 创建一个默认的错误响应对象 + * 使用默认消息"服务器错误",无数据,状态码500 + * + * @return Response 默认的成功响应对象 + */ + fun error() = error("服务器错误") + /** * 创建一个成功的响应对象(仅包含消息) * @@ -292,5 +301,5 @@ data class Response( * @return 格式化的字符串表示 */ override fun toString(): String = - "Response(time=${getTime()}, message=${getMessage()}, data:[${data?.javaClass?.simpleName}]=${getData()}, statusCode=${getStatusCode()})" + "Response<${data?.javaClass?.simpleName ?: "Nothing"}>(time=${getTime()}, message=${getMessage()}, data=${getData()}, statusCode=${getStatusCode()})" } diff --git a/src/main/kotlin/com/mingliqiye/utils/io/SIO.kt b/src/main/kotlin/com/mingliqiye/utils/io/SIO.kt index 0ea21da..bf6b4e8 100644 --- a/src/main/kotlin/com/mingliqiye/utils/io/SIO.kt +++ b/src/main/kotlin/com/mingliqiye/utils/io/SIO.kt @@ -16,7 +16,7 @@ * ProjectName mingli-utils * ModuleName mingli-utils.main * CurrentFile SIO.kt - * LastUpdate 2026-02-27 12:36:11 + * LastUpdate 2026-06-21 10:40:58 * UpdateUser MingLiPro */ @@ -106,6 +106,14 @@ object SIO { return this } + fun T.ifOr(boolean: Boolean, pd: T.() -> T): T = if (boolean) { + this + } else pd(this) + + fun T.ifOrElse(boolean: Boolean, pd: T.() -> T): T = if (!boolean) { + this + } else pd(this) + /** * 扩展函数:将列表以花括号格式打印,元素间用逗号分隔 * @return 原始列表 diff --git a/src/main/kotlin/com/mingliqiye/utils/json/api/JSONA.kt b/src/main/kotlin/com/mingliqiye/utils/json/api/JSONA.kt index 60b8899..9bc4787 100644 --- a/src/main/kotlin/com/mingliqiye/utils/json/api/JSONA.kt +++ b/src/main/kotlin/com/mingliqiye/utils/json/api/JSONA.kt @@ -16,7 +16,7 @@ * ProjectName mingli-utils * ModuleName mingli-utils.main * CurrentFile JSONA.kt - * LastUpdate 2026-02-26 14:14:18 + * LastUpdate 2026-03-18 09:14:06 * UpdateUser MingLiPro */ @@ -29,10 +29,13 @@ import com.mingliqiye.utils.json.api.type.JsonTypeReference import com.mingliqiye.utils.json.api.type.listType import com.mingliqiye.utils.json.converters.base.BaseJsonConverter import com.mingliqiye.utils.json.converters.base.getJsonConverter +import com.mingliqiye.utils.json.objects.base.JsonItem import java.io.File +import java.io.IOException import java.io.InputStream import java.io.OutputStream import java.nio.file.Path +import kotlin.io.path.readBytes /** * JSON工具类,提供静态方法访问JSON API功能 @@ -263,7 +266,7 @@ object JSONA { */ @JvmStatic fun parse( - json: String, type: JsonTypeReference, defaultValue: T + json: String, type: JsonTypeReference, defaultValue: T, ): T = getJsonApi().parse(json, type, defaultValue) /** @@ -401,7 +404,7 @@ object JSONA { */ @JvmStatic fun parseMap( - json: String, keyType: Class, valueType: Class + json: String, keyType: Class, valueType: Class, ): MutableMap = getJsonApi().parseMap(json, keyType, valueType) /** @@ -414,7 +417,7 @@ object JSONA { */ @JvmStatic inline fun parseMap( - json: String + json: String, ): MutableMap = getJsonApi().parseMap(json, K::class.java, V::class.java) /** @@ -429,7 +432,6 @@ object JSONA { /** * 将对象转换为JSON字节数组 * - * @param object 待转换的对象 * @return 转换后的JSON字节数组 */ @JvmStatic @@ -438,7 +440,6 @@ object JSONA { /** * 将对象转换为美化格式的JSON字节数组 * - * @param object 待转换的对象 * @return 转换后的美化格式JSON字节数组 */ @JvmStatic @@ -478,7 +479,6 @@ object JSONA { /** * 将源对象转换为目标类型的对象 * - * @param T 源对象的类型 * @param D 目标对象的类型 * @param source 需要转换的源对象 * @param destinationClass 目标对象的Class类型 @@ -490,7 +490,6 @@ object JSONA { /** * 使用内联函数和reified类型参数将源对象转换为目标类型的对象 * - * @param T 源对象的类型 * @param D 目标对象的类型(通过reified类型参数推断) * @param source 需要转换的源对象 * @return 转换后的目标类型对象 @@ -501,7 +500,6 @@ object JSONA { /** * 将源对象转换为目标类型的对象,使用JsonTypeReference指定目标类型 * - * @param T 源对象的类型 * @param D 目标对象的类型 * @param source 需要转换的源对象 * @param destinationType 目标对象的JsonTypeReference类型引用 @@ -540,4 +538,86 @@ object JSONA { @JvmStatic fun ObjectMapper.jacksonKotlinObjectMapper(): ObjectMapper = this.registerModule(kotlinModule()) + + + /** + * 将 JSON 字符串解析为 JsonItem 对象 + * + * @param json JSON 格式的字符串 + * @return 解析后的 JsonItem 对象,可以是 JsonObject、JsonArray 或 JsonValue + */ + @JvmStatic + fun parseJsonItem(json: String): JsonItem = getJsonApi().parseJsonItem(json) + + /** + * 将字节数组解析为 JsonItem 对象 + * 字节数组会被转换为字符串后再解析 + * + * @param byte JSON 格式的字节数组(通常是 UTF-8 编码) + * @return 解析后的 JsonItem 对象 + */ + @JvmStatic + fun parseJsonItem(byte: ByteArray): JsonItem { + return parseJsonItem(String(byte)) + } + + /** + * 将输入流解析为 JsonItem 对象 + * 会自动关闭输入流 + * + * @param inputStream JSON 数据的输入流 + * @return 解析后的 JsonItem 对象 + * @throws IOException 当读取输入流失败时抛出 + * + * 使用示例: + * ``` + * val inputStream = FileInputStream("data.json") + * val jsonItem = converter.parseJsonItem(inputStream) + * ``` + */ + @JvmStatic + @Throws(IOException::class) + fun parseJsonItem(inputStream: InputStream): JsonItem { + inputStream.use { + return parseJsonItem(it.readAllBytes()) + } + } + + /** + * 将文件解析为 JsonItem 对象 + * + * @param file 包含 JSON 数据的文件 + * @return 解析后的 JsonItem 对象 + * @throws IOException 当读取文件失败时抛出 + * + * 使用示例: + * ``` + * val file = File("config.json") + * val jsonItem = converter.parseJsonItem(file) + * ``` + */ + @JvmStatic + @Throws(IOException::class) + fun parseJsonItem(file: File): JsonItem { + return parseJsonItem(file.readBytes()) + } + + /** + * 将文件路径解析为 JsonItem 对象 + * + * @param path 包含 JSON 数据的文件路径 + * @return 解析后的 JsonItem 对象 + * @throws IOException 当读取文件失败时抛出 + * + * 使用示例: + * ``` + * val path = Paths.get("data/user.json") + * val jsonItem = converter.parseJsonItem(path) + * ``` + */ + @JvmStatic + @Throws(IOException::class) + fun parseJsonItem(path: Path): JsonItem { + return parseJsonItem(path.readBytes()) + } } diff --git a/src/main/kotlin/com/mingliqiye/utils/json/Jackson3JsonApi.kt b/src/main/kotlin/com/mingliqiye/utils/json/api/Jackson3JsonApi.kt similarity index 69% rename from src/main/kotlin/com/mingliqiye/utils/json/Jackson3JsonApi.kt rename to src/main/kotlin/com/mingliqiye/utils/json/api/Jackson3JsonApi.kt index cd5cfe1..771b169 100644 --- a/src/main/kotlin/com/mingliqiye/utils/json/Jackson3JsonApi.kt +++ b/src/main/kotlin/com/mingliqiye/utils/json/api/Jackson3JsonApi.kt @@ -16,27 +16,30 @@ * ProjectName mingli-utils * ModuleName mingli-utils.main * CurrentFile Jackson3JsonApi.kt - * LastUpdate 2026-03-11 08:46:40 + * LastUpdate 2026-06-21 10:40:58 * UpdateUser MingLiPro */ -package com.mingliqiye.utils.json +package com.mingliqiye.utils.json.api import com.mingliqiye.utils.exception.JsonException +import com.mingliqiye.utils.json.api.JackSon3JsonItem.Companion.getJsonItem import com.mingliqiye.utils.json.api.base.JsonApi import com.mingliqiye.utils.json.api.type.JsonTypeReference import com.mingliqiye.utils.json.converters.base.BaseJsonConverter import com.mingliqiye.utils.json.converters.base.getJackson3Module +import com.mingliqiye.utils.json.objects.base.* import tools.jackson.core.type.TypeReference import tools.jackson.databind.JsonNode import tools.jackson.databind.ObjectMapper +import tools.jackson.databind.node.JsonNodeType import tools.jackson.databind.node.ObjectNode import java.lang.reflect.Type class Jackson3JsonApi : JsonApi { - var get: () -> ObjectMapper - var set: (ObjectMapper) -> Unit + var get: () -> ObjectMapper = { _prObjectMapper!! } + var set: (ObjectMapper) -> Unit = { _prObjectMapper = it } private var _prObjectMapper: ObjectMapper? = null @@ -47,8 +50,6 @@ class Jackson3JsonApi : JsonApi { constructor(objectMapper: ObjectMapper) { _prObjectMapper = objectMapper - get = { _prObjectMapper!! } - set = { _prObjectMapper = it } } constructor( @@ -59,6 +60,10 @@ class Jackson3JsonApi : JsonApi { this.set = set } + constructor() { + _prObjectMapper = ObjectMapper() + } + override fun parse(json: String, clazz: Class): T { try { return objectMapper.readValue(json, clazz) @@ -97,7 +102,7 @@ class Jackson3JsonApi : JsonApi { return try { objectMapper.readTree(json) true - } catch (e: Exception) { + } catch (_: Exception) { false } } @@ -214,4 +219,80 @@ class Jackson3JsonApi : JsonApi { mapperBuilder.addModule(c.getJackson3Module()) this.objectMapper = mapperBuilder.build() } + + override fun parseJsonItem(json: String): JsonItem { + try { + return getJsonItem(objectMapper.readTree(json)) + } catch (e: Exception) { + throw JsonException("Failed to parseJsonItem", e) + } + } +} + + +class JackSon3JsonItem : JsonItem { + companion object { + fun getJsonItem(node: JsonNode): JsonItem { + return when (node.nodeType) { + JsonNodeType.OBJECT -> JackSon3JsonObject(node) + JsonNodeType.ARRAY -> JackSon3JsonArray(node) + JsonNodeType.BOOLEAN -> JackSon3JsonBoolean(node) + JsonNodeType.NULL -> JsonNull() + JsonNodeType.NUMBER -> JackSon3JsonNumber(node) + JsonNodeType.STRING -> JackSon3JsonString(node) + else -> throw IllegalStateException("unknown type ${node.nodeType}") + } + } + } +} + +class JackSon3JsonNumber(node: JsonNode) : JsonNumber(node.asString()) +class JackSon3JsonBoolean(node: JsonNode) : JsonBoolean(node.asBoolean()) +class JackSon3JsonString(node: JsonNode) : JsonString(node.asString()) + + +class JackSon3JsonArray(val node: JsonNode) : JsonArray() { + override fun getIndex(index: Int): JsonItem { + return JackSon3JsonItem.getJsonItem(node.get(index)) + } + + override fun iteratorArray(): Iterator> { + val iteet = node.iterator().withIndex() + return object : Iterator> { + override fun next(): IndexedValue { + val it = iteet.next() + return IndexedValue(it.index, JackSon3JsonItem.getJsonItem(it.value)) + } + + override fun hasNext(): Boolean { + return iteet.hasNext() + } + + } + } +} + +class JackSon3JsonObject(val node: JsonNode) : JsonObject() { + override fun getField(name: String): JsonItem { + return JackSon3JsonItem.getJsonItem(node.get(name)) + } + + override fun iteratorObject(): Iterator> { + return object : Iterator> { + val it = node.properties().iterator() + override fun next(): Map.Entry { + val utem = it.next() + return object : Map.Entry { + override val key: String + get() = utem.key + override val value: JsonItem + get() = JackSon3JsonItem.getJsonItem(utem.value) + } + } + + override fun hasNext(): Boolean { + return it.hasNext() + } + } + } } diff --git a/src/main/kotlin/com/mingliqiye/utils/json/api/JacksonJsonApi.kt b/src/main/kotlin/com/mingliqiye/utils/json/api/JacksonJsonApi.kt index 383d4d5..3e06ee2 100644 --- a/src/main/kotlin/com/mingliqiye/utils/json/api/JacksonJsonApi.kt +++ b/src/main/kotlin/com/mingliqiye/utils/json/api/JacksonJsonApi.kt @@ -16,7 +16,7 @@ * ProjectName mingli-utils * ModuleName mingli-utils.main * CurrentFile JacksonJsonApi.kt - * LastUpdate 2026-03-11 08:46:40 + * LastUpdate 2026-06-21 10:40:58 * UpdateUser MingLiPro */ @@ -27,12 +27,15 @@ import com.fasterxml.jackson.core.JsonProcessingException import com.fasterxml.jackson.databind.JsonNode import com.fasterxml.jackson.databind.ObjectMapper import com.fasterxml.jackson.databind.ObjectReader +import com.fasterxml.jackson.databind.node.JsonNodeType import com.fasterxml.jackson.databind.node.ObjectNode import com.mingliqiye.utils.exception.JsonException +import com.mingliqiye.utils.json.api.JackSonJsonItem.Companion.getJsonItem import com.mingliqiye.utils.json.api.base.JsonApi import com.mingliqiye.utils.json.api.type.JsonTypeReference import com.mingliqiye.utils.json.converters.base.BaseJsonConverter import com.mingliqiye.utils.json.converters.base.getJacksonModule +import com.mingliqiye.utils.json.objects.base.* /** * 基于Jackson的JSON处理实现类,提供JSON字符串解析、格式化、合并、节点操作等功能。 @@ -97,7 +100,6 @@ class JacksonJsonApi : JsonApi { /** * 将对象格式化为JSON字符串 * - * @param `object` 待格式化的对象 * @return 格式化后的JSON字符串 * @throws JsonException 当格式化失败时抛出异常 */ @@ -122,7 +124,6 @@ class JacksonJsonApi : JsonApi { /** * 将对象格式化为美化(带缩进)的JSON字符串 * - * @param `object` 待格式化的对象 * @return 美化后的JSON字符串 * @throws JsonException 当格式化失败时抛出异常 */ @@ -158,7 +159,7 @@ class JacksonJsonApi : JsonApi { return try { objectMapper.readTree(json) true - } catch (e: Exception) { + } catch (_: Exception) { false } } @@ -178,7 +179,7 @@ class JacksonJsonApi : JsonApi { if (node.isObject) { result.setAll(node as ObjectNode) } - } catch (e: Exception) { + } catch (_: Exception) { } } return try { @@ -293,4 +294,79 @@ class JacksonJsonApi : JsonApi { throw JsonException("Failed to update node value", e) } } + + override fun parseJsonItem(json: String): JsonItem { + try { + return getJsonItem(objectMapper.readTree(json)) + } catch (e: Exception) { + throw JsonException("Failed to parseJsonItem", e) + } + } +} + +class JackSonJsonItem : JsonItem { + companion object { + fun getJsonItem(node: JsonNode): JsonItem { + return when (node.nodeType) { + JsonNodeType.OBJECT -> JackSonJsonObject(node) + JsonNodeType.ARRAY -> JackSonJsonArray(node) + JsonNodeType.BOOLEAN -> JackSonJsonBoolean(node) + JsonNodeType.NULL -> JsonNull() + JsonNodeType.NUMBER -> JackSonJsonNumber(node) + JsonNodeType.STRING -> JackSonJsonString(node) + else -> throw IllegalStateException("unknown type ${node.nodeType}") + } + } + } +} + +class JackSonJsonNumber(node: JsonNode) : JsonNumber(node.asText()) +class JackSonJsonBoolean(node: JsonNode) : JsonBoolean(node.asBoolean()) +class JackSonJsonString(node: JsonNode) : JsonString(node.asText()) + + +class JackSonJsonArray(val node: JsonNode) : JsonArray() { + override fun getIndex(index: Int): JsonItem { + return getJsonItem(node.get(index)) + } + + override fun iteratorArray(): Iterator> { + val iteet = node.iterator().withIndex() + return object : Iterator> { + override fun next(): IndexedValue { + val it = iteet.next() + return IndexedValue(it.index, getJsonItem(it.value)) + } + + override fun hasNext(): Boolean { + return iteet.hasNext() + } + + } + } +} + +class JackSonJsonObject(val node: JsonNode) : JsonObject() { + override fun getField(name: String): JsonItem { + return getJsonItem(node.get(name)) + } + + override fun iteratorObject(): Iterator> { + return object : Iterator> { + val it = node.properties().iterator() + override fun next(): Map.Entry { + val utem = it.next() + return object : Map.Entry { + override val key: String + get() = utem.key + override val value: JsonItem + get() = getJsonItem(utem.value) + } + } + + override fun hasNext(): Boolean { + return it.hasNext() + } + } + } } diff --git a/src/main/kotlin/com/mingliqiye/utils/json/api/base/JsonApi.kt b/src/main/kotlin/com/mingliqiye/utils/json/api/base/JsonApi.kt index b6ecc46..b5dc86e 100644 --- a/src/main/kotlin/com/mingliqiye/utils/json/api/base/JsonApi.kt +++ b/src/main/kotlin/com/mingliqiye/utils/json/api/base/JsonApi.kt @@ -16,20 +16,24 @@ * ProjectName mingli-utils * ModuleName mingli-utils.main * CurrentFile JsonApi.kt - * LastUpdate 2026-03-11 08:46:40 + * LastUpdate 2026-03-27 14:19:31 * UpdateUser MingLiPro */ package com.mingliqiye.utils.json.api.base +import com.mingliqiye.utils.exception.JsonParserException import com.mingliqiye.utils.json.api.type.JsonTypeReference import com.mingliqiye.utils.json.api.type.listType import com.mingliqiye.utils.json.converters.base.BaseJsonConverter import com.mingliqiye.utils.json.converters.base.getJsonConverter +import com.mingliqiye.utils.json.objects.base.JsonItem +import okio.IOException import java.io.* import java.nio.file.Files import java.nio.file.Path import java.nio.file.Paths +import kotlin.io.path.readBytes /** * JSON处理接口,提供JSON字符串与Java对象之间的相互转换功能 @@ -46,6 +50,7 @@ interface JsonApi { */ inline fun JsonApi.parse(json: String): T = parse(json, object : JsonTypeReference() {}) + /** * 将JSON字节数组解析为指定泛型类型对象 * @@ -248,6 +253,7 @@ interface JsonApi { return parseFrom(path.toFile(), type) } + /** * 从文件读取JSON并解析为指定泛型类型对象 * @@ -478,9 +484,123 @@ interface JsonApi { */ fun updateNodeValue(json: String, path: String, newValue: Any): String + /** + * 将任意对象转换为指定类型的对象 + * + * @param source 源对象,可以是 JSON 字符串、JsonItem 或其他对象 + * @param destinationClass 目标类型的 Class 对象 + * @return 转换后的目标类型对象 + * + * @param 目标类型泛型参数 + */ fun convert(source: Any, destinationClass: Class): D + /** + * 将任意对象转换为指定泛型类型的对象 + * 用于处理带泛型的复杂类型,如 List、Map 等 + * + * @param source 源对象,可以是 JSON 字符串、JsonItem 或其他对象 + * @param destinationType 目标类型的类型引用,包含泛型信息 + * @return 转换后的目标类型对象 + * + * @param 目标类型泛型参数 + * + * 使用示例: + * ``` + * val typeRef = object : JsonTypeReference>() {} + * val userList = converter.convert(jsonString, typeRef) + * ``` + */ fun convert(source: Any, destinationType: JsonTypeReference): D + /** + * 注册自定义的 JSON 转换器 + * 用于处理特定类型的自定义序列化和反序列化逻辑 + * + * @param c 自定义的 JSON 转换器实例 + * + * 使用示例: + * ``` + * converter.addJsonConverter(DateJsonConverter()) + * converter.addJsonConverter(LocalDateTimeJsonConverter()) + * ``` + */ fun addJsonConverter(c: BaseJsonConverter<*, *>) + + /** + * 将 JSON 字符串解析为 JsonItem 对象 + * + * @param json JSON 格式的字符串 + * @return 解析后的 JsonItem 对象,可以是 JsonObject、JsonArray 或 JsonValue + * @throws JsonParserException 当 JSON 格式错误时抛出 + */ + fun parseJsonItem(json: String): JsonItem + + /** + * 将字节数组解析为 JsonItem 对象 + * 字节数组会被转换为字符串后再解析 + * + * @param byte JSON 格式的字节数组(通常是 UTF-8 编码) + * @return 解析后的 JsonItem 对象 + * @throws JsonParserException 当 JSON 格式错误时抛出 + */ + fun parseJsonItem(byte: ByteArray): JsonItem { + return parseJsonItem(String(byte)) + } + + /** + * 将输入流解析为 JsonItem 对象 + * 会自动关闭输入流 + * + * @param inputStream JSON 数据的输入流 + * @return 解析后的 JsonItem 对象 + * @throws JsonParserException 当 JSON 格式错误时抛出 + * @throws IOException 当读取输入流失败时抛出 + * + * 使用示例: + * ``` + * val inputStream = FileInputStream("data.json") + * val jsonItem = converter.parseJsonItem(inputStream) + * ``` + */ + fun parseJsonItem(inputStream: InputStream): JsonItem { + inputStream.use { + return parseJsonItem(it.readAllBytes()) + } + } + + /** + * 将文件解析为 JsonItem 对象 + * + * @param file 包含 JSON 数据的文件 + * @return 解析后的 JsonItem 对象 + * @throws IOException 当读取文件失败时抛出 + * + * 使用示例: + * ``` + * val file = File("config.json") + * val jsonItem = converter.parseJsonItem(file) + * ``` + */ + @Throws(IOException::class) + fun parseJsonItem(file: File): JsonItem { + return parseJsonItem(file.readBytes()) + } + + /** + * 将文件路径解析为 JsonItem 对象 + * + * @param path 包含 JSON 数据的文件路径 + * @return 解析后的 JsonItem 对象 + * @throws IOException 当读取文件失败时抛出 + * + * 使用示例: + * ``` + * val path = Paths.get("data/user.json") + * val jsonItem = converter.parseJsonItem(path) + * ``` + */ + fun parseJsonItem(path: Path): JsonItem { + return parseJsonItem(path.readBytes()) + } } diff --git a/src/main/kotlin/com/mingliqiye/utils/json/objects/base/JsonObject.kt b/src/main/kotlin/com/mingliqiye/utils/json/objects/base/JsonObject.kt new file mode 100644 index 0000000..369e5bc --- /dev/null +++ b/src/main/kotlin/com/mingliqiye/utils/json/objects/base/JsonObject.kt @@ -0,0 +1,279 @@ +/* + * Copyright 2026 mingliqiye + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * ProjectName mingli-utils + * ModuleName mingli-utils.main + * CurrentFile JsonObject.kt + * LastUpdate 2026-06-21 10:40:58 + * UpdateUser MingLiPro + */ + +package com.mingliqiye.utils.json.objects.base + +import java.math.BigDecimal +import java.math.BigInteger +import java.util.* + +/** + * JSON 元素接口,定义所有 JSON 数据类型的通用操作 + */ +interface JsonItem { + /** + * 作为 JSON 对象返回 + * @throws IllegalStateException 如果不是对象类型 + */ + fun asObject(): JsonObject { + throw IllegalStateException("Current JSON element is ${name()} not a Object") + } + + /** + * 作为 JSON 数组返回 + * @throws IllegalStateException 如果不是数组类型 + */ + fun asArray(): JsonArray { + throw IllegalStateException("Current JSON element is ${name()} not a Array") + } + + /** + * 作为字符串返回 + * @throws IllegalStateException 如果不是字符串类型 + */ + fun asString(): String { + throw IllegalStateException("Current JSON element is ${name()} not a String") + } + + /** + * 作为布尔值返回 + * @throws IllegalStateException 如果不是布尔类型 + */ + fun asBoolean(): Boolean { + throw IllegalStateException("Current JSON element is ${name()} not a Boolean") + } + + /** + * 作为数字返回 + * @throws IllegalStateException 如果不是数字类型 + */ + fun asNumber(): JsonNumber { + throw IllegalStateException("Current JSON element is ${name()} not a Number") + } + + /** + * 转换为 List 集合 + * @throws IllegalStateException 如果不是数组类型 + */ + fun toList(): List { + val it = asArray().iteratorArray() + val list = LinkedList() + it.forEach { item -> list.add(item.value) } + return list + } + + /** + * 转换为 Map 集合 + * @throws IllegalStateException 如果不是对象类型 + */ + fun toMap(): Map { + val it = asObject().iteratorObject() + val map = LinkedHashMap() + it.forEach { item -> map[item.key] = item.value } + return map + } + + /** 是否为 null */ + fun isNull(): Boolean = false + + /** 是否为布尔值 */ + fun isBoolean(): Boolean = false + + /** 是否为数字 */ + fun isNumber(): Boolean = false + + /** 是否为字符串 */ + fun isString(): Boolean = false + + /** 是否为对象 */ + fun isObject(): Boolean = false + + /** 是否为数组 */ + fun isArray(): Boolean = false + + /** 返回当前元素的类型名称 */ + fun name(): String = "Any" + + /** 根据索引获取元素(数组专用) */ + fun get(index: Int): JsonItem = getIndex(index) + + /** 根据字段名获取元素(对象专用) */ + fun get(fieldName: String): JsonItem = getField(fieldName) + + /** + * 根据索引获取元素 + * @throws IllegalStateException 如果不是数组类型 + */ + fun getIndex(index: Int): JsonItem { + throw IllegalStateException("Current JSON element is ${name()} not a Array") + } + + /** + * 根据字段名获取元素 + * @throws IllegalStateException 如果不是对象类型 + */ + fun getField(name: String): JsonItem { + throw IllegalStateException("Current JSON element is ${name()} not a Object") + } + + /** + * 遍历数组元素 + * @param consumer 接收索引和元素的消费者函数 + */ + fun forEachArray(consumer: (Int, JsonItem) -> Unit) { + iteratorArray().forEach { + consumer(it.index, it.value) + } + } + + /** + * 遍历对象字段 + * @param consumer 接收字段名和值的消费者函数 + */ + fun forEachObject(consumer: (String, JsonItem) -> Unit) { + iteratorObject().forEach { + consumer(it.key, it.value) + } + } + + /** + * 获取数组迭代器 + * @throws IllegalStateException 如果不是数组类型 + */ + fun iteratorArray(): Iterator> { + throw IllegalStateException("Current JSON element is ${name()} not a Array") + } + + /** + * 获取对象迭代器 + * @throws IllegalStateException 如果不是对象类型 + */ + fun iteratorObject(): Iterator> { + throw IllegalStateException("Current JSON element is ${name()} not a Object") + } +} + +/** + * JSON 对象抽象类 + * 表示键值对形式的 JSON 对象 {} + */ +abstract class JsonObject : JsonItem { + override fun isObject(): Boolean = true + override fun name(): String = "object" + override fun asObject(): JsonObject = this + override fun toString(): String = StringBuilder().apply { + append("{") + iteratorObject().forEach { + append(it.key) + append("=") + append(it.value) + append(",") + } + deleteCharAt(length - 1) + append("}") + }.toString() +} + +/** + * JSON 数组抽象类 + * 表示有序的 JSON 数组 [] + */ +abstract class JsonArray : JsonItem { + override fun isArray(): Boolean = true + override fun name(): String = "array" + override fun asArray() = this + override fun toString(): String = StringBuilder().apply { + append("[") + iteratorArray().forEach { + append(it.value) + append(",") + } + deleteCharAt(length - 1) + append("]") + }.toString() +} + +/** + * JSON null 类型 + * 表示 JSON 中的 null 值 + */ +open class JsonNull : JsonItem { + override fun isNull(): Boolean = true + override fun name(): String = "null" + override fun toString(): String = "null" +} + +/** + * JSON 数字类型 + * 表示 JSON 中的数字,继承自 Number 以便转换为各种数值类型 + * @param numberString 数字的字符串表示形式 + */ +open class JsonNumber(val numberString: String) : JsonItem, Number() { + override fun isNumber(): Boolean = true + override fun name(): String = "number" + override fun asNumber(): JsonNumber = this + override fun toDouble(): Double = numberString.toDouble() + override fun toFloat(): Float = numberString.toFloat() + override fun toLong(): Long = numberString.toLong() + override fun toInt(): Int = numberString.toInt() + override fun toShort(): Short = numberString.toShort() + override fun toByte(): Byte = numberString.toByte() + + /** 转换为 BigDecimal */ + open fun toBigDecimal(): BigDecimal = numberString.toBigDecimal() + + /** 转换为指定精度的 BigDecimal */ + open fun toBigDecimal(scale: Int): BigDecimal = numberString.toBigDecimal().setScale(scale) + + /** 转换为 BigInteger */ + open fun toBigInteger(): BigInteger = numberString.toBigInteger() + + override fun toString(): String = numberString +} + +/** + * JSON 字符串类型 + * @param value 字符串值 + */ +open class JsonString(val value: String) : JsonItem { + override fun isString(): Boolean = true + override fun name(): String = "string" + override fun asString(): String { + return value + } + + override fun toString(): String = value +} + +/** + * JSON 布尔类型 + * @param value 布尔值 + */ +open class JsonBoolean(val value: Boolean) : JsonItem { + override fun isBoolean(): Boolean = true + override fun name(): String = "boolean" + override fun asBoolean(): Boolean { + return value + } + + override fun toString(): String = value.toString() +} diff --git a/src/main/kotlin/com/mingliqiye/utils/math/MathUtils.kt b/src/main/kotlin/com/mingliqiye/utils/math/MathUtils.kt index fc61a27..6a769ab 100644 --- a/src/main/kotlin/com/mingliqiye/utils/math/MathUtils.kt +++ b/src/main/kotlin/com/mingliqiye/utils/math/MathUtils.kt @@ -16,7 +16,7 @@ * ProjectName mingli-utils * ModuleName mingli-utils.main * CurrentFile MathUtils.kt - * LastUpdate 2026-02-05 10:25:32 + * LastUpdate 2026-06-21 10:40:58 * UpdateUser MingLiPro */ @file:JvmName("MathUtils") @@ -167,7 +167,7 @@ operator fun BigDecimal.div(value: BigDecimal): BigDecimal = this.divide(value) * @return 除法运算结果 */ operator fun BigDecimal.div( - value: Long + value: Long, ): BigDecimal = this.divide(BigDecimal(value)) /** @@ -176,7 +176,7 @@ operator fun BigDecimal.div( * @return 除法运算结果 */ operator fun BigDecimal.div( - value: Int + value: Int, ): BigDecimal = this.divide(BigDecimal(value)) /** @@ -185,7 +185,7 @@ operator fun BigDecimal.div( * @return 除法运算结果 */ operator fun BigDecimal.div( - value: Double + value: Double, ): BigDecimal = this.divide(BigDecimal(value.toString())) /** @@ -194,7 +194,7 @@ operator fun BigDecimal.div( * @return 除法运算结果 */ operator fun BigDecimal.div( - value: Float + value: Float, ): BigDecimal = this.divide(BigDecimal(value.toString())) /** @@ -203,7 +203,7 @@ operator fun BigDecimal.div( * @return 除法运算结果 */ operator fun BigDecimal.div( - value: BigInteger + value: BigInteger, ): BigDecimal = this.divide(BigDecimal(value)) /** @@ -372,3 +372,63 @@ fun Number.toBigInteger(): BigInteger = BigInteger(this.toString()) * @return 返回与当前 Number 对象等值且具有指定精度的 BigDecimal 实例。 */ fun Number.toBigDecimal(scale: Int): BigDecimal = BigDecimal(this.toString()).setScale(scale) + + +/** + * Number 与 BigDecimal 的加法运算符重载 + * + * 允许任意数字类型(Int、Long、Double等)直接与 BigDecimal 进行加法运算 + * 例如:val result = 100 + BigDecimal("10.5") + * + * @param value 要相加的 BigDecimal 值 + * @return 相加后的 BigDecimal 结果 + * + * 注意:通过 toString() 转换可能会丢失精度(如 Double 的精度问题) + */ +operator fun Number.plus(value: BigDecimal): BigDecimal = BigDecimal(this.toString()).plus(value) + +/** + * Number 与 BigDecimal 的减法运算符重载 + * + * 允许任意数字类型直接与 BigDecimal 进行减法运算 + * 例如:val result = 100 - BigDecimal("10.5") + * + * @param value 要相减的 BigDecimal 值 + * @return 相减后的 BigDecimal 结果 + */ +operator fun Number.minus(value: BigDecimal): BigDecimal = BigDecimal(this.toString()).minus(value) + +/** + * Number 与 BigDecimal 的乘法运算符重载 + * + * 允许任意数字类型直接与 BigDecimal 进行乘法运算 + * 例如:val result = 100 * BigDecimal("10.5") + * + * @param value 要相乘的 BigDecimal 值 + * @return 相乘后的 BigDecimal 结果 + */ +operator fun Number.times(value: BigDecimal): BigDecimal = BigDecimal(this.toString()).times(value) + +/** + * Number 与 BigDecimal 的除法运算符重载 + * + * 允许任意数字类型直接与 BigDecimal 进行除法运算 + * 例如:val result = 100 / BigDecimal("10.5") + * + * @param value 要相除的 BigDecimal 值(除数) + * @return 相除后的 BigDecimal 结果 + * + * 注意:如果除不尽会抛出 ArithmeticException,建议使用 divide() 方法指定精度 + */ +operator fun Number.div(value: BigDecimal): BigDecimal = BigDecimal(this.toString()).div(value) + +/** + * Number 与 BigDecimal 的取余运算符重载 + * + * 允许任意数字类型直接与 BigDecimal 进行取余运算 + * 例如:val result = 100 % BigDecimal("10.5") + * + * @param value 取余运算的 BigDecimal 值 + * @return 取余后的 BigDecimal 结果 + */ +operator fun Number.rem(value: BigDecimal): BigDecimal = BigDecimal(this.toString()).rem(value) diff --git a/src/main/kotlin/com/mingliqiye/utils/metadata/MetaData.kt b/src/main/kotlin/com/mingliqiye/utils/metadata/MetaData.kt index fe36a01..30820b1 100644 --- a/src/main/kotlin/com/mingliqiye/utils/metadata/MetaData.kt +++ b/src/main/kotlin/com/mingliqiye/utils/metadata/MetaData.kt @@ -16,7 +16,7 @@ * ProjectName mingli-utils * ModuleName mingli-utils.main * CurrentFile MetaData.kt - * LastUpdate 2026-03-11 08:46:40 + * LastUpdate 2026-05-22 13:27:28 * UpdateUser MingLiPro */ @file:JvmName("MetaData") @@ -26,8 +26,10 @@ package com.mingliqiye.utils.metadata import com.mingliqiye.utils.resource.ResourceUtils import java.util.stream.Collectors.toMap +class MetaDataResource + fun getMetaData(): Map { - return ResourceUtils.getStringResource("/META-INF/meta-data").split("\n").stream().map { + return ResourceUtils.getResourceAsString("/META-INF/meta-data").split("\n").stream().map { if (it.isBlank()) { return@map null } diff --git a/src/main/kotlin/com/mingliqiye/utils/netty/ClientScheduleReconnect.kt b/src/main/kotlin/com/mingliqiye/utils/netty/ClientScheduleReconnect.kt index ead9f4e..b6042ce 100644 --- a/src/main/kotlin/com/mingliqiye/utils/netty/ClientScheduleReconnect.kt +++ b/src/main/kotlin/com/mingliqiye/utils/netty/ClientScheduleReconnect.kt @@ -16,7 +16,7 @@ * ProjectName mingli-utils * ModuleName mingli-utils.main * CurrentFile ClientScheduleReconnect.kt - * LastUpdate 2026-01-20 08:10:15 + * LastUpdate 2026-06-21 10:40:58 * UpdateUser MingLiPro */ @@ -119,21 +119,20 @@ abstract class ClientScheduleReconnect { * 停止连接时的日志记录回调 */ abstract fun onStoppedLog() + abstract fun onConnectClosed() /** * 执行连接操作 * @return ChannelFuture 连接结果的异步操作对象 */ - abstract fun doConnect(): ChannelFuture + abstract fun doConnect(bootstrap: Bootstrap): ChannelFuture /** * 初始化引导配置 * @param bootstrap 要初始化的引导配置对象 */ - open fun initBootstrap(bootstrap: Bootstrap) { - - } + abstract fun initBootstrap(bootstrap: Bootstrap) /** * 更新重连延迟配置 @@ -151,7 +150,7 @@ abstract class ClientScheduleReconnect { * 执行连接操作,设置连接完成监听器 */ open fun connect() { - doConnect().addListener(object : ChannelFutureListener { + doConnect(bootstrap).addListener(object : ChannelFutureListener { override fun operationComplete(future: ChannelFuture) { if (future.isSuccess) { onConnected(future.channel()) @@ -165,6 +164,7 @@ abstract class ClientScheduleReconnect { /** * 停止连接并标记为停止状态 */ + @Deprecated("use close()", ReplaceWith("close()")) open fun stop() { isStop = true disConnect() @@ -178,6 +178,14 @@ abstract class ClientScheduleReconnect { channel = null } + /** + * 停止连接并标记为停止状态 + */ + open fun close() { + isStop = true + disConnect() + } + /** * 调度下一次重连操作 */ diff --git a/src/main/kotlin/com/mingliqiye/utils/netty/NamedMultiThreadIoEventLoopGroup.kt b/src/main/kotlin/com/mingliqiye/utils/netty/NamedMultiThreadIoEventLoopGroup.kt new file mode 100644 index 0000000..0966000 --- /dev/null +++ b/src/main/kotlin/com/mingliqiye/utils/netty/NamedMultiThreadIoEventLoopGroup.kt @@ -0,0 +1,52 @@ +/* + * Copyright 2026 mingliqiye + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * ProjectName mingli-utils + * ModuleName mingli-utils.main + * CurrentFile NamedMultiThreadIoEventLoopGroup.kt + * LastUpdate 2026-06-20 22:01:50 + * UpdateUser MingLiPro + */ + +package com.mingliqiye.utils.netty + +import com.mingliqiye.utils.system.availableProcessors +import io.netty.channel.MultiThreadIoEventLoopGroup +import io.netty.channel.nio.NioIoHandler +import java.nio.channels.spi.SelectorProvider +import java.text.MessageFormat + +/** + * 命名的NIO事件循环组,继承自NioEventLoopGroup + * 用于创建具有自定义命名规则的线程池,便于线程管理和调试 + * + * @param name 线程池的名称,默认为"NioEventLoopGroup" + * @param template 线程名称的格式模板,默认为"{0}-{2}-{3}",{0} 名字 {1} 类名 {2} 线程池序号 {3} 线程池内线程的序号 + * @param nThreads 线程数量,默认为核心数的2倍 + * @param selectorProvider NIO 提供者 + */ +open class NamedMultiThreadIoEventLoopGroup( + val template: String = "{0}-{2}-{3}", + val name: String = "NamedMultiThreadIoEventLoopGroup", + nThreads: Int = availableProcessors * 2, + selectorProvider: SelectorProvider = SelectorProvider.provider(), +) : + MultiThreadIoEventLoopGroup( + nThreads, + NamedThreadFactory( + getName = { a, b, c -> MessageFormat.format(template, name, a, b, c) } + ), + NioIoHandler.newFactory(selectorProvider), + ) diff --git a/src/main/kotlin/com/mingliqiye/utils/netty/NamedNioEventLoopGroup.kt b/src/main/kotlin/com/mingliqiye/utils/netty/NamedNioEventLoopGroup.kt index 3c32db6..0514bf0 100644 --- a/src/main/kotlin/com/mingliqiye/utils/netty/NamedNioEventLoopGroup.kt +++ b/src/main/kotlin/com/mingliqiye/utils/netty/NamedNioEventLoopGroup.kt @@ -16,7 +16,7 @@ * ProjectName mingli-utils * ModuleName mingli-utils.main * CurrentFile NamedNioEventLoopGroup.kt - * LastUpdate 2026-02-05 10:20:31 + * LastUpdate 2026-06-20 22:01:50 * UpdateUser MingLiPro */ @@ -37,7 +37,7 @@ import java.text.MessageFormat open class NamedNioEventLoopGroup( val template: String = "{0}-{2}-{3}", val name: String = "NioEventLoopGroup", - nThreads: Int = availableProcessors * 2 + nThreads: Int = availableProcessors * 2, ) : NioEventLoopGroup( nThreads, diff --git a/src/main/kotlin/com/mingliqiye/utils/netty/NettyUtils.kt b/src/main/kotlin/com/mingliqiye/utils/netty/NettyUtils.kt index bcf99ab..dce47be 100644 --- a/src/main/kotlin/com/mingliqiye/utils/netty/NettyUtils.kt +++ b/src/main/kotlin/com/mingliqiye/utils/netty/NettyUtils.kt @@ -16,7 +16,7 @@ * ProjectName mingli-utils * ModuleName mingli-utils.main * CurrentFile NettyUtils.kt - * LastUpdate 2026-01-31 20:50:41 + * LastUpdate 2026-06-20 22:18:39 * UpdateUser MingLiPro */ @@ -30,7 +30,10 @@ import io.netty.bootstrap.ServerBootstrap import io.netty.buffer.ByteBuf import io.netty.buffer.Unpooled import io.netty.channel.Channel +import io.netty.channel.ChannelFuture import io.netty.channel.ChannelInitializer +import io.netty.channel.ChannelPipeline +import io.netty.util.concurrent.Future import java.nio.ByteBuffer import java.nio.charset.Charset @@ -106,6 +109,26 @@ fun ServerBootstrap.channelInitializer(funa: P1Function): ServerBootstr return this } +/** + * 为ServerBootstrap配置子管道初始化器 + * + * 该函数用于设置ServerBootstrap的childHandler,当新的客户端连接建立时, + * 会调用提供的函数来初始化子管道 + * + * @receiver ServerBootstrap 需要配置的服务器引导程序实例 + * @param funa 用于初始化管道的回调函数,接收ChannelPipeline作为参数 + * @return ServerBootstrap 返回当前实例以支持链式调用 + */ +@JvmName("pipelineInit") +fun ServerBootstrap.pipelineInitializer(funa: P1Function): ServerBootstrap { + this.childHandler(object : ChannelInitializer() { + override fun initChannel(ch: Channel) { + funa.call(ch.pipeline()) + } + }) + return this +} + /** * 为Bootstrap配置通道初始化器 * @@ -126,6 +149,26 @@ fun Bootstrap.channelInitializer(funa: P1Function): Bootstrap { return this } +/** + * 为Bootstrap配置管道初始化器 + * + * 该函数用于设置Bootstrap的handler,当客户端连接建立时, + * 会调用提供的函数来初始化管道 + * + * @receiver Bootstrap 需要配置的客户端引导程序实例 + * @param funa 用于初始化管道的回调函数,接收ChannelPipeline作为参数 + * @return Bootstrap 返回当前实例以支持链式调用 + */ +@JvmName("pipelineInit") +fun Bootstrap.pipelineInitializer(funa: P1Function): Bootstrap { + this.handler(object : ChannelInitializer() { + override fun initChannel(ch: Channel) { + funa.call(ch.pipeline()) + } + }) + return this +} + /** * 将字符串转换为Netty的ByteBuf对象 * @@ -248,7 +291,7 @@ fun Channel.closeSafely() { /** * 检查通道是否处于活跃状态 */ -val Channel.isActive: Boolean +val Channel.isActived: Boolean get() = isOpen && isActive /** @@ -288,3 +331,8 @@ fun ByteBuf.tryRelease(): Boolean { false } } + +fun ChannelFuture.addChannelListener( + listener: (Future) -> Unit, +) { +} diff --git a/src/main/kotlin/com/mingliqiye/utils/network/NetworkEndpoint.kt b/src/main/kotlin/com/mingliqiye/utils/network/NetworkEndpoint.kt index 1abfc71..272dc8d 100644 --- a/src/main/kotlin/com/mingliqiye/utils/network/NetworkEndpoint.kt +++ b/src/main/kotlin/com/mingliqiye/utils/network/NetworkEndpoint.kt @@ -16,7 +16,7 @@ * ProjectName mingli-utils * ModuleName mingli-utils.main * CurrentFile NetworkEndpoint.kt - * LastUpdate 2026-02-05 10:20:31 + * LastUpdate 2026-05-23 11:00:33 * UpdateUser MingLiPro */ @@ -24,6 +24,7 @@ package com.mingliqiye.utils.network import java.io.Serializable import java.net.InetSocketAddress +import java.net.SocketAddress import java.nio.ByteBuffer /** @@ -34,7 +35,7 @@ import java.nio.ByteBuffer * @see java.net.InetSocketAddress */ class NetworkEndpoint private constructor( - val networkAddress: NetworkAddress, val networkPort: NetworkPort + val networkAddress: NetworkAddress, val networkPort: NetworkPort, ) : Serializable, InetSocketAddress(networkAddress.toInetAddress(), networkPort.port) { @@ -47,10 +48,13 @@ class NetworkEndpoint private constructor( * @see InetSocketAddress */ @JvmStatic - fun of(address: InetSocketAddress): NetworkEndpoint { - return NetworkEndpoint( - NetworkAddress.of(address.hostString), NetworkPort(address.port) - ) + fun of(address: SocketAddress): NetworkEndpoint { + if (address is InetSocketAddress) { + return NetworkEndpoint( + NetworkAddress.of(address.hostString), NetworkPort(address.port) + ) + } + throw ClassCastException("${address.javaClass} cannot be cast to InetSocketAddress to NetworkEndpoint") } /** @@ -117,6 +121,11 @@ class NetworkEndpoint private constructor( s.take(lastColonIndex), s.substring(lastColonIndex + 1).toInt() ) } + + val SocketAddress.networkAddress: NetworkEndpoint + get() = of(this) + val SocketAddress.hostPortString: String + get() = networkAddress.toHostPortString() } /** diff --git a/src/main/kotlin/com/mingliqiye/utils/random/RandomBytes.kt b/src/main/kotlin/com/mingliqiye/utils/random/RandomBytes.kt index d4842d6..b1bf3a6 100644 --- a/src/main/kotlin/com/mingliqiye/utils/random/RandomBytes.kt +++ b/src/main/kotlin/com/mingliqiye/utils/random/RandomBytes.kt @@ -16,73 +16,292 @@ * ProjectName mingli-utils * ModuleName mingli-utils.main * CurrentFile RandomBytes.kt - * LastUpdate 2026-01-28 10:47:13 + * LastUpdate 2026-03-27 14:18:30 * UpdateUser MingLiPro */ -@file:JvmName("RandomBytes") - package com.mingliqiye.utils.random +import java.security.SecureRandom +import kotlin.random.Random +import kotlin.random.nextInt +import kotlin.random.nextLong + /** - * 生成指定长度的随机字节数组 - * @param length 数组长度 - * @return 包含随机字节的数组 + * Random对象 - 提供各种随机数据生成方法 + * 使用SecureRandom确保密码学安全,同时提供便捷的随机数生成接口 */ -fun randomBytes(length: Int): ByteArray { - val bytes = ByteArray(length) - for (i in 0.. Array.randomItem(): T = this[nextInt(0.. Collection.randomItem(): T = this.elementAt(nextInt(0.. max) { - val t = min - min = max - max = t - } - if (min == max) { - return min - } - return secureRandom.nextInt(min, max) -} - -/** - * 生成指定范围内的随机整数 - * @param min 最小值(包含) - * @param max 最大值(包含) - * @return 随机整数 - */ -fun randomInt(min: Int, max: Int): Int { - var max = max - return randomIntNoHave(min, ++max) -} diff --git a/src/main/kotlin/com/mingliqiye/utils/random/RandomString.kt b/src/main/kotlin/com/mingliqiye/utils/random/RandomString.kt deleted file mode 100644 index 74ee18c..0000000 --- a/src/main/kotlin/com/mingliqiye/utils/random/RandomString.kt +++ /dev/null @@ -1,54 +0,0 @@ -/* - * Copyright 2026 mingliqiye - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * ProjectName mingli-utils - * ModuleName mingli-utils.main - * CurrentFile RandomString.kt - * LastUpdate 2026-02-05 11:12:36 - * UpdateUser MingLiPro - */ -@file:JvmName("RandomString") - -package com.mingliqiye.utils.random - -/** - * 生成指定长度和字符集的随机字符串 - * - * @param length 要生成的随机字符串长度 - * @param chars 用于生成随机字符串的字符集 - * @return 指定长度的随机字符串 - */ -fun randomString(length: Int, chars: String): String { - val charsd: Array = chars.split("".toRegex()).filter { !it.isEmpty() }.toTypedArray().println() - val sb = StringBuilder(length) - // 循环生成随机字符并拼接 - for (i in 0.. AnnotatedElement.getAnnotation() = this.getAnnotation(T::class.java) + inline fun T.ktClass(): KClass = T::class + var KMutableProperty.value: T + get() = this.getter.call() + set(t: T) = this.setter.call(t) + val KProperty.javaGetter: Method + get() = this.getter.javaMethod!! + val KMutableProperty.javaSetter: Method + get() = this.getter.javaMethod!! + val KFunction.java: Method + get() = this.javaMethod!! + + fun getStackFrame(skip: Long = 0, limit: Long = 0): List { + return walker.walk { + it.skip(skip + 2).ifOr(limit == 0L) { + limit(limit) + }.toList() + } + } +} diff --git a/src/main/kotlin/com/mingliqiye/utils/reflect/kotlin/KotlinReflect.kt b/src/main/kotlin/com/mingliqiye/utils/reflect/kotlin/KotlinReflect.kt deleted file mode 100644 index d367614..0000000 --- a/src/main/kotlin/com/mingliqiye/utils/reflect/kotlin/KotlinReflect.kt +++ /dev/null @@ -1,263 +0,0 @@ -/* - * Copyright 2026 mingliqiye - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * ProjectName mingli-utils - * ModuleName mingli-utils.main - * CurrentFile KotlinReflect.kt - * LastUpdate 2026-03-11 08:16:32 - * UpdateUser MingLiPro - */ - -@file:JvmName("KotlinReflect") - -package com.mingliqiye.utils.reflect.kotlin - -import kotlin.reflect.KClass -import kotlin.reflect.KFunction -import kotlin.reflect.KType -import kotlin.reflect.full.* -import kotlin.reflect.jvm.isAccessible - -/** - * 获取实例的 KClass - */ -inline fun T.kClass(): KClass = T::class - -/** - * 获取实例的 Java Class - */ -inline fun T.kClassJava(): Class = T::class.java - -/** - * 创建实例(通过无参构造函数) - */ -inline fun createInstance(): T = T::class.createInstance() - -/** - * 创建实例(通过主构造函数,提供参数) - */ -inline fun createInstance(vararg args: Any?): T? { - val kClass = T::class - val constructor = kClass.primaryConstructor - return constructor?.let { - it.isAccessible = true - it.call(*args) - } -} - -/** - * 获取所有父类(包括接口) - */ -inline fun T.superClasses(): Collection> = T::class.allSuperclasses - -/** - * 判断是否是某个类的子类 - */ -inline fun T.isSubclassOf(): Boolean = T::class.isSubclassOf(S::class) - -/** - * 获取伴生对象实例 - */ -inline fun T.companion(): Any? = T::class.companionObject?.objectInstance - -/** - * 获取对象的所有属性名 - */ -inline fun T.propertyNames(): List = T::class.memberProperties.map { it.name } - -/** - * 获取属性值 - */ -inline fun T.getPropertyValue(name: String): Any? { - val property = T::class.memberProperties.find { it.name == name } - return if (property != null) { - property.isAccessible = true - property.get(this) - } else null -} - -/** - * 设置属性值(仅适用于 var 属性) - */ -inline fun T.setPropertyValue(name: String, value: Any?): Boolean { - val property = T::class.memberProperties.find { it.name == name } - return if (property is kotlin.reflect.KMutableProperty<*>) { - property.isAccessible = true - property.setter.call(this, value) - true - } else false -} - -/** - * 批量获取属性值 - */ -inline fun T.getPropertyValues(vararg names: String): Map { - val properties = T::class.memberProperties - return names.associateWith { name -> - properties.find { it.name == name }?.let { - it.isAccessible = true - it.get(this) - } - } -} - -/** - * 获取所有属性及其值 - */ -inline fun T.getAllPropertyValues(): Map { - return T::class.memberProperties.associate { prop -> - prop.isAccessible = true - prop.name to prop.get(this) - } -} - -/** - * 调用对象的方法 - */ -inline fun T.callMethod(name: String, vararg args: Any?): Any? { - val function = T::class.functions.find { it.name == name } - return function?.let { - it.isAccessible = true - it.call(this, *args) - } -} - -/** - * 调用静态方法(通过伴生对象) - */ -inline fun T.callStaticMethod(name: String, vararg args: Any?): Any? { - val companion = T::class.companionObject?.objectInstance - val function = companion?.let { - it::class.functions.find { func -> func.name == name } - } - return function?.let { - it.isAccessible = true - it.call(companion, *args) - } -} - -/** - * 获取所有方法名 - */ -inline fun T.methodNames(): List = T::class.functions.map { it.name } - -/** - * 检查类是否有特定注解 - */ -inline fun T.hasAnnotation(): Boolean = T::class.hasAnnotation() - -/** - * 获取所有带有特定注解的属性 - */ -inline fun T.propertiesWithAnnotation(): List { - return T::class.memberProperties.filter { it.hasAnnotation() }.map { it.name } -} - -/** - * 获取所有带有特定注解的方法 - */ -inline fun T.methodsWithAnnotation(): List { - return T::class.functions.filter { it.hasAnnotation() }.map { it.name } -} - -/** - * 获取泛型类型参数 - */ -inline fun T.genericType(): KType = T::class.starProjectedType - -/** - * 检查类型是否匹配 - */ -inline fun T.isInstanceOf(instance: Any): Boolean = T::class.isInstance(instance) - -// ==================== Java 互操作 ==================== - -/** - * 获取对应的 Java 方法 - */ -inline fun T.getJavaMethod(name: String, vararg paramTypes: Class<*>): java.lang.reflect.Method? { - return T::class.java.getDeclaredMethod(name, *paramTypes).apply { - isAccessible = true - } -} - -/** - * 获取对应的 Java 字段 - */ -inline fun T.getJavaField(name: String): java.lang.reflect.Field? { - return T::class.java.getDeclaredField(name).apply { - isAccessible = true - } -} - -/** - * 调用 Java 方法 - */ -inline fun T.callJavaMethod(name: String, vararg args: Any?): Any? { - val method = T::class.java.methods.find { it.name == name } - return method?.let { - it.isAccessible = true - it.invoke(this, *args) - } -} - -/** - * 获取所有构造函数 - */ -inline fun T.constructors(): List> = T::class.constructors.toList() - -/** - * 通过构造函数索引创建实例 - */ -inline fun createInstanceByIndex(index: Int, vararg args: Any?): T? { - val constructors = T::class.constructors.toList() - return if (index < constructors.size) { - constructors[index].apply { isAccessible = true }.call(*args) - } else null -} - -/** - * 比较两个对象的属性值 - */ -inline fun T.compareWith(other: T, vararg properties: String): Map> { - val result = mutableMapOf>() - val props = T::class.memberProperties.associateBy { it.name } - - properties.forEach { propName -> - props[propName]?.let { prop -> - prop.isAccessible = true - result[propName] = Pair(prop.get(this), prop.get(other)) - } - } - return result -} - -/** - * 获取单例对象实例(适用于 object 声明) - */ -inline fun getSingletonInstance(): T? { - return (T::class.objectInstance as? T) -} - -/** - * 检查是否是单例对象 - */ -inline fun T.isSingleton(): Boolean = T::class.objectInstance != null - -/** - * 获取类的所有扩展函数 - */ -inline fun T.extensionFunctions(): Collection> = - T::class.declaredMemberExtensionFunctions diff --git a/src/main/kotlin/com/mingliqiye/utils/resource/ResourceUtils.kt b/src/main/kotlin/com/mingliqiye/utils/resource/ResourceUtils.kt index a2e03c1..1310586 100644 --- a/src/main/kotlin/com/mingliqiye/utils/resource/ResourceUtils.kt +++ b/src/main/kotlin/com/mingliqiye/utils/resource/ResourceUtils.kt @@ -16,120 +16,142 @@ * ProjectName mingli-utils * ModuleName mingli-utils.main * CurrentFile ResourceUtils.kt - * LastUpdate 2026-02-05 11:09:16 + * LastUpdate 2026-05-23 10:28:28 * UpdateUser MingLiPro */ package com.mingliqiye.utils.resource -import java.io.IOException +import com.mingliqiye.utils.exception.NotFoundResourceException +import java.nio.charset.Charset -/** - * 工具类,用于从类路径中加载资源文件。 - */ object ResourceUtils { + /** - * 从默认类路径中加载指定名称的资源文件,并以字节数组形式返回。 + * 从类路径中读取资源文件并返回字节数组(使用 reified 类型参数) * - * @param resourceName 资源文件的名称(相对于类路径根目录)。 - * @return 资源文件的内容作为字节数组。 - * @throws IOException 如果资源未找到或读取失败时抛出。 + * 这是一个内联扩展函数,利用 reified 关键字在编译时获取具体类型 T 的 Class 对象 + * + * @param T 用于获取 ClassLoader 的类型参数(通常传入调用方的类) + * @param path 资源文件的路径(相对于 T 所在的包,或以 / 开头的绝对路径) + * @return 资源的字节数组 + * @throws NotFoundResourceException 当资源不存在时抛出 + * + * 使用示例: + * ```kotlin + * // 在当前类的包下查找 config.json + * val data = getResourceAsByteArray("config.json") + * + * // 使用绝对路径(从 classpath 根目录) + * val data = getResourceAsByteArray("/assets/config.json") + * ``` */ - @JvmStatic - @Throws(IOException::class) - fun getResource(resourceName: String): ByteArray { - return getResource(resourceName, ResourceUtils::class.java) + inline fun getResourceAsByteArray(path: String): ByteArray { + // 将 reified T 的 KClass 转换为 Java 的 Class 对象,传递给重载方法 + return getResourceAsByteArray(path, T::class.java) } /** - * 从指定类的类路径中加载指定名称的资源文件,并以字节数组形式返回。 + * 从类路径中读取资源文件并返回字符串(使用 reified 类型参数) * - * @param resourceName 资源文件的名称(相对于类路径根目录)。 - * @param clazz 用于定位资源的类。 - * @return 资源文件的内容作为字节数组。 - * @throws IOException 如果资源未找到或读取失败时抛出。 + * @param T 用于获取 ClassLoader 的类型参数 + * @param resource 资源文件路径 + * @param charset 字符编码,默认为系统默认字符集 + * @return 资源文件的字符串内容 + * @throws NotFoundResourceException 当资源不存在时抛出 + * + * 使用示例: + * ```kotlin + * // 读取文本文件,使用默认编码 + * val content = getResourceAsString("data.txt") + * + * // 指定 UTF-8 编码 + * val content = getResourceAsString("data.txt", Charsets.UTF_8) + * ``` */ - @JvmStatic - @Throws(IOException::class) - fun getResource(resourceName: String, clazz: Class<*>): ByteArray { - return clazz.getResourceAsStream(resourceName)?.use { - it.readBytes() - } ?: throw IOException("Resource not found: $resourceName") + inline fun getResourceAsString( + resource: String, + charset: Charset = Charset.defaultCharset(), + ): String { + // 将 reified T 的 Class 对象传递给重载方法 + return getResourceAsString(resource, charset, T::class.java) } /** - * 从默认类路径中加载指定名称的资源文件,并以字符串形式返回。 + * 从类路径中读取资源文件并返回字符串(Java 友好重载版本) * - * @param resourceName 资源文件的名称(相对于类路径根目录)。 - * @return 资源文件的内容作为字符串(使用UTF-8编码)。 - * @throws IOException 如果资源未找到或读取失败时抛出。 + * 此方法标记为 @JvmStatic,使其可以在 Java 代码中以静态方法形式调用 + * + * @param path 资源文件路径 + * @param charset 字符编码 + * @param clazz 用于获取 ClassLoader 的参考类 + * @return 资源文件的字符串内容 + * @throws NotFoundResourceException 当资源不存在时抛出 + * + * Java 调用示例: + * ```java + * // 在 Java 中调用 + * String content = YourClass.getResourceAsString("config.json", StandardCharsets.UTF_8, MyClass.class); + * ``` */ @JvmStatic - @Throws(IOException::class) - fun getStringResource(resourceName: String): String { - return getStringResource(resourceName, ResourceUtils::class.java) + fun getResourceAsString(path: String, charset: Charset, clazz: Class<*>): String { + // 先读取为字节数组,再按指定字符集解码为字符串 + return String(getResourceAsByteArray(path, clazz), charset) } /** - * 从指定类的类路径中加载指定名称的资源文件,并以字符串形式返回。 + * 从类路径中读取资源文件并返回字符串(使用默认字符集,Java 友好重载) * - * @param resourceName 资源文件的名称(相对于类路径根目录)。 - * @param clazz 用于定位资源的类。 - * @return 资源文件的内容作为字符串(使用UTF-8编码)。 - * @throws IOException 如果资源未找到或读取失败时抛出。 + * @param path 资源文件路径 + * @param clazz 用于获取 ClassLoader 的参考类 + * @return 资源文件的字符串内容 + * @throws NotFoundResourceException 当资源不存在时抛出 */ @JvmStatic - @Throws(IOException::class) - fun getStringResource(resourceName: String, clazz: Class<*>): String { - return clazz.getResourceAsStream(resourceName)?.use { - it.readBytes().toString(charset = Charsets.UTF_8) - } ?: throw IOException("Resource not found: $resourceName") + fun getResourceAsString(path: String, clazz: Class<*>): String { + // 委托给上面的方法,使用系统默认字符集 + return getResourceAsString(path, Charset.defaultCharset(), clazz) } /** - * 从调用者的类路径中加载指定名称的资源文件,并以字符串形式返回。 + * 从类路径中读取资源文件并返回字节数组(核心实现方法) * - * @param resourceName 资源文件的名称(相对于类路径根目录)。 - * @return 资源文件的内容作为字符串(使用UTF-8编码)。 - * @throws IOException 如果资源未找到或读取失败时抛出。 + * 这是所有方法的核心实现,负责实际的资源查找和读取工作 + * + * @param path 资源文件路径 + * - 如果以 "/" 开头:表示从 classpath 根目录查找 + * - 如果不以 "/" 开头:表示相对于 clazz 所在包的路径 + * @param clazz 参考类,用于确定相对路径的基准包 + * @return 资源的完整字节数组(使用 readAllBytes() 一次性读取) + * @throws NotFoundResourceException 当资源文件不存在时抛出,错误信息会显示完整的查找路径 + * + * 资源查找规则说明: + * 1. 如果 path = "config.properties" 且 clazz = com.example.MyClass + * 实际查找路径:/com/example/config.properties + * + * 2. 如果 path = "/config.properties" + * 实际查找路径:/config.properties(classpath 根目录) + * + * 异常消息示例: + * - 找不到文件时抛出:"/com/example/config.properties is not found" */ @JvmStatic - @Throws(IOException::class) - fun getStringResourceCallers(resourceName: String): String { - return getStringResource(resourceName, getCallerClass()) - } + fun getResourceAsByteArray(path: String, clazz: Class<*>): ByteArray { + // 尝试从类路径中获取资源的输入流 + val stream = clazz.getResourceAsStream(path) + ?: throw NotFoundResourceException( + // 构建详细的错误信息:显示实际查找的完整路径 + // 如果 path 不以 "/" 开头,则拼接类的包路径(将包名中的点替换为斜杠) + (if (!path.startsWith("/")) + "/${clazz.packageName.replace(".", "/")}/$path" // 相对路径:相对于 clazz 的包 + else + path // 绝对路径:直接使用原路径 + ) + " is not found" // 添加 " is not found" 后缀 + ) - /** - * 从调用者的类路径中加载指定名称的资源文件,并以字节数组形式返回。 - * - * @param resourceName 资源文件的名称(相对于类路径根目录)。 - * @return 资源文件的内容作为字节数组。 - * @throws IOException 如果资源未找到或读取失败时抛出。 - */ - @JvmStatic - @Throws(IOException::class) - fun getResourceCallers(resourceName: String): ByteArray { - return getResource(resourceName, getCallerClass()) - } - - /** - * 获取当前调用栈中第一个非ResourceUtils类的调用者类。 - * - * @return 调用者类对象;如果未找到则返回ResourceUtils类本身。 - */ - private fun getCallerClass(): Class<*> { - val stackTrace = Thread.currentThread().stackTrace - for (i in 2 until stackTrace.size) { - val className = stackTrace[i].className - try { - val clazz = Class.forName(className) - if (clazz != ResourceUtils::class.java) { - return clazz - } - } catch (e: ClassNotFoundException) { - continue - } - } - return ResourceUtils::class.java + // 读取输入流中的所有字节并返回 + // Kotlin 的扩展函数,等同于 Java 9+ 的 InputStream.readAllBytes() + return stream.readAllBytes() } } diff --git a/src/main/kotlin/com/mingliqiye/utils/springboot/autoconfigure/Jackson3JsonApiAutoConfiguration.kt b/src/main/kotlin/com/mingliqiye/utils/springboot/autoconfigure/Jackson3JsonApiAutoConfiguration.kt index 5b66610..b2e19f9 100644 --- a/src/main/kotlin/com/mingliqiye/utils/springboot/autoconfigure/Jackson3JsonApiAutoConfiguration.kt +++ b/src/main/kotlin/com/mingliqiye/utils/springboot/autoconfigure/Jackson3JsonApiAutoConfiguration.kt @@ -16,15 +16,15 @@ * ProjectName mingli-utils * ModuleName mingli-utils.main * CurrentFile Jackson3JsonApiAutoConfiguration.kt - * LastUpdate 2026-02-26 14:24:33 + * LastUpdate 2026-06-21 10:40:58 * UpdateUser MingLiPro */ package com.mingliqiye.utils.springboot.autoconfigure import com.mingliqiye.utils.exception.JsonException -import com.mingliqiye.utils.json.Jackson3JsonApi import com.mingliqiye.utils.json.api.JSONA +import com.mingliqiye.utils.json.api.Jackson3JsonApi import com.mingliqiye.utils.json.api.base.JsonApi import com.mingliqiye.utils.logger.MingLiLoggerFactory import org.springframework.boot.autoconfigure.AutoConfigureAfter diff --git a/src/main/kotlin/com/mingliqiye/utils/system/SystemUtil.kt b/src/main/kotlin/com/mingliqiye/utils/system/SystemUtil.kt index 7516b6d..6c4f1f4 100644 --- a/src/main/kotlin/com/mingliqiye/utils/system/SystemUtil.kt +++ b/src/main/kotlin/com/mingliqiye/utils/system/SystemUtil.kt @@ -16,16 +16,16 @@ * ProjectName mingli-utils * ModuleName mingli-utils.main * CurrentFile SystemUtil.kt - * LastUpdate 2026-03-11 08:44:41 + * LastUpdate 2026-03-27 09:35:40 * UpdateUser MingLiPro */ @file:JvmName("SystemUtils") package com.mingliqiye.utils.system -import com.mingliqiye.utils.random.randomByte import java.lang.management.ManagementFactory import java.net.* +import com.mingliqiye.utils.random.Random.nextBytes as randomByte /** * 操作系统名称属性,延迟初始化 diff --git a/src/main/kotlin/com/mingliqiye/utils/time/DateTime.kt b/src/main/kotlin/com/mingliqiye/utils/time/DateTime.kt index d953716..7e93704 100644 --- a/src/main/kotlin/com/mingliqiye/utils/time/DateTime.kt +++ b/src/main/kotlin/com/mingliqiye/utils/time/DateTime.kt @@ -16,7 +16,7 @@ * ProjectName mingli-utils * ModuleName mingli-utils.main * CurrentFile DateTime.kt - * LastUpdate 2026-03-07 11:02:42 + * LastUpdate 2026-03-14 16:12:08 * UpdateUser MingLiPro */ @@ -54,7 +54,7 @@ import kotlin.time.Instant format = "date-time" ) class DateTime private constructor( - private var localDateTime: LocalDateTime, private val zoneId: ZoneId = ZoneId.systemDefault() + private var localDateTime: LocalDateTime, private val zoneId: ZoneId = ZoneId.systemDefault(), ) : Serializable { companion object { @@ -105,6 +105,18 @@ class DateTime private constructor( return DateTime(localDateTime) } + + /** + * 根据 LocalDateTime 创建 DateTime 实例。 + * + * @param localDateTime LocalDateTime 对象 + * @return 返回对应的 DateTime 实例 + */ + @JvmStatic + fun of(instant: java.time.Instant, zoneId: ZoneId = ZoneId.systemDefault()): DateTime { + return DateTime(LocalDateTime.ofInstant(instant, zoneId)) + } + /** * 解析时间字符串并生成 DateTime 实例。 * @@ -115,7 +127,7 @@ class DateTime private constructor( */ @JvmStatic fun parse( - timestr: String, formatter: String, fillZero: Boolean + timestr: String, formatter: String, fillZero: Boolean, ): DateTime { return DateTime( LocalDateTime.parse( @@ -127,7 +139,7 @@ class DateTime private constructor( @JvmStatic fun parse( - timestr: String + timestr: String, ): DateTime { val formatterString = Formatter.STANDARD_DATETIME_MILLISECOUND9.value @@ -148,7 +160,7 @@ class DateTime private constructor( */ @JvmStatic fun parse( - timestr: String, formatter: Formatter, fillZero: Boolean + timestr: String, formatter: Formatter, fillZero: Boolean, ): DateTime { return parse(timestr, formatter.value, fillZero) } @@ -232,7 +244,7 @@ class DateTime private constructor( */ @JvmStatic fun of( - year: Int, month: Int, day: Int, hour: Int, minute: Int + year: Int, month: Int, day: Int, hour: Int, minute: Int, ): DateTime { return DateTime(LocalDateTime.of(year, month, day, hour, minute)) } @@ -250,7 +262,7 @@ class DateTime private constructor( */ @JvmStatic fun of( - year: Int, month: Int, day: Int, hour: Int, minute: Int, second: Int + year: Int, month: Int, day: Int, hour: Int, minute: Int, second: Int, ): DateTime { return DateTime( LocalDateTime.of(year, month, day, hour, minute, second) @@ -271,7 +283,7 @@ class DateTime private constructor( */ @JvmStatic fun of( - year: Int, month: Int, day: Int, hour: Int, minute: Int, second: Int, nano: Int + year: Int, month: Int, day: Int, hour: Int, minute: Int, second: Int, nano: Int, ): DateTime { return DateTime( LocalDateTime.of(year, month, day, hour, minute, second, nano) @@ -311,6 +323,9 @@ class DateTime private constructor( java.time.Instant.ofEpochMilli(epochMilli).atZone(zoneId).toLocalDateTime(), zoneId ) } + + fun LocalDateTime.toDateTime(): DateTime = of(this) + fun Date.toDateTime(): DateTime = of(this) } /** diff --git a/src/main/kotlin/com/mingliqiye/utils/tuple/Tuple.kt b/src/main/kotlin/com/mingliqiye/utils/tuple/Tuple.kt new file mode 100644 index 0000000..551af46 --- /dev/null +++ b/src/main/kotlin/com/mingliqiye/utils/tuple/Tuple.kt @@ -0,0 +1,10523 @@ +/* + * Copyright 2026 mingliqiye + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * ProjectName mingli-utils + * ModuleName mingli-utils.main + * CurrentFile Tuple.kt + * LastUpdate 2026-06-21 10:40:58 + * UpdateUser MingLiPro + */ + +package com.mingliqiye.utils.tuple + +class Tuple1( + val t1: T1, +) : Tuple(1) { + operator fun component1(): T1 = t1 +} + +class Tuple2( + val t1: T1, + val t2: T2, +) : Tuple(2) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 +} + +class Tuple3( + val t1: T1, + val t2: T2, + val t3: T3, +) : Tuple(3) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 +} + +class Tuple4( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, +) : Tuple(4) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 +} + +class Tuple5( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, +) : Tuple(5) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 +} + +class Tuple6( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, +) : Tuple(6) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 +} + +class Tuple7( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, +) : Tuple(7) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 +} + +class Tuple8( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, +) : Tuple(8) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 +} + +class Tuple9( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, +) : Tuple(9) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 +} + +class Tuple10( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, +) : Tuple(10) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 +} + +class Tuple11( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, +) : Tuple(11) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 +} + +class Tuple12( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, +) : Tuple(12) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 +} + +class Tuple13( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, +) : Tuple(13) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 +} + +class Tuple14( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, +) : Tuple(14) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 +} + +class Tuple15( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, +) : Tuple(15) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 +} + +class Tuple16( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, +) : Tuple(16) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 +} + +class Tuple17( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, +) : Tuple(17) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 +} + +class Tuple18( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, +) : Tuple(18) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 +} + +class Tuple19( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, +) : Tuple(19) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 +} + +class Tuple20( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, +) : Tuple(20) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 +} + +class Tuple21( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, +) : Tuple(21) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 +} + +class Tuple22( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, +) : Tuple(22) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 +} + +class Tuple23( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, +) : Tuple(23) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 +} + +class Tuple24( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, +) : Tuple(24) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 +} + +class Tuple25( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, +) : Tuple(25) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 +} + +class Tuple26( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, +) : Tuple(26) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 +} + +class Tuple27( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, +) : Tuple(27) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 +} + +class Tuple28( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, +) : Tuple(28) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 +} + +class Tuple29( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, +) : Tuple(29) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 +} + +class Tuple30( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, +) : Tuple(30) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 +} + +class Tuple31( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, +) : Tuple(31) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 +} + +class Tuple32( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, +) : Tuple(32) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 +} + +class Tuple33( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, +) : Tuple(33) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 +} + +class Tuple34( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, +) : Tuple(34) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 +} + +class Tuple35( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, +) : Tuple(35) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 +} + +class Tuple36( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, +) : Tuple(36) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 +} + +class Tuple37( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, +) : Tuple(37) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 +} + +class Tuple38( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, +) : Tuple(38) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 +} + +class Tuple39( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, +) : Tuple(39) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 +} + +class Tuple40( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, +) : Tuple(40) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 +} + +class Tuple41( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, +) : Tuple(41) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 +} + +class Tuple42( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, +) : Tuple(42) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 +} + +class Tuple43( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, +) : Tuple(43) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 +} + +class Tuple44( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, +) : Tuple(44) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 +} + +class Tuple45( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, +) : Tuple(45) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 +} + +class Tuple46( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, +) : Tuple(46) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 +} + +class Tuple47( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, +) : Tuple(47) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 +} + +class Tuple48( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, +) : Tuple(48) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 +} + +class Tuple49( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, +) : Tuple(49) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 +} + +class Tuple50( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, +) : Tuple(50) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 +} + +class Tuple51( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, +) : Tuple(51) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 +} + +class Tuple52( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, +) : Tuple(52) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 +} + +class Tuple53( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, +) : Tuple(53) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 +} + +class Tuple54( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, +) : Tuple(54) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 +} + +class Tuple55( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, +) : Tuple(55) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 +} + +class Tuple56( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, + val t56: T56, +) : Tuple(56) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 + operator fun component56(): T56 = t56 +} + +class Tuple57( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, + val t56: T56, + val t57: T57, +) : Tuple(57) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 + operator fun component56(): T56 = t56 + operator fun component57(): T57 = t57 +} + +class Tuple58( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, + val t56: T56, + val t57: T57, + val t58: T58, +) : Tuple(58) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 + operator fun component56(): T56 = t56 + operator fun component57(): T57 = t57 + operator fun component58(): T58 = t58 +} + +class Tuple59( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, + val t56: T56, + val t57: T57, + val t58: T58, + val t59: T59, +) : Tuple(59) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 + operator fun component56(): T56 = t56 + operator fun component57(): T57 = t57 + operator fun component58(): T58 = t58 + operator fun component59(): T59 = t59 +} + +class Tuple60( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, + val t56: T56, + val t57: T57, + val t58: T58, + val t59: T59, + val t60: T60, +) : Tuple(60) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 + operator fun component56(): T56 = t56 + operator fun component57(): T57 = t57 + operator fun component58(): T58 = t58 + operator fun component59(): T59 = t59 + operator fun component60(): T60 = t60 +} + +class Tuple61( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, + val t56: T56, + val t57: T57, + val t58: T58, + val t59: T59, + val t60: T60, + val t61: T61, +) : Tuple(61) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 + operator fun component56(): T56 = t56 + operator fun component57(): T57 = t57 + operator fun component58(): T58 = t58 + operator fun component59(): T59 = t59 + operator fun component60(): T60 = t60 + operator fun component61(): T61 = t61 +} + +class Tuple62( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, + val t56: T56, + val t57: T57, + val t58: T58, + val t59: T59, + val t60: T60, + val t61: T61, + val t62: T62, +) : Tuple(62) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 + operator fun component56(): T56 = t56 + operator fun component57(): T57 = t57 + operator fun component58(): T58 = t58 + operator fun component59(): T59 = t59 + operator fun component60(): T60 = t60 + operator fun component61(): T61 = t61 + operator fun component62(): T62 = t62 +} + +class Tuple63( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, + val t56: T56, + val t57: T57, + val t58: T58, + val t59: T59, + val t60: T60, + val t61: T61, + val t62: T62, + val t63: T63, +) : Tuple(63) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 + operator fun component56(): T56 = t56 + operator fun component57(): T57 = t57 + operator fun component58(): T58 = t58 + operator fun component59(): T59 = t59 + operator fun component60(): T60 = t60 + operator fun component61(): T61 = t61 + operator fun component62(): T62 = t62 + operator fun component63(): T63 = t63 +} + +class Tuple64( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, + val t56: T56, + val t57: T57, + val t58: T58, + val t59: T59, + val t60: T60, + val t61: T61, + val t62: T62, + val t63: T63, + val t64: T64, +) : Tuple(64) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 + operator fun component56(): T56 = t56 + operator fun component57(): T57 = t57 + operator fun component58(): T58 = t58 + operator fun component59(): T59 = t59 + operator fun component60(): T60 = t60 + operator fun component61(): T61 = t61 + operator fun component62(): T62 = t62 + operator fun component63(): T63 = t63 + operator fun component64(): T64 = t64 +} + +class Tuple65( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, + val t56: T56, + val t57: T57, + val t58: T58, + val t59: T59, + val t60: T60, + val t61: T61, + val t62: T62, + val t63: T63, + val t64: T64, + val t65: T65, +) : Tuple(65) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 + operator fun component56(): T56 = t56 + operator fun component57(): T57 = t57 + operator fun component58(): T58 = t58 + operator fun component59(): T59 = t59 + operator fun component60(): T60 = t60 + operator fun component61(): T61 = t61 + operator fun component62(): T62 = t62 + operator fun component63(): T63 = t63 + operator fun component64(): T64 = t64 + operator fun component65(): T65 = t65 +} + +class Tuple66( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, + val t56: T56, + val t57: T57, + val t58: T58, + val t59: T59, + val t60: T60, + val t61: T61, + val t62: T62, + val t63: T63, + val t64: T64, + val t65: T65, + val t66: T66, +) : Tuple(66) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 + operator fun component56(): T56 = t56 + operator fun component57(): T57 = t57 + operator fun component58(): T58 = t58 + operator fun component59(): T59 = t59 + operator fun component60(): T60 = t60 + operator fun component61(): T61 = t61 + operator fun component62(): T62 = t62 + operator fun component63(): T63 = t63 + operator fun component64(): T64 = t64 + operator fun component65(): T65 = t65 + operator fun component66(): T66 = t66 +} + +class Tuple67( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, + val t56: T56, + val t57: T57, + val t58: T58, + val t59: T59, + val t60: T60, + val t61: T61, + val t62: T62, + val t63: T63, + val t64: T64, + val t65: T65, + val t66: T66, + val t67: T67, +) : Tuple(67) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 + operator fun component56(): T56 = t56 + operator fun component57(): T57 = t57 + operator fun component58(): T58 = t58 + operator fun component59(): T59 = t59 + operator fun component60(): T60 = t60 + operator fun component61(): T61 = t61 + operator fun component62(): T62 = t62 + operator fun component63(): T63 = t63 + operator fun component64(): T64 = t64 + operator fun component65(): T65 = t65 + operator fun component66(): T66 = t66 + operator fun component67(): T67 = t67 +} + +class Tuple68( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, + val t56: T56, + val t57: T57, + val t58: T58, + val t59: T59, + val t60: T60, + val t61: T61, + val t62: T62, + val t63: T63, + val t64: T64, + val t65: T65, + val t66: T66, + val t67: T67, + val t68: T68, +) : Tuple(68) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 + operator fun component56(): T56 = t56 + operator fun component57(): T57 = t57 + operator fun component58(): T58 = t58 + operator fun component59(): T59 = t59 + operator fun component60(): T60 = t60 + operator fun component61(): T61 = t61 + operator fun component62(): T62 = t62 + operator fun component63(): T63 = t63 + operator fun component64(): T64 = t64 + operator fun component65(): T65 = t65 + operator fun component66(): T66 = t66 + operator fun component67(): T67 = t67 + operator fun component68(): T68 = t68 +} + +class Tuple69( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, + val t56: T56, + val t57: T57, + val t58: T58, + val t59: T59, + val t60: T60, + val t61: T61, + val t62: T62, + val t63: T63, + val t64: T64, + val t65: T65, + val t66: T66, + val t67: T67, + val t68: T68, + val t69: T69, +) : Tuple(69) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 + operator fun component56(): T56 = t56 + operator fun component57(): T57 = t57 + operator fun component58(): T58 = t58 + operator fun component59(): T59 = t59 + operator fun component60(): T60 = t60 + operator fun component61(): T61 = t61 + operator fun component62(): T62 = t62 + operator fun component63(): T63 = t63 + operator fun component64(): T64 = t64 + operator fun component65(): T65 = t65 + operator fun component66(): T66 = t66 + operator fun component67(): T67 = t67 + operator fun component68(): T68 = t68 + operator fun component69(): T69 = t69 +} + +class Tuple70( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, + val t56: T56, + val t57: T57, + val t58: T58, + val t59: T59, + val t60: T60, + val t61: T61, + val t62: T62, + val t63: T63, + val t64: T64, + val t65: T65, + val t66: T66, + val t67: T67, + val t68: T68, + val t69: T69, + val t70: T70, +) : Tuple(70) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 + operator fun component56(): T56 = t56 + operator fun component57(): T57 = t57 + operator fun component58(): T58 = t58 + operator fun component59(): T59 = t59 + operator fun component60(): T60 = t60 + operator fun component61(): T61 = t61 + operator fun component62(): T62 = t62 + operator fun component63(): T63 = t63 + operator fun component64(): T64 = t64 + operator fun component65(): T65 = t65 + operator fun component66(): T66 = t66 + operator fun component67(): T67 = t67 + operator fun component68(): T68 = t68 + operator fun component69(): T69 = t69 + operator fun component70(): T70 = t70 +} + +class Tuple71( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, + val t56: T56, + val t57: T57, + val t58: T58, + val t59: T59, + val t60: T60, + val t61: T61, + val t62: T62, + val t63: T63, + val t64: T64, + val t65: T65, + val t66: T66, + val t67: T67, + val t68: T68, + val t69: T69, + val t70: T70, + val t71: T71, +) : Tuple(71) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 + operator fun component56(): T56 = t56 + operator fun component57(): T57 = t57 + operator fun component58(): T58 = t58 + operator fun component59(): T59 = t59 + operator fun component60(): T60 = t60 + operator fun component61(): T61 = t61 + operator fun component62(): T62 = t62 + operator fun component63(): T63 = t63 + operator fun component64(): T64 = t64 + operator fun component65(): T65 = t65 + operator fun component66(): T66 = t66 + operator fun component67(): T67 = t67 + operator fun component68(): T68 = t68 + operator fun component69(): T69 = t69 + operator fun component70(): T70 = t70 + operator fun component71(): T71 = t71 +} + +class Tuple72( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, + val t56: T56, + val t57: T57, + val t58: T58, + val t59: T59, + val t60: T60, + val t61: T61, + val t62: T62, + val t63: T63, + val t64: T64, + val t65: T65, + val t66: T66, + val t67: T67, + val t68: T68, + val t69: T69, + val t70: T70, + val t71: T71, + val t72: T72, +) : Tuple(72) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 + operator fun component56(): T56 = t56 + operator fun component57(): T57 = t57 + operator fun component58(): T58 = t58 + operator fun component59(): T59 = t59 + operator fun component60(): T60 = t60 + operator fun component61(): T61 = t61 + operator fun component62(): T62 = t62 + operator fun component63(): T63 = t63 + operator fun component64(): T64 = t64 + operator fun component65(): T65 = t65 + operator fun component66(): T66 = t66 + operator fun component67(): T67 = t67 + operator fun component68(): T68 = t68 + operator fun component69(): T69 = t69 + operator fun component70(): T70 = t70 + operator fun component71(): T71 = t71 + operator fun component72(): T72 = t72 +} + +class Tuple73( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, + val t56: T56, + val t57: T57, + val t58: T58, + val t59: T59, + val t60: T60, + val t61: T61, + val t62: T62, + val t63: T63, + val t64: T64, + val t65: T65, + val t66: T66, + val t67: T67, + val t68: T68, + val t69: T69, + val t70: T70, + val t71: T71, + val t72: T72, + val t73: T73, +) : Tuple(73) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 + operator fun component56(): T56 = t56 + operator fun component57(): T57 = t57 + operator fun component58(): T58 = t58 + operator fun component59(): T59 = t59 + operator fun component60(): T60 = t60 + operator fun component61(): T61 = t61 + operator fun component62(): T62 = t62 + operator fun component63(): T63 = t63 + operator fun component64(): T64 = t64 + operator fun component65(): T65 = t65 + operator fun component66(): T66 = t66 + operator fun component67(): T67 = t67 + operator fun component68(): T68 = t68 + operator fun component69(): T69 = t69 + operator fun component70(): T70 = t70 + operator fun component71(): T71 = t71 + operator fun component72(): T72 = t72 + operator fun component73(): T73 = t73 +} + +class Tuple74( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, + val t56: T56, + val t57: T57, + val t58: T58, + val t59: T59, + val t60: T60, + val t61: T61, + val t62: T62, + val t63: T63, + val t64: T64, + val t65: T65, + val t66: T66, + val t67: T67, + val t68: T68, + val t69: T69, + val t70: T70, + val t71: T71, + val t72: T72, + val t73: T73, + val t74: T74, +) : Tuple(74) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 + operator fun component56(): T56 = t56 + operator fun component57(): T57 = t57 + operator fun component58(): T58 = t58 + operator fun component59(): T59 = t59 + operator fun component60(): T60 = t60 + operator fun component61(): T61 = t61 + operator fun component62(): T62 = t62 + operator fun component63(): T63 = t63 + operator fun component64(): T64 = t64 + operator fun component65(): T65 = t65 + operator fun component66(): T66 = t66 + operator fun component67(): T67 = t67 + operator fun component68(): T68 = t68 + operator fun component69(): T69 = t69 + operator fun component70(): T70 = t70 + operator fun component71(): T71 = t71 + operator fun component72(): T72 = t72 + operator fun component73(): T73 = t73 + operator fun component74(): T74 = t74 +} + +class Tuple75( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, + val t56: T56, + val t57: T57, + val t58: T58, + val t59: T59, + val t60: T60, + val t61: T61, + val t62: T62, + val t63: T63, + val t64: T64, + val t65: T65, + val t66: T66, + val t67: T67, + val t68: T68, + val t69: T69, + val t70: T70, + val t71: T71, + val t72: T72, + val t73: T73, + val t74: T74, + val t75: T75, +) : Tuple(75) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 + operator fun component56(): T56 = t56 + operator fun component57(): T57 = t57 + operator fun component58(): T58 = t58 + operator fun component59(): T59 = t59 + operator fun component60(): T60 = t60 + operator fun component61(): T61 = t61 + operator fun component62(): T62 = t62 + operator fun component63(): T63 = t63 + operator fun component64(): T64 = t64 + operator fun component65(): T65 = t65 + operator fun component66(): T66 = t66 + operator fun component67(): T67 = t67 + operator fun component68(): T68 = t68 + operator fun component69(): T69 = t69 + operator fun component70(): T70 = t70 + operator fun component71(): T71 = t71 + operator fun component72(): T72 = t72 + operator fun component73(): T73 = t73 + operator fun component74(): T74 = t74 + operator fun component75(): T75 = t75 +} + +class Tuple76( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, + val t56: T56, + val t57: T57, + val t58: T58, + val t59: T59, + val t60: T60, + val t61: T61, + val t62: T62, + val t63: T63, + val t64: T64, + val t65: T65, + val t66: T66, + val t67: T67, + val t68: T68, + val t69: T69, + val t70: T70, + val t71: T71, + val t72: T72, + val t73: T73, + val t74: T74, + val t75: T75, + val t76: T76, +) : Tuple(76) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 + operator fun component56(): T56 = t56 + operator fun component57(): T57 = t57 + operator fun component58(): T58 = t58 + operator fun component59(): T59 = t59 + operator fun component60(): T60 = t60 + operator fun component61(): T61 = t61 + operator fun component62(): T62 = t62 + operator fun component63(): T63 = t63 + operator fun component64(): T64 = t64 + operator fun component65(): T65 = t65 + operator fun component66(): T66 = t66 + operator fun component67(): T67 = t67 + operator fun component68(): T68 = t68 + operator fun component69(): T69 = t69 + operator fun component70(): T70 = t70 + operator fun component71(): T71 = t71 + operator fun component72(): T72 = t72 + operator fun component73(): T73 = t73 + operator fun component74(): T74 = t74 + operator fun component75(): T75 = t75 + operator fun component76(): T76 = t76 +} + +class Tuple77( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, + val t56: T56, + val t57: T57, + val t58: T58, + val t59: T59, + val t60: T60, + val t61: T61, + val t62: T62, + val t63: T63, + val t64: T64, + val t65: T65, + val t66: T66, + val t67: T67, + val t68: T68, + val t69: T69, + val t70: T70, + val t71: T71, + val t72: T72, + val t73: T73, + val t74: T74, + val t75: T75, + val t76: T76, + val t77: T77, +) : Tuple(77) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 + operator fun component56(): T56 = t56 + operator fun component57(): T57 = t57 + operator fun component58(): T58 = t58 + operator fun component59(): T59 = t59 + operator fun component60(): T60 = t60 + operator fun component61(): T61 = t61 + operator fun component62(): T62 = t62 + operator fun component63(): T63 = t63 + operator fun component64(): T64 = t64 + operator fun component65(): T65 = t65 + operator fun component66(): T66 = t66 + operator fun component67(): T67 = t67 + operator fun component68(): T68 = t68 + operator fun component69(): T69 = t69 + operator fun component70(): T70 = t70 + operator fun component71(): T71 = t71 + operator fun component72(): T72 = t72 + operator fun component73(): T73 = t73 + operator fun component74(): T74 = t74 + operator fun component75(): T75 = t75 + operator fun component76(): T76 = t76 + operator fun component77(): T77 = t77 +} + +class Tuple78( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, + val t56: T56, + val t57: T57, + val t58: T58, + val t59: T59, + val t60: T60, + val t61: T61, + val t62: T62, + val t63: T63, + val t64: T64, + val t65: T65, + val t66: T66, + val t67: T67, + val t68: T68, + val t69: T69, + val t70: T70, + val t71: T71, + val t72: T72, + val t73: T73, + val t74: T74, + val t75: T75, + val t76: T76, + val t77: T77, + val t78: T78, +) : Tuple(78) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 + operator fun component56(): T56 = t56 + operator fun component57(): T57 = t57 + operator fun component58(): T58 = t58 + operator fun component59(): T59 = t59 + operator fun component60(): T60 = t60 + operator fun component61(): T61 = t61 + operator fun component62(): T62 = t62 + operator fun component63(): T63 = t63 + operator fun component64(): T64 = t64 + operator fun component65(): T65 = t65 + operator fun component66(): T66 = t66 + operator fun component67(): T67 = t67 + operator fun component68(): T68 = t68 + operator fun component69(): T69 = t69 + operator fun component70(): T70 = t70 + operator fun component71(): T71 = t71 + operator fun component72(): T72 = t72 + operator fun component73(): T73 = t73 + operator fun component74(): T74 = t74 + operator fun component75(): T75 = t75 + operator fun component76(): T76 = t76 + operator fun component77(): T77 = t77 + operator fun component78(): T78 = t78 +} + +class Tuple79( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, + val t56: T56, + val t57: T57, + val t58: T58, + val t59: T59, + val t60: T60, + val t61: T61, + val t62: T62, + val t63: T63, + val t64: T64, + val t65: T65, + val t66: T66, + val t67: T67, + val t68: T68, + val t69: T69, + val t70: T70, + val t71: T71, + val t72: T72, + val t73: T73, + val t74: T74, + val t75: T75, + val t76: T76, + val t77: T77, + val t78: T78, + val t79: T79, +) : Tuple(79) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 + operator fun component56(): T56 = t56 + operator fun component57(): T57 = t57 + operator fun component58(): T58 = t58 + operator fun component59(): T59 = t59 + operator fun component60(): T60 = t60 + operator fun component61(): T61 = t61 + operator fun component62(): T62 = t62 + operator fun component63(): T63 = t63 + operator fun component64(): T64 = t64 + operator fun component65(): T65 = t65 + operator fun component66(): T66 = t66 + operator fun component67(): T67 = t67 + operator fun component68(): T68 = t68 + operator fun component69(): T69 = t69 + operator fun component70(): T70 = t70 + operator fun component71(): T71 = t71 + operator fun component72(): T72 = t72 + operator fun component73(): T73 = t73 + operator fun component74(): T74 = t74 + operator fun component75(): T75 = t75 + operator fun component76(): T76 = t76 + operator fun component77(): T77 = t77 + operator fun component78(): T78 = t78 + operator fun component79(): T79 = t79 +} + +class Tuple80( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, + val t56: T56, + val t57: T57, + val t58: T58, + val t59: T59, + val t60: T60, + val t61: T61, + val t62: T62, + val t63: T63, + val t64: T64, + val t65: T65, + val t66: T66, + val t67: T67, + val t68: T68, + val t69: T69, + val t70: T70, + val t71: T71, + val t72: T72, + val t73: T73, + val t74: T74, + val t75: T75, + val t76: T76, + val t77: T77, + val t78: T78, + val t79: T79, + val t80: T80, +) : Tuple(80) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 + operator fun component56(): T56 = t56 + operator fun component57(): T57 = t57 + operator fun component58(): T58 = t58 + operator fun component59(): T59 = t59 + operator fun component60(): T60 = t60 + operator fun component61(): T61 = t61 + operator fun component62(): T62 = t62 + operator fun component63(): T63 = t63 + operator fun component64(): T64 = t64 + operator fun component65(): T65 = t65 + operator fun component66(): T66 = t66 + operator fun component67(): T67 = t67 + operator fun component68(): T68 = t68 + operator fun component69(): T69 = t69 + operator fun component70(): T70 = t70 + operator fun component71(): T71 = t71 + operator fun component72(): T72 = t72 + operator fun component73(): T73 = t73 + operator fun component74(): T74 = t74 + operator fun component75(): T75 = t75 + operator fun component76(): T76 = t76 + operator fun component77(): T77 = t77 + operator fun component78(): T78 = t78 + operator fun component79(): T79 = t79 + operator fun component80(): T80 = t80 +} + +class Tuple81( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, + val t56: T56, + val t57: T57, + val t58: T58, + val t59: T59, + val t60: T60, + val t61: T61, + val t62: T62, + val t63: T63, + val t64: T64, + val t65: T65, + val t66: T66, + val t67: T67, + val t68: T68, + val t69: T69, + val t70: T70, + val t71: T71, + val t72: T72, + val t73: T73, + val t74: T74, + val t75: T75, + val t76: T76, + val t77: T77, + val t78: T78, + val t79: T79, + val t80: T80, + val t81: T81, +) : Tuple(81) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 + operator fun component56(): T56 = t56 + operator fun component57(): T57 = t57 + operator fun component58(): T58 = t58 + operator fun component59(): T59 = t59 + operator fun component60(): T60 = t60 + operator fun component61(): T61 = t61 + operator fun component62(): T62 = t62 + operator fun component63(): T63 = t63 + operator fun component64(): T64 = t64 + operator fun component65(): T65 = t65 + operator fun component66(): T66 = t66 + operator fun component67(): T67 = t67 + operator fun component68(): T68 = t68 + operator fun component69(): T69 = t69 + operator fun component70(): T70 = t70 + operator fun component71(): T71 = t71 + operator fun component72(): T72 = t72 + operator fun component73(): T73 = t73 + operator fun component74(): T74 = t74 + operator fun component75(): T75 = t75 + operator fun component76(): T76 = t76 + operator fun component77(): T77 = t77 + operator fun component78(): T78 = t78 + operator fun component79(): T79 = t79 + operator fun component80(): T80 = t80 + operator fun component81(): T81 = t81 +} + +class Tuple82( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, + val t56: T56, + val t57: T57, + val t58: T58, + val t59: T59, + val t60: T60, + val t61: T61, + val t62: T62, + val t63: T63, + val t64: T64, + val t65: T65, + val t66: T66, + val t67: T67, + val t68: T68, + val t69: T69, + val t70: T70, + val t71: T71, + val t72: T72, + val t73: T73, + val t74: T74, + val t75: T75, + val t76: T76, + val t77: T77, + val t78: T78, + val t79: T79, + val t80: T80, + val t81: T81, + val t82: T82, +) : Tuple(82) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 + operator fun component56(): T56 = t56 + operator fun component57(): T57 = t57 + operator fun component58(): T58 = t58 + operator fun component59(): T59 = t59 + operator fun component60(): T60 = t60 + operator fun component61(): T61 = t61 + operator fun component62(): T62 = t62 + operator fun component63(): T63 = t63 + operator fun component64(): T64 = t64 + operator fun component65(): T65 = t65 + operator fun component66(): T66 = t66 + operator fun component67(): T67 = t67 + operator fun component68(): T68 = t68 + operator fun component69(): T69 = t69 + operator fun component70(): T70 = t70 + operator fun component71(): T71 = t71 + operator fun component72(): T72 = t72 + operator fun component73(): T73 = t73 + operator fun component74(): T74 = t74 + operator fun component75(): T75 = t75 + operator fun component76(): T76 = t76 + operator fun component77(): T77 = t77 + operator fun component78(): T78 = t78 + operator fun component79(): T79 = t79 + operator fun component80(): T80 = t80 + operator fun component81(): T81 = t81 + operator fun component82(): T82 = t82 +} + +class Tuple83( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, + val t56: T56, + val t57: T57, + val t58: T58, + val t59: T59, + val t60: T60, + val t61: T61, + val t62: T62, + val t63: T63, + val t64: T64, + val t65: T65, + val t66: T66, + val t67: T67, + val t68: T68, + val t69: T69, + val t70: T70, + val t71: T71, + val t72: T72, + val t73: T73, + val t74: T74, + val t75: T75, + val t76: T76, + val t77: T77, + val t78: T78, + val t79: T79, + val t80: T80, + val t81: T81, + val t82: T82, + val t83: T83, +) : Tuple(83) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 + operator fun component56(): T56 = t56 + operator fun component57(): T57 = t57 + operator fun component58(): T58 = t58 + operator fun component59(): T59 = t59 + operator fun component60(): T60 = t60 + operator fun component61(): T61 = t61 + operator fun component62(): T62 = t62 + operator fun component63(): T63 = t63 + operator fun component64(): T64 = t64 + operator fun component65(): T65 = t65 + operator fun component66(): T66 = t66 + operator fun component67(): T67 = t67 + operator fun component68(): T68 = t68 + operator fun component69(): T69 = t69 + operator fun component70(): T70 = t70 + operator fun component71(): T71 = t71 + operator fun component72(): T72 = t72 + operator fun component73(): T73 = t73 + operator fun component74(): T74 = t74 + operator fun component75(): T75 = t75 + operator fun component76(): T76 = t76 + operator fun component77(): T77 = t77 + operator fun component78(): T78 = t78 + operator fun component79(): T79 = t79 + operator fun component80(): T80 = t80 + operator fun component81(): T81 = t81 + operator fun component82(): T82 = t82 + operator fun component83(): T83 = t83 +} + +class Tuple84( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, + val t56: T56, + val t57: T57, + val t58: T58, + val t59: T59, + val t60: T60, + val t61: T61, + val t62: T62, + val t63: T63, + val t64: T64, + val t65: T65, + val t66: T66, + val t67: T67, + val t68: T68, + val t69: T69, + val t70: T70, + val t71: T71, + val t72: T72, + val t73: T73, + val t74: T74, + val t75: T75, + val t76: T76, + val t77: T77, + val t78: T78, + val t79: T79, + val t80: T80, + val t81: T81, + val t82: T82, + val t83: T83, + val t84: T84, +) : Tuple(84) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 + operator fun component56(): T56 = t56 + operator fun component57(): T57 = t57 + operator fun component58(): T58 = t58 + operator fun component59(): T59 = t59 + operator fun component60(): T60 = t60 + operator fun component61(): T61 = t61 + operator fun component62(): T62 = t62 + operator fun component63(): T63 = t63 + operator fun component64(): T64 = t64 + operator fun component65(): T65 = t65 + operator fun component66(): T66 = t66 + operator fun component67(): T67 = t67 + operator fun component68(): T68 = t68 + operator fun component69(): T69 = t69 + operator fun component70(): T70 = t70 + operator fun component71(): T71 = t71 + operator fun component72(): T72 = t72 + operator fun component73(): T73 = t73 + operator fun component74(): T74 = t74 + operator fun component75(): T75 = t75 + operator fun component76(): T76 = t76 + operator fun component77(): T77 = t77 + operator fun component78(): T78 = t78 + operator fun component79(): T79 = t79 + operator fun component80(): T80 = t80 + operator fun component81(): T81 = t81 + operator fun component82(): T82 = t82 + operator fun component83(): T83 = t83 + operator fun component84(): T84 = t84 +} + +class Tuple85( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, + val t56: T56, + val t57: T57, + val t58: T58, + val t59: T59, + val t60: T60, + val t61: T61, + val t62: T62, + val t63: T63, + val t64: T64, + val t65: T65, + val t66: T66, + val t67: T67, + val t68: T68, + val t69: T69, + val t70: T70, + val t71: T71, + val t72: T72, + val t73: T73, + val t74: T74, + val t75: T75, + val t76: T76, + val t77: T77, + val t78: T78, + val t79: T79, + val t80: T80, + val t81: T81, + val t82: T82, + val t83: T83, + val t84: T84, + val t85: T85, +) : Tuple(85) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 + operator fun component56(): T56 = t56 + operator fun component57(): T57 = t57 + operator fun component58(): T58 = t58 + operator fun component59(): T59 = t59 + operator fun component60(): T60 = t60 + operator fun component61(): T61 = t61 + operator fun component62(): T62 = t62 + operator fun component63(): T63 = t63 + operator fun component64(): T64 = t64 + operator fun component65(): T65 = t65 + operator fun component66(): T66 = t66 + operator fun component67(): T67 = t67 + operator fun component68(): T68 = t68 + operator fun component69(): T69 = t69 + operator fun component70(): T70 = t70 + operator fun component71(): T71 = t71 + operator fun component72(): T72 = t72 + operator fun component73(): T73 = t73 + operator fun component74(): T74 = t74 + operator fun component75(): T75 = t75 + operator fun component76(): T76 = t76 + operator fun component77(): T77 = t77 + operator fun component78(): T78 = t78 + operator fun component79(): T79 = t79 + operator fun component80(): T80 = t80 + operator fun component81(): T81 = t81 + operator fun component82(): T82 = t82 + operator fun component83(): T83 = t83 + operator fun component84(): T84 = t84 + operator fun component85(): T85 = t85 +} + +class Tuple86( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, + val t56: T56, + val t57: T57, + val t58: T58, + val t59: T59, + val t60: T60, + val t61: T61, + val t62: T62, + val t63: T63, + val t64: T64, + val t65: T65, + val t66: T66, + val t67: T67, + val t68: T68, + val t69: T69, + val t70: T70, + val t71: T71, + val t72: T72, + val t73: T73, + val t74: T74, + val t75: T75, + val t76: T76, + val t77: T77, + val t78: T78, + val t79: T79, + val t80: T80, + val t81: T81, + val t82: T82, + val t83: T83, + val t84: T84, + val t85: T85, + val t86: T86, +) : Tuple(86) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 + operator fun component56(): T56 = t56 + operator fun component57(): T57 = t57 + operator fun component58(): T58 = t58 + operator fun component59(): T59 = t59 + operator fun component60(): T60 = t60 + operator fun component61(): T61 = t61 + operator fun component62(): T62 = t62 + operator fun component63(): T63 = t63 + operator fun component64(): T64 = t64 + operator fun component65(): T65 = t65 + operator fun component66(): T66 = t66 + operator fun component67(): T67 = t67 + operator fun component68(): T68 = t68 + operator fun component69(): T69 = t69 + operator fun component70(): T70 = t70 + operator fun component71(): T71 = t71 + operator fun component72(): T72 = t72 + operator fun component73(): T73 = t73 + operator fun component74(): T74 = t74 + operator fun component75(): T75 = t75 + operator fun component76(): T76 = t76 + operator fun component77(): T77 = t77 + operator fun component78(): T78 = t78 + operator fun component79(): T79 = t79 + operator fun component80(): T80 = t80 + operator fun component81(): T81 = t81 + operator fun component82(): T82 = t82 + operator fun component83(): T83 = t83 + operator fun component84(): T84 = t84 + operator fun component85(): T85 = t85 + operator fun component86(): T86 = t86 +} + +class Tuple87( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, + val t56: T56, + val t57: T57, + val t58: T58, + val t59: T59, + val t60: T60, + val t61: T61, + val t62: T62, + val t63: T63, + val t64: T64, + val t65: T65, + val t66: T66, + val t67: T67, + val t68: T68, + val t69: T69, + val t70: T70, + val t71: T71, + val t72: T72, + val t73: T73, + val t74: T74, + val t75: T75, + val t76: T76, + val t77: T77, + val t78: T78, + val t79: T79, + val t80: T80, + val t81: T81, + val t82: T82, + val t83: T83, + val t84: T84, + val t85: T85, + val t86: T86, + val t87: T87, +) : Tuple(87) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 + operator fun component56(): T56 = t56 + operator fun component57(): T57 = t57 + operator fun component58(): T58 = t58 + operator fun component59(): T59 = t59 + operator fun component60(): T60 = t60 + operator fun component61(): T61 = t61 + operator fun component62(): T62 = t62 + operator fun component63(): T63 = t63 + operator fun component64(): T64 = t64 + operator fun component65(): T65 = t65 + operator fun component66(): T66 = t66 + operator fun component67(): T67 = t67 + operator fun component68(): T68 = t68 + operator fun component69(): T69 = t69 + operator fun component70(): T70 = t70 + operator fun component71(): T71 = t71 + operator fun component72(): T72 = t72 + operator fun component73(): T73 = t73 + operator fun component74(): T74 = t74 + operator fun component75(): T75 = t75 + operator fun component76(): T76 = t76 + operator fun component77(): T77 = t77 + operator fun component78(): T78 = t78 + operator fun component79(): T79 = t79 + operator fun component80(): T80 = t80 + operator fun component81(): T81 = t81 + operator fun component82(): T82 = t82 + operator fun component83(): T83 = t83 + operator fun component84(): T84 = t84 + operator fun component85(): T85 = t85 + operator fun component86(): T86 = t86 + operator fun component87(): T87 = t87 +} + +class Tuple88( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, + val t56: T56, + val t57: T57, + val t58: T58, + val t59: T59, + val t60: T60, + val t61: T61, + val t62: T62, + val t63: T63, + val t64: T64, + val t65: T65, + val t66: T66, + val t67: T67, + val t68: T68, + val t69: T69, + val t70: T70, + val t71: T71, + val t72: T72, + val t73: T73, + val t74: T74, + val t75: T75, + val t76: T76, + val t77: T77, + val t78: T78, + val t79: T79, + val t80: T80, + val t81: T81, + val t82: T82, + val t83: T83, + val t84: T84, + val t85: T85, + val t86: T86, + val t87: T87, + val t88: T88, +) : Tuple(88) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 + operator fun component56(): T56 = t56 + operator fun component57(): T57 = t57 + operator fun component58(): T58 = t58 + operator fun component59(): T59 = t59 + operator fun component60(): T60 = t60 + operator fun component61(): T61 = t61 + operator fun component62(): T62 = t62 + operator fun component63(): T63 = t63 + operator fun component64(): T64 = t64 + operator fun component65(): T65 = t65 + operator fun component66(): T66 = t66 + operator fun component67(): T67 = t67 + operator fun component68(): T68 = t68 + operator fun component69(): T69 = t69 + operator fun component70(): T70 = t70 + operator fun component71(): T71 = t71 + operator fun component72(): T72 = t72 + operator fun component73(): T73 = t73 + operator fun component74(): T74 = t74 + operator fun component75(): T75 = t75 + operator fun component76(): T76 = t76 + operator fun component77(): T77 = t77 + operator fun component78(): T78 = t78 + operator fun component79(): T79 = t79 + operator fun component80(): T80 = t80 + operator fun component81(): T81 = t81 + operator fun component82(): T82 = t82 + operator fun component83(): T83 = t83 + operator fun component84(): T84 = t84 + operator fun component85(): T85 = t85 + operator fun component86(): T86 = t86 + operator fun component87(): T87 = t87 + operator fun component88(): T88 = t88 +} + +class Tuple89( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, + val t56: T56, + val t57: T57, + val t58: T58, + val t59: T59, + val t60: T60, + val t61: T61, + val t62: T62, + val t63: T63, + val t64: T64, + val t65: T65, + val t66: T66, + val t67: T67, + val t68: T68, + val t69: T69, + val t70: T70, + val t71: T71, + val t72: T72, + val t73: T73, + val t74: T74, + val t75: T75, + val t76: T76, + val t77: T77, + val t78: T78, + val t79: T79, + val t80: T80, + val t81: T81, + val t82: T82, + val t83: T83, + val t84: T84, + val t85: T85, + val t86: T86, + val t87: T87, + val t88: T88, + val t89: T89, +) : Tuple(89) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 + operator fun component56(): T56 = t56 + operator fun component57(): T57 = t57 + operator fun component58(): T58 = t58 + operator fun component59(): T59 = t59 + operator fun component60(): T60 = t60 + operator fun component61(): T61 = t61 + operator fun component62(): T62 = t62 + operator fun component63(): T63 = t63 + operator fun component64(): T64 = t64 + operator fun component65(): T65 = t65 + operator fun component66(): T66 = t66 + operator fun component67(): T67 = t67 + operator fun component68(): T68 = t68 + operator fun component69(): T69 = t69 + operator fun component70(): T70 = t70 + operator fun component71(): T71 = t71 + operator fun component72(): T72 = t72 + operator fun component73(): T73 = t73 + operator fun component74(): T74 = t74 + operator fun component75(): T75 = t75 + operator fun component76(): T76 = t76 + operator fun component77(): T77 = t77 + operator fun component78(): T78 = t78 + operator fun component79(): T79 = t79 + operator fun component80(): T80 = t80 + operator fun component81(): T81 = t81 + operator fun component82(): T82 = t82 + operator fun component83(): T83 = t83 + operator fun component84(): T84 = t84 + operator fun component85(): T85 = t85 + operator fun component86(): T86 = t86 + operator fun component87(): T87 = t87 + operator fun component88(): T88 = t88 + operator fun component89(): T89 = t89 +} + +class Tuple90( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, + val t56: T56, + val t57: T57, + val t58: T58, + val t59: T59, + val t60: T60, + val t61: T61, + val t62: T62, + val t63: T63, + val t64: T64, + val t65: T65, + val t66: T66, + val t67: T67, + val t68: T68, + val t69: T69, + val t70: T70, + val t71: T71, + val t72: T72, + val t73: T73, + val t74: T74, + val t75: T75, + val t76: T76, + val t77: T77, + val t78: T78, + val t79: T79, + val t80: T80, + val t81: T81, + val t82: T82, + val t83: T83, + val t84: T84, + val t85: T85, + val t86: T86, + val t87: T87, + val t88: T88, + val t89: T89, + val t90: T90, +) : Tuple(90) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 + operator fun component56(): T56 = t56 + operator fun component57(): T57 = t57 + operator fun component58(): T58 = t58 + operator fun component59(): T59 = t59 + operator fun component60(): T60 = t60 + operator fun component61(): T61 = t61 + operator fun component62(): T62 = t62 + operator fun component63(): T63 = t63 + operator fun component64(): T64 = t64 + operator fun component65(): T65 = t65 + operator fun component66(): T66 = t66 + operator fun component67(): T67 = t67 + operator fun component68(): T68 = t68 + operator fun component69(): T69 = t69 + operator fun component70(): T70 = t70 + operator fun component71(): T71 = t71 + operator fun component72(): T72 = t72 + operator fun component73(): T73 = t73 + operator fun component74(): T74 = t74 + operator fun component75(): T75 = t75 + operator fun component76(): T76 = t76 + operator fun component77(): T77 = t77 + operator fun component78(): T78 = t78 + operator fun component79(): T79 = t79 + operator fun component80(): T80 = t80 + operator fun component81(): T81 = t81 + operator fun component82(): T82 = t82 + operator fun component83(): T83 = t83 + operator fun component84(): T84 = t84 + operator fun component85(): T85 = t85 + operator fun component86(): T86 = t86 + operator fun component87(): T87 = t87 + operator fun component88(): T88 = t88 + operator fun component89(): T89 = t89 + operator fun component90(): T90 = t90 +} + +class Tuple91( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, + val t56: T56, + val t57: T57, + val t58: T58, + val t59: T59, + val t60: T60, + val t61: T61, + val t62: T62, + val t63: T63, + val t64: T64, + val t65: T65, + val t66: T66, + val t67: T67, + val t68: T68, + val t69: T69, + val t70: T70, + val t71: T71, + val t72: T72, + val t73: T73, + val t74: T74, + val t75: T75, + val t76: T76, + val t77: T77, + val t78: T78, + val t79: T79, + val t80: T80, + val t81: T81, + val t82: T82, + val t83: T83, + val t84: T84, + val t85: T85, + val t86: T86, + val t87: T87, + val t88: T88, + val t89: T89, + val t90: T90, + val t91: T91, +) : Tuple(91) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 + operator fun component56(): T56 = t56 + operator fun component57(): T57 = t57 + operator fun component58(): T58 = t58 + operator fun component59(): T59 = t59 + operator fun component60(): T60 = t60 + operator fun component61(): T61 = t61 + operator fun component62(): T62 = t62 + operator fun component63(): T63 = t63 + operator fun component64(): T64 = t64 + operator fun component65(): T65 = t65 + operator fun component66(): T66 = t66 + operator fun component67(): T67 = t67 + operator fun component68(): T68 = t68 + operator fun component69(): T69 = t69 + operator fun component70(): T70 = t70 + operator fun component71(): T71 = t71 + operator fun component72(): T72 = t72 + operator fun component73(): T73 = t73 + operator fun component74(): T74 = t74 + operator fun component75(): T75 = t75 + operator fun component76(): T76 = t76 + operator fun component77(): T77 = t77 + operator fun component78(): T78 = t78 + operator fun component79(): T79 = t79 + operator fun component80(): T80 = t80 + operator fun component81(): T81 = t81 + operator fun component82(): T82 = t82 + operator fun component83(): T83 = t83 + operator fun component84(): T84 = t84 + operator fun component85(): T85 = t85 + operator fun component86(): T86 = t86 + operator fun component87(): T87 = t87 + operator fun component88(): T88 = t88 + operator fun component89(): T89 = t89 + operator fun component90(): T90 = t90 + operator fun component91(): T91 = t91 +} + +class Tuple92( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, + val t56: T56, + val t57: T57, + val t58: T58, + val t59: T59, + val t60: T60, + val t61: T61, + val t62: T62, + val t63: T63, + val t64: T64, + val t65: T65, + val t66: T66, + val t67: T67, + val t68: T68, + val t69: T69, + val t70: T70, + val t71: T71, + val t72: T72, + val t73: T73, + val t74: T74, + val t75: T75, + val t76: T76, + val t77: T77, + val t78: T78, + val t79: T79, + val t80: T80, + val t81: T81, + val t82: T82, + val t83: T83, + val t84: T84, + val t85: T85, + val t86: T86, + val t87: T87, + val t88: T88, + val t89: T89, + val t90: T90, + val t91: T91, + val t92: T92, +) : Tuple(92) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 + operator fun component56(): T56 = t56 + operator fun component57(): T57 = t57 + operator fun component58(): T58 = t58 + operator fun component59(): T59 = t59 + operator fun component60(): T60 = t60 + operator fun component61(): T61 = t61 + operator fun component62(): T62 = t62 + operator fun component63(): T63 = t63 + operator fun component64(): T64 = t64 + operator fun component65(): T65 = t65 + operator fun component66(): T66 = t66 + operator fun component67(): T67 = t67 + operator fun component68(): T68 = t68 + operator fun component69(): T69 = t69 + operator fun component70(): T70 = t70 + operator fun component71(): T71 = t71 + operator fun component72(): T72 = t72 + operator fun component73(): T73 = t73 + operator fun component74(): T74 = t74 + operator fun component75(): T75 = t75 + operator fun component76(): T76 = t76 + operator fun component77(): T77 = t77 + operator fun component78(): T78 = t78 + operator fun component79(): T79 = t79 + operator fun component80(): T80 = t80 + operator fun component81(): T81 = t81 + operator fun component82(): T82 = t82 + operator fun component83(): T83 = t83 + operator fun component84(): T84 = t84 + operator fun component85(): T85 = t85 + operator fun component86(): T86 = t86 + operator fun component87(): T87 = t87 + operator fun component88(): T88 = t88 + operator fun component89(): T89 = t89 + operator fun component90(): T90 = t90 + operator fun component91(): T91 = t91 + operator fun component92(): T92 = t92 +} + +class Tuple93( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, + val t56: T56, + val t57: T57, + val t58: T58, + val t59: T59, + val t60: T60, + val t61: T61, + val t62: T62, + val t63: T63, + val t64: T64, + val t65: T65, + val t66: T66, + val t67: T67, + val t68: T68, + val t69: T69, + val t70: T70, + val t71: T71, + val t72: T72, + val t73: T73, + val t74: T74, + val t75: T75, + val t76: T76, + val t77: T77, + val t78: T78, + val t79: T79, + val t80: T80, + val t81: T81, + val t82: T82, + val t83: T83, + val t84: T84, + val t85: T85, + val t86: T86, + val t87: T87, + val t88: T88, + val t89: T89, + val t90: T90, + val t91: T91, + val t92: T92, + val t93: T93, +) : Tuple(93) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 + operator fun component56(): T56 = t56 + operator fun component57(): T57 = t57 + operator fun component58(): T58 = t58 + operator fun component59(): T59 = t59 + operator fun component60(): T60 = t60 + operator fun component61(): T61 = t61 + operator fun component62(): T62 = t62 + operator fun component63(): T63 = t63 + operator fun component64(): T64 = t64 + operator fun component65(): T65 = t65 + operator fun component66(): T66 = t66 + operator fun component67(): T67 = t67 + operator fun component68(): T68 = t68 + operator fun component69(): T69 = t69 + operator fun component70(): T70 = t70 + operator fun component71(): T71 = t71 + operator fun component72(): T72 = t72 + operator fun component73(): T73 = t73 + operator fun component74(): T74 = t74 + operator fun component75(): T75 = t75 + operator fun component76(): T76 = t76 + operator fun component77(): T77 = t77 + operator fun component78(): T78 = t78 + operator fun component79(): T79 = t79 + operator fun component80(): T80 = t80 + operator fun component81(): T81 = t81 + operator fun component82(): T82 = t82 + operator fun component83(): T83 = t83 + operator fun component84(): T84 = t84 + operator fun component85(): T85 = t85 + operator fun component86(): T86 = t86 + operator fun component87(): T87 = t87 + operator fun component88(): T88 = t88 + operator fun component89(): T89 = t89 + operator fun component90(): T90 = t90 + operator fun component91(): T91 = t91 + operator fun component92(): T92 = t92 + operator fun component93(): T93 = t93 +} + +class Tuple94( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, + val t56: T56, + val t57: T57, + val t58: T58, + val t59: T59, + val t60: T60, + val t61: T61, + val t62: T62, + val t63: T63, + val t64: T64, + val t65: T65, + val t66: T66, + val t67: T67, + val t68: T68, + val t69: T69, + val t70: T70, + val t71: T71, + val t72: T72, + val t73: T73, + val t74: T74, + val t75: T75, + val t76: T76, + val t77: T77, + val t78: T78, + val t79: T79, + val t80: T80, + val t81: T81, + val t82: T82, + val t83: T83, + val t84: T84, + val t85: T85, + val t86: T86, + val t87: T87, + val t88: T88, + val t89: T89, + val t90: T90, + val t91: T91, + val t92: T92, + val t93: T93, + val t94: T94, +) : Tuple(94) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 + operator fun component56(): T56 = t56 + operator fun component57(): T57 = t57 + operator fun component58(): T58 = t58 + operator fun component59(): T59 = t59 + operator fun component60(): T60 = t60 + operator fun component61(): T61 = t61 + operator fun component62(): T62 = t62 + operator fun component63(): T63 = t63 + operator fun component64(): T64 = t64 + operator fun component65(): T65 = t65 + operator fun component66(): T66 = t66 + operator fun component67(): T67 = t67 + operator fun component68(): T68 = t68 + operator fun component69(): T69 = t69 + operator fun component70(): T70 = t70 + operator fun component71(): T71 = t71 + operator fun component72(): T72 = t72 + operator fun component73(): T73 = t73 + operator fun component74(): T74 = t74 + operator fun component75(): T75 = t75 + operator fun component76(): T76 = t76 + operator fun component77(): T77 = t77 + operator fun component78(): T78 = t78 + operator fun component79(): T79 = t79 + operator fun component80(): T80 = t80 + operator fun component81(): T81 = t81 + operator fun component82(): T82 = t82 + operator fun component83(): T83 = t83 + operator fun component84(): T84 = t84 + operator fun component85(): T85 = t85 + operator fun component86(): T86 = t86 + operator fun component87(): T87 = t87 + operator fun component88(): T88 = t88 + operator fun component89(): T89 = t89 + operator fun component90(): T90 = t90 + operator fun component91(): T91 = t91 + operator fun component92(): T92 = t92 + operator fun component93(): T93 = t93 + operator fun component94(): T94 = t94 +} + +class Tuple95( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, + val t56: T56, + val t57: T57, + val t58: T58, + val t59: T59, + val t60: T60, + val t61: T61, + val t62: T62, + val t63: T63, + val t64: T64, + val t65: T65, + val t66: T66, + val t67: T67, + val t68: T68, + val t69: T69, + val t70: T70, + val t71: T71, + val t72: T72, + val t73: T73, + val t74: T74, + val t75: T75, + val t76: T76, + val t77: T77, + val t78: T78, + val t79: T79, + val t80: T80, + val t81: T81, + val t82: T82, + val t83: T83, + val t84: T84, + val t85: T85, + val t86: T86, + val t87: T87, + val t88: T88, + val t89: T89, + val t90: T90, + val t91: T91, + val t92: T92, + val t93: T93, + val t94: T94, + val t95: T95, +) : Tuple(95) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 + operator fun component56(): T56 = t56 + operator fun component57(): T57 = t57 + operator fun component58(): T58 = t58 + operator fun component59(): T59 = t59 + operator fun component60(): T60 = t60 + operator fun component61(): T61 = t61 + operator fun component62(): T62 = t62 + operator fun component63(): T63 = t63 + operator fun component64(): T64 = t64 + operator fun component65(): T65 = t65 + operator fun component66(): T66 = t66 + operator fun component67(): T67 = t67 + operator fun component68(): T68 = t68 + operator fun component69(): T69 = t69 + operator fun component70(): T70 = t70 + operator fun component71(): T71 = t71 + operator fun component72(): T72 = t72 + operator fun component73(): T73 = t73 + operator fun component74(): T74 = t74 + operator fun component75(): T75 = t75 + operator fun component76(): T76 = t76 + operator fun component77(): T77 = t77 + operator fun component78(): T78 = t78 + operator fun component79(): T79 = t79 + operator fun component80(): T80 = t80 + operator fun component81(): T81 = t81 + operator fun component82(): T82 = t82 + operator fun component83(): T83 = t83 + operator fun component84(): T84 = t84 + operator fun component85(): T85 = t85 + operator fun component86(): T86 = t86 + operator fun component87(): T87 = t87 + operator fun component88(): T88 = t88 + operator fun component89(): T89 = t89 + operator fun component90(): T90 = t90 + operator fun component91(): T91 = t91 + operator fun component92(): T92 = t92 + operator fun component93(): T93 = t93 + operator fun component94(): T94 = t94 + operator fun component95(): T95 = t95 +} + +class Tuple96( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, + val t56: T56, + val t57: T57, + val t58: T58, + val t59: T59, + val t60: T60, + val t61: T61, + val t62: T62, + val t63: T63, + val t64: T64, + val t65: T65, + val t66: T66, + val t67: T67, + val t68: T68, + val t69: T69, + val t70: T70, + val t71: T71, + val t72: T72, + val t73: T73, + val t74: T74, + val t75: T75, + val t76: T76, + val t77: T77, + val t78: T78, + val t79: T79, + val t80: T80, + val t81: T81, + val t82: T82, + val t83: T83, + val t84: T84, + val t85: T85, + val t86: T86, + val t87: T87, + val t88: T88, + val t89: T89, + val t90: T90, + val t91: T91, + val t92: T92, + val t93: T93, + val t94: T94, + val t95: T95, + val t96: T96, +) : Tuple(96) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 + operator fun component56(): T56 = t56 + operator fun component57(): T57 = t57 + operator fun component58(): T58 = t58 + operator fun component59(): T59 = t59 + operator fun component60(): T60 = t60 + operator fun component61(): T61 = t61 + operator fun component62(): T62 = t62 + operator fun component63(): T63 = t63 + operator fun component64(): T64 = t64 + operator fun component65(): T65 = t65 + operator fun component66(): T66 = t66 + operator fun component67(): T67 = t67 + operator fun component68(): T68 = t68 + operator fun component69(): T69 = t69 + operator fun component70(): T70 = t70 + operator fun component71(): T71 = t71 + operator fun component72(): T72 = t72 + operator fun component73(): T73 = t73 + operator fun component74(): T74 = t74 + operator fun component75(): T75 = t75 + operator fun component76(): T76 = t76 + operator fun component77(): T77 = t77 + operator fun component78(): T78 = t78 + operator fun component79(): T79 = t79 + operator fun component80(): T80 = t80 + operator fun component81(): T81 = t81 + operator fun component82(): T82 = t82 + operator fun component83(): T83 = t83 + operator fun component84(): T84 = t84 + operator fun component85(): T85 = t85 + operator fun component86(): T86 = t86 + operator fun component87(): T87 = t87 + operator fun component88(): T88 = t88 + operator fun component89(): T89 = t89 + operator fun component90(): T90 = t90 + operator fun component91(): T91 = t91 + operator fun component92(): T92 = t92 + operator fun component93(): T93 = t93 + operator fun component94(): T94 = t94 + operator fun component95(): T95 = t95 + operator fun component96(): T96 = t96 +} + +class Tuple97( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, + val t56: T56, + val t57: T57, + val t58: T58, + val t59: T59, + val t60: T60, + val t61: T61, + val t62: T62, + val t63: T63, + val t64: T64, + val t65: T65, + val t66: T66, + val t67: T67, + val t68: T68, + val t69: T69, + val t70: T70, + val t71: T71, + val t72: T72, + val t73: T73, + val t74: T74, + val t75: T75, + val t76: T76, + val t77: T77, + val t78: T78, + val t79: T79, + val t80: T80, + val t81: T81, + val t82: T82, + val t83: T83, + val t84: T84, + val t85: T85, + val t86: T86, + val t87: T87, + val t88: T88, + val t89: T89, + val t90: T90, + val t91: T91, + val t92: T92, + val t93: T93, + val t94: T94, + val t95: T95, + val t96: T96, + val t97: T97, +) : Tuple(97) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 + operator fun component56(): T56 = t56 + operator fun component57(): T57 = t57 + operator fun component58(): T58 = t58 + operator fun component59(): T59 = t59 + operator fun component60(): T60 = t60 + operator fun component61(): T61 = t61 + operator fun component62(): T62 = t62 + operator fun component63(): T63 = t63 + operator fun component64(): T64 = t64 + operator fun component65(): T65 = t65 + operator fun component66(): T66 = t66 + operator fun component67(): T67 = t67 + operator fun component68(): T68 = t68 + operator fun component69(): T69 = t69 + operator fun component70(): T70 = t70 + operator fun component71(): T71 = t71 + operator fun component72(): T72 = t72 + operator fun component73(): T73 = t73 + operator fun component74(): T74 = t74 + operator fun component75(): T75 = t75 + operator fun component76(): T76 = t76 + operator fun component77(): T77 = t77 + operator fun component78(): T78 = t78 + operator fun component79(): T79 = t79 + operator fun component80(): T80 = t80 + operator fun component81(): T81 = t81 + operator fun component82(): T82 = t82 + operator fun component83(): T83 = t83 + operator fun component84(): T84 = t84 + operator fun component85(): T85 = t85 + operator fun component86(): T86 = t86 + operator fun component87(): T87 = t87 + operator fun component88(): T88 = t88 + operator fun component89(): T89 = t89 + operator fun component90(): T90 = t90 + operator fun component91(): T91 = t91 + operator fun component92(): T92 = t92 + operator fun component93(): T93 = t93 + operator fun component94(): T94 = t94 + operator fun component95(): T95 = t95 + operator fun component96(): T96 = t96 + operator fun component97(): T97 = t97 +} + +class Tuple98( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, + val t56: T56, + val t57: T57, + val t58: T58, + val t59: T59, + val t60: T60, + val t61: T61, + val t62: T62, + val t63: T63, + val t64: T64, + val t65: T65, + val t66: T66, + val t67: T67, + val t68: T68, + val t69: T69, + val t70: T70, + val t71: T71, + val t72: T72, + val t73: T73, + val t74: T74, + val t75: T75, + val t76: T76, + val t77: T77, + val t78: T78, + val t79: T79, + val t80: T80, + val t81: T81, + val t82: T82, + val t83: T83, + val t84: T84, + val t85: T85, + val t86: T86, + val t87: T87, + val t88: T88, + val t89: T89, + val t90: T90, + val t91: T91, + val t92: T92, + val t93: T93, + val t94: T94, + val t95: T95, + val t96: T96, + val t97: T97, + val t98: T98, +) : Tuple(98) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 + operator fun component56(): T56 = t56 + operator fun component57(): T57 = t57 + operator fun component58(): T58 = t58 + operator fun component59(): T59 = t59 + operator fun component60(): T60 = t60 + operator fun component61(): T61 = t61 + operator fun component62(): T62 = t62 + operator fun component63(): T63 = t63 + operator fun component64(): T64 = t64 + operator fun component65(): T65 = t65 + operator fun component66(): T66 = t66 + operator fun component67(): T67 = t67 + operator fun component68(): T68 = t68 + operator fun component69(): T69 = t69 + operator fun component70(): T70 = t70 + operator fun component71(): T71 = t71 + operator fun component72(): T72 = t72 + operator fun component73(): T73 = t73 + operator fun component74(): T74 = t74 + operator fun component75(): T75 = t75 + operator fun component76(): T76 = t76 + operator fun component77(): T77 = t77 + operator fun component78(): T78 = t78 + operator fun component79(): T79 = t79 + operator fun component80(): T80 = t80 + operator fun component81(): T81 = t81 + operator fun component82(): T82 = t82 + operator fun component83(): T83 = t83 + operator fun component84(): T84 = t84 + operator fun component85(): T85 = t85 + operator fun component86(): T86 = t86 + operator fun component87(): T87 = t87 + operator fun component88(): T88 = t88 + operator fun component89(): T89 = t89 + operator fun component90(): T90 = t90 + operator fun component91(): T91 = t91 + operator fun component92(): T92 = t92 + operator fun component93(): T93 = t93 + operator fun component94(): T94 = t94 + operator fun component95(): T95 = t95 + operator fun component96(): T96 = t96 + operator fun component97(): T97 = t97 + operator fun component98(): T98 = t98 +} + +class Tuple99( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, + val t56: T56, + val t57: T57, + val t58: T58, + val t59: T59, + val t60: T60, + val t61: T61, + val t62: T62, + val t63: T63, + val t64: T64, + val t65: T65, + val t66: T66, + val t67: T67, + val t68: T68, + val t69: T69, + val t70: T70, + val t71: T71, + val t72: T72, + val t73: T73, + val t74: T74, + val t75: T75, + val t76: T76, + val t77: T77, + val t78: T78, + val t79: T79, + val t80: T80, + val t81: T81, + val t82: T82, + val t83: T83, + val t84: T84, + val t85: T85, + val t86: T86, + val t87: T87, + val t88: T88, + val t89: T89, + val t90: T90, + val t91: T91, + val t92: T92, + val t93: T93, + val t94: T94, + val t95: T95, + val t96: T96, + val t97: T97, + val t98: T98, + val t99: T99, +) : Tuple(99) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 + operator fun component56(): T56 = t56 + operator fun component57(): T57 = t57 + operator fun component58(): T58 = t58 + operator fun component59(): T59 = t59 + operator fun component60(): T60 = t60 + operator fun component61(): T61 = t61 + operator fun component62(): T62 = t62 + operator fun component63(): T63 = t63 + operator fun component64(): T64 = t64 + operator fun component65(): T65 = t65 + operator fun component66(): T66 = t66 + operator fun component67(): T67 = t67 + operator fun component68(): T68 = t68 + operator fun component69(): T69 = t69 + operator fun component70(): T70 = t70 + operator fun component71(): T71 = t71 + operator fun component72(): T72 = t72 + operator fun component73(): T73 = t73 + operator fun component74(): T74 = t74 + operator fun component75(): T75 = t75 + operator fun component76(): T76 = t76 + operator fun component77(): T77 = t77 + operator fun component78(): T78 = t78 + operator fun component79(): T79 = t79 + operator fun component80(): T80 = t80 + operator fun component81(): T81 = t81 + operator fun component82(): T82 = t82 + operator fun component83(): T83 = t83 + operator fun component84(): T84 = t84 + operator fun component85(): T85 = t85 + operator fun component86(): T86 = t86 + operator fun component87(): T87 = t87 + operator fun component88(): T88 = t88 + operator fun component89(): T89 = t89 + operator fun component90(): T90 = t90 + operator fun component91(): T91 = t91 + operator fun component92(): T92 = t92 + operator fun component93(): T93 = t93 + operator fun component94(): T94 = t94 + operator fun component95(): T95 = t95 + operator fun component96(): T96 = t96 + operator fun component97(): T97 = t97 + operator fun component98(): T98 = t98 + operator fun component99(): T99 = t99 +} + +class Tuple100( + val t1: T1, + val t2: T2, + val t3: T3, + val t4: T4, + val t5: T5, + val t6: T6, + val t7: T7, + val t8: T8, + val t9: T9, + val t10: T10, + val t11: T11, + val t12: T12, + val t13: T13, + val t14: T14, + val t15: T15, + val t16: T16, + val t17: T17, + val t18: T18, + val t19: T19, + val t20: T20, + val t21: T21, + val t22: T22, + val t23: T23, + val t24: T24, + val t25: T25, + val t26: T26, + val t27: T27, + val t28: T28, + val t29: T29, + val t30: T30, + val t31: T31, + val t32: T32, + val t33: T33, + val t34: T34, + val t35: T35, + val t36: T36, + val t37: T37, + val t38: T38, + val t39: T39, + val t40: T40, + val t41: T41, + val t42: T42, + val t43: T43, + val t44: T44, + val t45: T45, + val t46: T46, + val t47: T47, + val t48: T48, + val t49: T49, + val t50: T50, + val t51: T51, + val t52: T52, + val t53: T53, + val t54: T54, + val t55: T55, + val t56: T56, + val t57: T57, + val t58: T58, + val t59: T59, + val t60: T60, + val t61: T61, + val t62: T62, + val t63: T63, + val t64: T64, + val t65: T65, + val t66: T66, + val t67: T67, + val t68: T68, + val t69: T69, + val t70: T70, + val t71: T71, + val t72: T72, + val t73: T73, + val t74: T74, + val t75: T75, + val t76: T76, + val t77: T77, + val t78: T78, + val t79: T79, + val t80: T80, + val t81: T81, + val t82: T82, + val t83: T83, + val t84: T84, + val t85: T85, + val t86: T86, + val t87: T87, + val t88: T88, + val t89: T89, + val t90: T90, + val t91: T91, + val t92: T92, + val t93: T93, + val t94: T94, + val t95: T95, + val t96: T96, + val t97: T97, + val t98: T98, + val t99: T99, + val t100: T100, +) : Tuple(100) { + operator fun component1(): T1 = t1 + operator fun component2(): T2 = t2 + operator fun component3(): T3 = t3 + operator fun component4(): T4 = t4 + operator fun component5(): T5 = t5 + operator fun component6(): T6 = t6 + operator fun component7(): T7 = t7 + operator fun component8(): T8 = t8 + operator fun component9(): T9 = t9 + operator fun component10(): T10 = t10 + operator fun component11(): T11 = t11 + operator fun component12(): T12 = t12 + operator fun component13(): T13 = t13 + operator fun component14(): T14 = t14 + operator fun component15(): T15 = t15 + operator fun component16(): T16 = t16 + operator fun component17(): T17 = t17 + operator fun component18(): T18 = t18 + operator fun component19(): T19 = t19 + operator fun component20(): T20 = t20 + operator fun component21(): T21 = t21 + operator fun component22(): T22 = t22 + operator fun component23(): T23 = t23 + operator fun component24(): T24 = t24 + operator fun component25(): T25 = t25 + operator fun component26(): T26 = t26 + operator fun component27(): T27 = t27 + operator fun component28(): T28 = t28 + operator fun component29(): T29 = t29 + operator fun component30(): T30 = t30 + operator fun component31(): T31 = t31 + operator fun component32(): T32 = t32 + operator fun component33(): T33 = t33 + operator fun component34(): T34 = t34 + operator fun component35(): T35 = t35 + operator fun component36(): T36 = t36 + operator fun component37(): T37 = t37 + operator fun component38(): T38 = t38 + operator fun component39(): T39 = t39 + operator fun component40(): T40 = t40 + operator fun component41(): T41 = t41 + operator fun component42(): T42 = t42 + operator fun component43(): T43 = t43 + operator fun component44(): T44 = t44 + operator fun component45(): T45 = t45 + operator fun component46(): T46 = t46 + operator fun component47(): T47 = t47 + operator fun component48(): T48 = t48 + operator fun component49(): T49 = t49 + operator fun component50(): T50 = t50 + operator fun component51(): T51 = t51 + operator fun component52(): T52 = t52 + operator fun component53(): T53 = t53 + operator fun component54(): T54 = t54 + operator fun component55(): T55 = t55 + operator fun component56(): T56 = t56 + operator fun component57(): T57 = t57 + operator fun component58(): T58 = t58 + operator fun component59(): T59 = t59 + operator fun component60(): T60 = t60 + operator fun component61(): T61 = t61 + operator fun component62(): T62 = t62 + operator fun component63(): T63 = t63 + operator fun component64(): T64 = t64 + operator fun component65(): T65 = t65 + operator fun component66(): T66 = t66 + operator fun component67(): T67 = t67 + operator fun component68(): T68 = t68 + operator fun component69(): T69 = t69 + operator fun component70(): T70 = t70 + operator fun component71(): T71 = t71 + operator fun component72(): T72 = t72 + operator fun component73(): T73 = t73 + operator fun component74(): T74 = t74 + operator fun component75(): T75 = t75 + operator fun component76(): T76 = t76 + operator fun component77(): T77 = t77 + operator fun component78(): T78 = t78 + operator fun component79(): T79 = t79 + operator fun component80(): T80 = t80 + operator fun component81(): T81 = t81 + operator fun component82(): T82 = t82 + operator fun component83(): T83 = t83 + operator fun component84(): T84 = t84 + operator fun component85(): T85 = t85 + operator fun component86(): T86 = t86 + operator fun component87(): T87 = t87 + operator fun component88(): T88 = t88 + operator fun component89(): T89 = t89 + operator fun component90(): T90 = t90 + operator fun component91(): T91 = t91 + operator fun component92(): T92 = t92 + operator fun component93(): T93 = t93 + operator fun component94(): T94 = t94 + operator fun component95(): T95 = t95 + operator fun component96(): T96 = t96 + operator fun component97(): T97 = t97 + operator fun component98(): T98 = t98 + operator fun component99(): T99 = t99 + operator fun component100(): T100 = t100 +} diff --git a/src/main/kotlin/com/mingliqiye/utils/tuple/Tuples.kt b/src/main/kotlin/com/mingliqiye/utils/tuple/Tuples.kt new file mode 100644 index 0000000..bdbeb49 --- /dev/null +++ b/src/main/kotlin/com/mingliqiye/utils/tuple/Tuples.kt @@ -0,0 +1,10351 @@ +/* + * Copyright 2026 mingliqiye + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * ProjectName mingli-utils + * ModuleName mingli-utils.main + * CurrentFile Tuples.kt + * LastUpdate 2026-06-21 10:40:58 + * UpdateUser MingLiPro + */ + +package com.mingliqiye.utils.tuple + + +import java.io.Serializable + +abstract class Tuple(val size: Int = 1) : Serializable, Iterable { + + override fun iterator(): Iterator { + return object : Iterator { + private var index: Int = 0 + override fun next(): Any { + if (!hasNext()) throw NoSuchElementException("element next is None") + return get(index++) + } + + override fun hasNext(): Boolean = index < size + } + } + + open fun toList(): List { + return (0.. { + return toList().toMutableList() + } + + open fun toSet(): Set { + return toList().toSet() + } + + open fun toMutableSet(): MutableSet { + return toList().toMutableSet() + } + + operator fun get(index: Int): Any { + if (index >= size) { + throw IndexOutOfBoundsException("index $index is out size $size") + } + return this.javaClass.getDeclaredMethod("component${index + 1}").invoke(this) + } + + companion object { + @JvmStatic + fun of(t1: T1) = Tuple1(t1) + + @JvmStatic + fun of(t1: T1, t2: T2) = Tuple2(t1, t2) + + @JvmStatic + fun of(t1: T1, t2: T2, t3: T3) = Tuple3(t1, t2, t3) + + @JvmStatic + fun of(t1: T1, t2: T2, t3: T3, t4: T4) = Tuple4(t1, t2, t3, t4) + + @JvmStatic + fun of(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) = Tuple5(t1, t2, t3, t4, t5) + + @JvmStatic + fun of(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6) = Tuple6(t1, t2, t3, t4, t5, t6) + + @JvmStatic + fun of(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7) = + Tuple7(t1, t2, t3, t4, t5, t6, t7) + + @JvmStatic + fun of(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8) = + Tuple8(t1, t2, t3, t4, t5, t6, t7, t8) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + ) = Tuple9(t1, t2, t3, t4, t5, t6, t7, t8, t9) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + ) = Tuple10(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + ) = Tuple11(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + ) = Tuple12(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + ) = Tuple13(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + ) = Tuple14(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + ) = Tuple15(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + ) = Tuple16(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + ) = Tuple17(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + ) = Tuple18(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + ) = Tuple19(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + ) = Tuple20(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + ) = Tuple21(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + ) = Tuple22(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21, t22) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + ) = Tuple23( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + ) = Tuple24( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + ) = Tuple25( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + ) = Tuple26( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + ) = Tuple27( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + ) = Tuple28( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + ) = Tuple29( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + ) = Tuple30( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + ) = Tuple31( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + ) = Tuple32( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + ) = Tuple33( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + ) = Tuple34( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + ) = Tuple35( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + ) = Tuple36( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + ) = Tuple37( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + ) = Tuple38( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + ) = Tuple39( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + ) = Tuple40( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + ) = Tuple41( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + ) = Tuple42( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + ) = Tuple43( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + ) = Tuple44( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + ) = Tuple45( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + ) = Tuple46( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + ) = Tuple47( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + ) = Tuple48( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + ) = Tuple49( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + ) = Tuple50( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + ) = Tuple51( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + ) = Tuple52( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + ) = Tuple53( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + ) = Tuple54( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + ) = Tuple55( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + t56: T56, + ) = Tuple56( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55, + t56 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + t56: T56, + t57: T57, + ) = Tuple57( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55, + t56, + t57 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + t56: T56, + t57: T57, + t58: T58, + ) = Tuple58( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55, + t56, + t57, + t58 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + t56: T56, + t57: T57, + t58: T58, + t59: T59, + ) = Tuple59( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55, + t56, + t57, + t58, + t59 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + t56: T56, + t57: T57, + t58: T58, + t59: T59, + t60: T60, + ) = Tuple60( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55, + t56, + t57, + t58, + t59, + t60 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + t56: T56, + t57: T57, + t58: T58, + t59: T59, + t60: T60, + t61: T61, + ) = Tuple61( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55, + t56, + t57, + t58, + t59, + t60, + t61 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + t56: T56, + t57: T57, + t58: T58, + t59: T59, + t60: T60, + t61: T61, + t62: T62, + ) = Tuple62( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55, + t56, + t57, + t58, + t59, + t60, + t61, + t62 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + t56: T56, + t57: T57, + t58: T58, + t59: T59, + t60: T60, + t61: T61, + t62: T62, + t63: T63, + ) = Tuple63( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55, + t56, + t57, + t58, + t59, + t60, + t61, + t62, + t63 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + t56: T56, + t57: T57, + t58: T58, + t59: T59, + t60: T60, + t61: T61, + t62: T62, + t63: T63, + t64: T64, + ) = Tuple64( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55, + t56, + t57, + t58, + t59, + t60, + t61, + t62, + t63, + t64 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + t56: T56, + t57: T57, + t58: T58, + t59: T59, + t60: T60, + t61: T61, + t62: T62, + t63: T63, + t64: T64, + t65: T65, + ) = Tuple65( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55, + t56, + t57, + t58, + t59, + t60, + t61, + t62, + t63, + t64, + t65 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + t56: T56, + t57: T57, + t58: T58, + t59: T59, + t60: T60, + t61: T61, + t62: T62, + t63: T63, + t64: T64, + t65: T65, + t66: T66, + ) = Tuple66( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55, + t56, + t57, + t58, + t59, + t60, + t61, + t62, + t63, + t64, + t65, + t66 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + t56: T56, + t57: T57, + t58: T58, + t59: T59, + t60: T60, + t61: T61, + t62: T62, + t63: T63, + t64: T64, + t65: T65, + t66: T66, + t67: T67, + ) = Tuple67( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55, + t56, + t57, + t58, + t59, + t60, + t61, + t62, + t63, + t64, + t65, + t66, + t67 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + t56: T56, + t57: T57, + t58: T58, + t59: T59, + t60: T60, + t61: T61, + t62: T62, + t63: T63, + t64: T64, + t65: T65, + t66: T66, + t67: T67, + t68: T68, + ) = Tuple68( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55, + t56, + t57, + t58, + t59, + t60, + t61, + t62, + t63, + t64, + t65, + t66, + t67, + t68 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + t56: T56, + t57: T57, + t58: T58, + t59: T59, + t60: T60, + t61: T61, + t62: T62, + t63: T63, + t64: T64, + t65: T65, + t66: T66, + t67: T67, + t68: T68, + t69: T69, + ) = Tuple69( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55, + t56, + t57, + t58, + t59, + t60, + t61, + t62, + t63, + t64, + t65, + t66, + t67, + t68, + t69 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + t56: T56, + t57: T57, + t58: T58, + t59: T59, + t60: T60, + t61: T61, + t62: T62, + t63: T63, + t64: T64, + t65: T65, + t66: T66, + t67: T67, + t68: T68, + t69: T69, + t70: T70, + ) = Tuple70( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55, + t56, + t57, + t58, + t59, + t60, + t61, + t62, + t63, + t64, + t65, + t66, + t67, + t68, + t69, + t70 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + t56: T56, + t57: T57, + t58: T58, + t59: T59, + t60: T60, + t61: T61, + t62: T62, + t63: T63, + t64: T64, + t65: T65, + t66: T66, + t67: T67, + t68: T68, + t69: T69, + t70: T70, + t71: T71, + ) = Tuple71( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55, + t56, + t57, + t58, + t59, + t60, + t61, + t62, + t63, + t64, + t65, + t66, + t67, + t68, + t69, + t70, + t71 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + t56: T56, + t57: T57, + t58: T58, + t59: T59, + t60: T60, + t61: T61, + t62: T62, + t63: T63, + t64: T64, + t65: T65, + t66: T66, + t67: T67, + t68: T68, + t69: T69, + t70: T70, + t71: T71, + t72: T72, + ) = Tuple72( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55, + t56, + t57, + t58, + t59, + t60, + t61, + t62, + t63, + t64, + t65, + t66, + t67, + t68, + t69, + t70, + t71, + t72 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + t56: T56, + t57: T57, + t58: T58, + t59: T59, + t60: T60, + t61: T61, + t62: T62, + t63: T63, + t64: T64, + t65: T65, + t66: T66, + t67: T67, + t68: T68, + t69: T69, + t70: T70, + t71: T71, + t72: T72, + t73: T73, + ) = Tuple73( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55, + t56, + t57, + t58, + t59, + t60, + t61, + t62, + t63, + t64, + t65, + t66, + t67, + t68, + t69, + t70, + t71, + t72, + t73 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + t56: T56, + t57: T57, + t58: T58, + t59: T59, + t60: T60, + t61: T61, + t62: T62, + t63: T63, + t64: T64, + t65: T65, + t66: T66, + t67: T67, + t68: T68, + t69: T69, + t70: T70, + t71: T71, + t72: T72, + t73: T73, + t74: T74, + ) = Tuple74( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55, + t56, + t57, + t58, + t59, + t60, + t61, + t62, + t63, + t64, + t65, + t66, + t67, + t68, + t69, + t70, + t71, + t72, + t73, + t74 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + t56: T56, + t57: T57, + t58: T58, + t59: T59, + t60: T60, + t61: T61, + t62: T62, + t63: T63, + t64: T64, + t65: T65, + t66: T66, + t67: T67, + t68: T68, + t69: T69, + t70: T70, + t71: T71, + t72: T72, + t73: T73, + t74: T74, + t75: T75, + ) = Tuple75( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55, + t56, + t57, + t58, + t59, + t60, + t61, + t62, + t63, + t64, + t65, + t66, + t67, + t68, + t69, + t70, + t71, + t72, + t73, + t74, + t75 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + t56: T56, + t57: T57, + t58: T58, + t59: T59, + t60: T60, + t61: T61, + t62: T62, + t63: T63, + t64: T64, + t65: T65, + t66: T66, + t67: T67, + t68: T68, + t69: T69, + t70: T70, + t71: T71, + t72: T72, + t73: T73, + t74: T74, + t75: T75, + t76: T76, + ) = Tuple76( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55, + t56, + t57, + t58, + t59, + t60, + t61, + t62, + t63, + t64, + t65, + t66, + t67, + t68, + t69, + t70, + t71, + t72, + t73, + t74, + t75, + t76 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + t56: T56, + t57: T57, + t58: T58, + t59: T59, + t60: T60, + t61: T61, + t62: T62, + t63: T63, + t64: T64, + t65: T65, + t66: T66, + t67: T67, + t68: T68, + t69: T69, + t70: T70, + t71: T71, + t72: T72, + t73: T73, + t74: T74, + t75: T75, + t76: T76, + t77: T77, + ) = Tuple77( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55, + t56, + t57, + t58, + t59, + t60, + t61, + t62, + t63, + t64, + t65, + t66, + t67, + t68, + t69, + t70, + t71, + t72, + t73, + t74, + t75, + t76, + t77 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + t56: T56, + t57: T57, + t58: T58, + t59: T59, + t60: T60, + t61: T61, + t62: T62, + t63: T63, + t64: T64, + t65: T65, + t66: T66, + t67: T67, + t68: T68, + t69: T69, + t70: T70, + t71: T71, + t72: T72, + t73: T73, + t74: T74, + t75: T75, + t76: T76, + t77: T77, + t78: T78, + ) = Tuple78( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55, + t56, + t57, + t58, + t59, + t60, + t61, + t62, + t63, + t64, + t65, + t66, + t67, + t68, + t69, + t70, + t71, + t72, + t73, + t74, + t75, + t76, + t77, + t78 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + t56: T56, + t57: T57, + t58: T58, + t59: T59, + t60: T60, + t61: T61, + t62: T62, + t63: T63, + t64: T64, + t65: T65, + t66: T66, + t67: T67, + t68: T68, + t69: T69, + t70: T70, + t71: T71, + t72: T72, + t73: T73, + t74: T74, + t75: T75, + t76: T76, + t77: T77, + t78: T78, + t79: T79, + ) = Tuple79( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55, + t56, + t57, + t58, + t59, + t60, + t61, + t62, + t63, + t64, + t65, + t66, + t67, + t68, + t69, + t70, + t71, + t72, + t73, + t74, + t75, + t76, + t77, + t78, + t79 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + t56: T56, + t57: T57, + t58: T58, + t59: T59, + t60: T60, + t61: T61, + t62: T62, + t63: T63, + t64: T64, + t65: T65, + t66: T66, + t67: T67, + t68: T68, + t69: T69, + t70: T70, + t71: T71, + t72: T72, + t73: T73, + t74: T74, + t75: T75, + t76: T76, + t77: T77, + t78: T78, + t79: T79, + t80: T80, + ) = Tuple80( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55, + t56, + t57, + t58, + t59, + t60, + t61, + t62, + t63, + t64, + t65, + t66, + t67, + t68, + t69, + t70, + t71, + t72, + t73, + t74, + t75, + t76, + t77, + t78, + t79, + t80 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + t56: T56, + t57: T57, + t58: T58, + t59: T59, + t60: T60, + t61: T61, + t62: T62, + t63: T63, + t64: T64, + t65: T65, + t66: T66, + t67: T67, + t68: T68, + t69: T69, + t70: T70, + t71: T71, + t72: T72, + t73: T73, + t74: T74, + t75: T75, + t76: T76, + t77: T77, + t78: T78, + t79: T79, + t80: T80, + t81: T81, + ) = Tuple81( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55, + t56, + t57, + t58, + t59, + t60, + t61, + t62, + t63, + t64, + t65, + t66, + t67, + t68, + t69, + t70, + t71, + t72, + t73, + t74, + t75, + t76, + t77, + t78, + t79, + t80, + t81 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + t56: T56, + t57: T57, + t58: T58, + t59: T59, + t60: T60, + t61: T61, + t62: T62, + t63: T63, + t64: T64, + t65: T65, + t66: T66, + t67: T67, + t68: T68, + t69: T69, + t70: T70, + t71: T71, + t72: T72, + t73: T73, + t74: T74, + t75: T75, + t76: T76, + t77: T77, + t78: T78, + t79: T79, + t80: T80, + t81: T81, + t82: T82, + ) = Tuple82( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55, + t56, + t57, + t58, + t59, + t60, + t61, + t62, + t63, + t64, + t65, + t66, + t67, + t68, + t69, + t70, + t71, + t72, + t73, + t74, + t75, + t76, + t77, + t78, + t79, + t80, + t81, + t82 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + t56: T56, + t57: T57, + t58: T58, + t59: T59, + t60: T60, + t61: T61, + t62: T62, + t63: T63, + t64: T64, + t65: T65, + t66: T66, + t67: T67, + t68: T68, + t69: T69, + t70: T70, + t71: T71, + t72: T72, + t73: T73, + t74: T74, + t75: T75, + t76: T76, + t77: T77, + t78: T78, + t79: T79, + t80: T80, + t81: T81, + t82: T82, + t83: T83, + ) = Tuple83( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55, + t56, + t57, + t58, + t59, + t60, + t61, + t62, + t63, + t64, + t65, + t66, + t67, + t68, + t69, + t70, + t71, + t72, + t73, + t74, + t75, + t76, + t77, + t78, + t79, + t80, + t81, + t82, + t83 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + t56: T56, + t57: T57, + t58: T58, + t59: T59, + t60: T60, + t61: T61, + t62: T62, + t63: T63, + t64: T64, + t65: T65, + t66: T66, + t67: T67, + t68: T68, + t69: T69, + t70: T70, + t71: T71, + t72: T72, + t73: T73, + t74: T74, + t75: T75, + t76: T76, + t77: T77, + t78: T78, + t79: T79, + t80: T80, + t81: T81, + t82: T82, + t83: T83, + t84: T84, + ) = Tuple84( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55, + t56, + t57, + t58, + t59, + t60, + t61, + t62, + t63, + t64, + t65, + t66, + t67, + t68, + t69, + t70, + t71, + t72, + t73, + t74, + t75, + t76, + t77, + t78, + t79, + t80, + t81, + t82, + t83, + t84 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + t56: T56, + t57: T57, + t58: T58, + t59: T59, + t60: T60, + t61: T61, + t62: T62, + t63: T63, + t64: T64, + t65: T65, + t66: T66, + t67: T67, + t68: T68, + t69: T69, + t70: T70, + t71: T71, + t72: T72, + t73: T73, + t74: T74, + t75: T75, + t76: T76, + t77: T77, + t78: T78, + t79: T79, + t80: T80, + t81: T81, + t82: T82, + t83: T83, + t84: T84, + t85: T85, + ) = Tuple85( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55, + t56, + t57, + t58, + t59, + t60, + t61, + t62, + t63, + t64, + t65, + t66, + t67, + t68, + t69, + t70, + t71, + t72, + t73, + t74, + t75, + t76, + t77, + t78, + t79, + t80, + t81, + t82, + t83, + t84, + t85 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + t56: T56, + t57: T57, + t58: T58, + t59: T59, + t60: T60, + t61: T61, + t62: T62, + t63: T63, + t64: T64, + t65: T65, + t66: T66, + t67: T67, + t68: T68, + t69: T69, + t70: T70, + t71: T71, + t72: T72, + t73: T73, + t74: T74, + t75: T75, + t76: T76, + t77: T77, + t78: T78, + t79: T79, + t80: T80, + t81: T81, + t82: T82, + t83: T83, + t84: T84, + t85: T85, + t86: T86, + ) = Tuple86( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55, + t56, + t57, + t58, + t59, + t60, + t61, + t62, + t63, + t64, + t65, + t66, + t67, + t68, + t69, + t70, + t71, + t72, + t73, + t74, + t75, + t76, + t77, + t78, + t79, + t80, + t81, + t82, + t83, + t84, + t85, + t86 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + t56: T56, + t57: T57, + t58: T58, + t59: T59, + t60: T60, + t61: T61, + t62: T62, + t63: T63, + t64: T64, + t65: T65, + t66: T66, + t67: T67, + t68: T68, + t69: T69, + t70: T70, + t71: T71, + t72: T72, + t73: T73, + t74: T74, + t75: T75, + t76: T76, + t77: T77, + t78: T78, + t79: T79, + t80: T80, + t81: T81, + t82: T82, + t83: T83, + t84: T84, + t85: T85, + t86: T86, + t87: T87, + ) = Tuple87( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55, + t56, + t57, + t58, + t59, + t60, + t61, + t62, + t63, + t64, + t65, + t66, + t67, + t68, + t69, + t70, + t71, + t72, + t73, + t74, + t75, + t76, + t77, + t78, + t79, + t80, + t81, + t82, + t83, + t84, + t85, + t86, + t87 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + t56: T56, + t57: T57, + t58: T58, + t59: T59, + t60: T60, + t61: T61, + t62: T62, + t63: T63, + t64: T64, + t65: T65, + t66: T66, + t67: T67, + t68: T68, + t69: T69, + t70: T70, + t71: T71, + t72: T72, + t73: T73, + t74: T74, + t75: T75, + t76: T76, + t77: T77, + t78: T78, + t79: T79, + t80: T80, + t81: T81, + t82: T82, + t83: T83, + t84: T84, + t85: T85, + t86: T86, + t87: T87, + t88: T88, + ) = Tuple88( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55, + t56, + t57, + t58, + t59, + t60, + t61, + t62, + t63, + t64, + t65, + t66, + t67, + t68, + t69, + t70, + t71, + t72, + t73, + t74, + t75, + t76, + t77, + t78, + t79, + t80, + t81, + t82, + t83, + t84, + t85, + t86, + t87, + t88 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + t56: T56, + t57: T57, + t58: T58, + t59: T59, + t60: T60, + t61: T61, + t62: T62, + t63: T63, + t64: T64, + t65: T65, + t66: T66, + t67: T67, + t68: T68, + t69: T69, + t70: T70, + t71: T71, + t72: T72, + t73: T73, + t74: T74, + t75: T75, + t76: T76, + t77: T77, + t78: T78, + t79: T79, + t80: T80, + t81: T81, + t82: T82, + t83: T83, + t84: T84, + t85: T85, + t86: T86, + t87: T87, + t88: T88, + t89: T89, + ) = Tuple89( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55, + t56, + t57, + t58, + t59, + t60, + t61, + t62, + t63, + t64, + t65, + t66, + t67, + t68, + t69, + t70, + t71, + t72, + t73, + t74, + t75, + t76, + t77, + t78, + t79, + t80, + t81, + t82, + t83, + t84, + t85, + t86, + t87, + t88, + t89 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + t56: T56, + t57: T57, + t58: T58, + t59: T59, + t60: T60, + t61: T61, + t62: T62, + t63: T63, + t64: T64, + t65: T65, + t66: T66, + t67: T67, + t68: T68, + t69: T69, + t70: T70, + t71: T71, + t72: T72, + t73: T73, + t74: T74, + t75: T75, + t76: T76, + t77: T77, + t78: T78, + t79: T79, + t80: T80, + t81: T81, + t82: T82, + t83: T83, + t84: T84, + t85: T85, + t86: T86, + t87: T87, + t88: T88, + t89: T89, + t90: T90, + ) = Tuple90( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55, + t56, + t57, + t58, + t59, + t60, + t61, + t62, + t63, + t64, + t65, + t66, + t67, + t68, + t69, + t70, + t71, + t72, + t73, + t74, + t75, + t76, + t77, + t78, + t79, + t80, + t81, + t82, + t83, + t84, + t85, + t86, + t87, + t88, + t89, + t90 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + t56: T56, + t57: T57, + t58: T58, + t59: T59, + t60: T60, + t61: T61, + t62: T62, + t63: T63, + t64: T64, + t65: T65, + t66: T66, + t67: T67, + t68: T68, + t69: T69, + t70: T70, + t71: T71, + t72: T72, + t73: T73, + t74: T74, + t75: T75, + t76: T76, + t77: T77, + t78: T78, + t79: T79, + t80: T80, + t81: T81, + t82: T82, + t83: T83, + t84: T84, + t85: T85, + t86: T86, + t87: T87, + t88: T88, + t89: T89, + t90: T90, + t91: T91, + ) = Tuple91( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55, + t56, + t57, + t58, + t59, + t60, + t61, + t62, + t63, + t64, + t65, + t66, + t67, + t68, + t69, + t70, + t71, + t72, + t73, + t74, + t75, + t76, + t77, + t78, + t79, + t80, + t81, + t82, + t83, + t84, + t85, + t86, + t87, + t88, + t89, + t90, + t91 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + t56: T56, + t57: T57, + t58: T58, + t59: T59, + t60: T60, + t61: T61, + t62: T62, + t63: T63, + t64: T64, + t65: T65, + t66: T66, + t67: T67, + t68: T68, + t69: T69, + t70: T70, + t71: T71, + t72: T72, + t73: T73, + t74: T74, + t75: T75, + t76: T76, + t77: T77, + t78: T78, + t79: T79, + t80: T80, + t81: T81, + t82: T82, + t83: T83, + t84: T84, + t85: T85, + t86: T86, + t87: T87, + t88: T88, + t89: T89, + t90: T90, + t91: T91, + t92: T92, + ) = Tuple92( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55, + t56, + t57, + t58, + t59, + t60, + t61, + t62, + t63, + t64, + t65, + t66, + t67, + t68, + t69, + t70, + t71, + t72, + t73, + t74, + t75, + t76, + t77, + t78, + t79, + t80, + t81, + t82, + t83, + t84, + t85, + t86, + t87, + t88, + t89, + t90, + t91, + t92 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + t56: T56, + t57: T57, + t58: T58, + t59: T59, + t60: T60, + t61: T61, + t62: T62, + t63: T63, + t64: T64, + t65: T65, + t66: T66, + t67: T67, + t68: T68, + t69: T69, + t70: T70, + t71: T71, + t72: T72, + t73: T73, + t74: T74, + t75: T75, + t76: T76, + t77: T77, + t78: T78, + t79: T79, + t80: T80, + t81: T81, + t82: T82, + t83: T83, + t84: T84, + t85: T85, + t86: T86, + t87: T87, + t88: T88, + t89: T89, + t90: T90, + t91: T91, + t92: T92, + t93: T93, + ) = Tuple93( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55, + t56, + t57, + t58, + t59, + t60, + t61, + t62, + t63, + t64, + t65, + t66, + t67, + t68, + t69, + t70, + t71, + t72, + t73, + t74, + t75, + t76, + t77, + t78, + t79, + t80, + t81, + t82, + t83, + t84, + t85, + t86, + t87, + t88, + t89, + t90, + t91, + t92, + t93 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + t56: T56, + t57: T57, + t58: T58, + t59: T59, + t60: T60, + t61: T61, + t62: T62, + t63: T63, + t64: T64, + t65: T65, + t66: T66, + t67: T67, + t68: T68, + t69: T69, + t70: T70, + t71: T71, + t72: T72, + t73: T73, + t74: T74, + t75: T75, + t76: T76, + t77: T77, + t78: T78, + t79: T79, + t80: T80, + t81: T81, + t82: T82, + t83: T83, + t84: T84, + t85: T85, + t86: T86, + t87: T87, + t88: T88, + t89: T89, + t90: T90, + t91: T91, + t92: T92, + t93: T93, + t94: T94, + ) = Tuple94( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55, + t56, + t57, + t58, + t59, + t60, + t61, + t62, + t63, + t64, + t65, + t66, + t67, + t68, + t69, + t70, + t71, + t72, + t73, + t74, + t75, + t76, + t77, + t78, + t79, + t80, + t81, + t82, + t83, + t84, + t85, + t86, + t87, + t88, + t89, + t90, + t91, + t92, + t93, + t94 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + t56: T56, + t57: T57, + t58: T58, + t59: T59, + t60: T60, + t61: T61, + t62: T62, + t63: T63, + t64: T64, + t65: T65, + t66: T66, + t67: T67, + t68: T68, + t69: T69, + t70: T70, + t71: T71, + t72: T72, + t73: T73, + t74: T74, + t75: T75, + t76: T76, + t77: T77, + t78: T78, + t79: T79, + t80: T80, + t81: T81, + t82: T82, + t83: T83, + t84: T84, + t85: T85, + t86: T86, + t87: T87, + t88: T88, + t89: T89, + t90: T90, + t91: T91, + t92: T92, + t93: T93, + t94: T94, + t95: T95, + ) = Tuple95( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55, + t56, + t57, + t58, + t59, + t60, + t61, + t62, + t63, + t64, + t65, + t66, + t67, + t68, + t69, + t70, + t71, + t72, + t73, + t74, + t75, + t76, + t77, + t78, + t79, + t80, + t81, + t82, + t83, + t84, + t85, + t86, + t87, + t88, + t89, + t90, + t91, + t92, + t93, + t94, + t95 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + t56: T56, + t57: T57, + t58: T58, + t59: T59, + t60: T60, + t61: T61, + t62: T62, + t63: T63, + t64: T64, + t65: T65, + t66: T66, + t67: T67, + t68: T68, + t69: T69, + t70: T70, + t71: T71, + t72: T72, + t73: T73, + t74: T74, + t75: T75, + t76: T76, + t77: T77, + t78: T78, + t79: T79, + t80: T80, + t81: T81, + t82: T82, + t83: T83, + t84: T84, + t85: T85, + t86: T86, + t87: T87, + t88: T88, + t89: T89, + t90: T90, + t91: T91, + t92: T92, + t93: T93, + t94: T94, + t95: T95, + t96: T96, + ) = Tuple96( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55, + t56, + t57, + t58, + t59, + t60, + t61, + t62, + t63, + t64, + t65, + t66, + t67, + t68, + t69, + t70, + t71, + t72, + t73, + t74, + t75, + t76, + t77, + t78, + t79, + t80, + t81, + t82, + t83, + t84, + t85, + t86, + t87, + t88, + t89, + t90, + t91, + t92, + t93, + t94, + t95, + t96 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + t56: T56, + t57: T57, + t58: T58, + t59: T59, + t60: T60, + t61: T61, + t62: T62, + t63: T63, + t64: T64, + t65: T65, + t66: T66, + t67: T67, + t68: T68, + t69: T69, + t70: T70, + t71: T71, + t72: T72, + t73: T73, + t74: T74, + t75: T75, + t76: T76, + t77: T77, + t78: T78, + t79: T79, + t80: T80, + t81: T81, + t82: T82, + t83: T83, + t84: T84, + t85: T85, + t86: T86, + t87: T87, + t88: T88, + t89: T89, + t90: T90, + t91: T91, + t92: T92, + t93: T93, + t94: T94, + t95: T95, + t96: T96, + t97: T97, + ) = Tuple97( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55, + t56, + t57, + t58, + t59, + t60, + t61, + t62, + t63, + t64, + t65, + t66, + t67, + t68, + t69, + t70, + t71, + t72, + t73, + t74, + t75, + t76, + t77, + t78, + t79, + t80, + t81, + t82, + t83, + t84, + t85, + t86, + t87, + t88, + t89, + t90, + t91, + t92, + t93, + t94, + t95, + t96, + t97 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + t56: T56, + t57: T57, + t58: T58, + t59: T59, + t60: T60, + t61: T61, + t62: T62, + t63: T63, + t64: T64, + t65: T65, + t66: T66, + t67: T67, + t68: T68, + t69: T69, + t70: T70, + t71: T71, + t72: T72, + t73: T73, + t74: T74, + t75: T75, + t76: T76, + t77: T77, + t78: T78, + t79: T79, + t80: T80, + t81: T81, + t82: T82, + t83: T83, + t84: T84, + t85: T85, + t86: T86, + t87: T87, + t88: T88, + t89: T89, + t90: T90, + t91: T91, + t92: T92, + t93: T93, + t94: T94, + t95: T95, + t96: T96, + t97: T97, + t98: T98, + ) = Tuple98( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55, + t56, + t57, + t58, + t59, + t60, + t61, + t62, + t63, + t64, + t65, + t66, + t67, + t68, + t69, + t70, + t71, + t72, + t73, + t74, + t75, + t76, + t77, + t78, + t79, + t80, + t81, + t82, + t83, + t84, + t85, + t86, + t87, + t88, + t89, + t90, + t91, + t92, + t93, + t94, + t95, + t96, + t97, + t98 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + t56: T56, + t57: T57, + t58: T58, + t59: T59, + t60: T60, + t61: T61, + t62: T62, + t63: T63, + t64: T64, + t65: T65, + t66: T66, + t67: T67, + t68: T68, + t69: T69, + t70: T70, + t71: T71, + t72: T72, + t73: T73, + t74: T74, + t75: T75, + t76: T76, + t77: T77, + t78: T78, + t79: T79, + t80: T80, + t81: T81, + t82: T82, + t83: T83, + t84: T84, + t85: T85, + t86: T86, + t87: T87, + t88: T88, + t89: T89, + t90: T90, + t91: T91, + t92: T92, + t93: T93, + t94: T94, + t95: T95, + t96: T96, + t97: T97, + t98: T98, + t99: T99, + ) = Tuple99( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55, + t56, + t57, + t58, + t59, + t60, + t61, + t62, + t63, + t64, + t65, + t66, + t67, + t68, + t69, + t70, + t71, + t72, + t73, + t74, + t75, + t76, + t77, + t78, + t79, + t80, + t81, + t82, + t83, + t84, + t85, + t86, + t87, + t88, + t89, + t90, + t91, + t92, + t93, + t94, + t95, + t96, + t97, + t98, + t99 + ) + + @JvmStatic + fun of( + t1: T1, + t2: T2, + t3: T3, + t4: T4, + t5: T5, + t6: T6, + t7: T7, + t8: T8, + t9: T9, + t10: T10, + t11: T11, + t12: T12, + t13: T13, + t14: T14, + t15: T15, + t16: T16, + t17: T17, + t18: T18, + t19: T19, + t20: T20, + t21: T21, + t22: T22, + t23: T23, + t24: T24, + t25: T25, + t26: T26, + t27: T27, + t28: T28, + t29: T29, + t30: T30, + t31: T31, + t32: T32, + t33: T33, + t34: T34, + t35: T35, + t36: T36, + t37: T37, + t38: T38, + t39: T39, + t40: T40, + t41: T41, + t42: T42, + t43: T43, + t44: T44, + t45: T45, + t46: T46, + t47: T47, + t48: T48, + t49: T49, + t50: T50, + t51: T51, + t52: T52, + t53: T53, + t54: T54, + t55: T55, + t56: T56, + t57: T57, + t58: T58, + t59: T59, + t60: T60, + t61: T61, + t62: T62, + t63: T63, + t64: T64, + t65: T65, + t66: T66, + t67: T67, + t68: T68, + t69: T69, + t70: T70, + t71: T71, + t72: T72, + t73: T73, + t74: T74, + t75: T75, + t76: T76, + t77: T77, + t78: T78, + t79: T79, + t80: T80, + t81: T81, + t82: T82, + t83: T83, + t84: T84, + t85: T85, + t86: T86, + t87: T87, + t88: T88, + t89: T89, + t90: T90, + t91: T91, + t92: T92, + t93: T93, + t94: T94, + t95: T95, + t96: T96, + t97: T97, + t98: T98, + t99: T99, + t100: T100, + ) = Tuple100( + t1, + t2, + t3, + t4, + t5, + t6, + t7, + t8, + t9, + t10, + t11, + t12, + t13, + t14, + t15, + t16, + t17, + t18, + t19, + t20, + t21, + t22, + t23, + t24, + t25, + t26, + t27, + t28, + t29, + t30, + t31, + t32, + t33, + t34, + t35, + t36, + t37, + t38, + t39, + t40, + t41, + t42, + t43, + t44, + t45, + t46, + t47, + t48, + t49, + t50, + t51, + t52, + t53, + t54, + t55, + t56, + t57, + t58, + t59, + t60, + t61, + t62, + t63, + t64, + t65, + t66, + t67, + t68, + t69, + t70, + t71, + t72, + t73, + t74, + t75, + t76, + t77, + t78, + t79, + t80, + t81, + t82, + t83, + t84, + t85, + t86, + t87, + t88, + t89, + t90, + t91, + t92, + t93, + t94, + t95, + t96, + t97, + t98, + t99, + t100 + ) + + + } +} diff --git a/src/main/kotlin/com/mingliqiye/utils/uuid/UUID.kt b/src/main/kotlin/com/mingliqiye/utils/uuid/UUID.kt index ce7f060..b2f762b 100644 --- a/src/main/kotlin/com/mingliqiye/utils/uuid/UUID.kt +++ b/src/main/kotlin/com/mingliqiye/utils/uuid/UUID.kt @@ -16,7 +16,7 @@ * ProjectName mingli-utils * ModuleName mingli-utils.main * CurrentFile UUID.kt - * LastUpdate 2026-03-12 10:07:08 + * LastUpdate 2026-06-21 10:40:58 * UpdateUser MingLiPro */ @@ -25,8 +25,7 @@ package com.mingliqiye.utils.uuid import com.mingliqiye.utils.array.copyTo import com.mingliqiye.utils.base.BaseCodec import com.mingliqiye.utils.base.BaseType -import com.mingliqiye.utils.random.randomByte -import com.mingliqiye.utils.random.secureRandom +import com.mingliqiye.utils.random.Random import com.mingliqiye.utils.system.macAddressBytes import com.mingliqiye.utils.time.DateTime import com.mingliqiye.utils.time.DateTimeOffset @@ -38,6 +37,7 @@ import java.nio.ByteBuffer import java.security.MessageDigest import java.time.temporal.ChronoUnit import java.util.concurrent.atomic.AtomicLong +import com.mingliqiye.utils.random.Random.nextBytes as randomByte import java.util.UUID as JUUID @@ -62,7 +62,7 @@ class UUID : Serializable { private var lastTimestamp = 0L - private var clockSequence = secureRandom.nextInt(0x3FFF + 1) + private var clockSequence = Random.nextInt(0x3FFF + 1) private val clockSeqHolder = AtomicLong(0) /** @@ -227,8 +227,8 @@ class UUID : Serializable { .to100NanoTime() and 0x0FFFFFFFFFFFFFFFL val timeHigh = (timestamp ushr 12) and 0xFFFFFFFFFFFFL val timeMid = timestamp and 0x0FFFL - val clockSeq = secureRandom.nextInt(16384) and 0x3FFF - val node = secureRandom.nextLong() and 0x0000FFFFFFFFFFFFL + val clockSeq = Random.nextInt(16384) and 0x3FFF + val node = Random.nextLong() and 0x0000FFFFFFFFFFFFL val buffer = ByteBuffer.allocate(16) buffer.putLong((timeHigh shl 16) or (0x6000L) or (timeMid and 0x0FFF)) buffer.putShort((0x8000 or (clockSeq and 0x3FFF)).toShort()) @@ -253,7 +253,7 @@ class UUID : Serializable { buffer.putInt((instant shr 16).toInt()) buffer.putShort((instant).toShort()) buffer.put(randomByte(2)) - buffer.putLong(secureRandom.nextLong()) + buffer.putLong(Random.nextLong()) val bytes = buffer.array() bytes[6] = (bytes[6].toInt() and 0x0F or 0x70).toByte() bytes[8] = (bytes[8].toInt() and 0x3F or 0x80).toByte() diff --git a/src/test/kotlin/com/mingliqiye/utils/TestJson.kt b/src/test/kotlin/com/mingliqiye/utils/TestJson.kt new file mode 100644 index 0000000..e82011c --- /dev/null +++ b/src/test/kotlin/com/mingliqiye/utils/TestJson.kt @@ -0,0 +1,33 @@ +/* + * Copyright 2026 mingliqiye + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * ProjectName mingli-utils + * ModuleName mingli-utils.test + * CurrentFile TestJson.kt + * LastUpdate 2026-06-20 22:05:31 + * UpdateUser MingLiPro + */ + +package com.mingliqiye.utils + +import org.junit.jupiter.api.Test + + +class TestJson { + + @Test + fun test() { + } +} diff --git a/src/test/resources/test.json b/src/test/resources/test.json new file mode 100644 index 0000000..0652857 --- /dev/null +++ b/src/test/resources/test.json @@ -0,0 +1,60 @@ +{ + "company": { + "name": "未来科技有限公司", + "founded": 2015, + "employees": 128, + "departments": [ + { + "name": "技术部", + "manager": "王五", + "members": [ + { + "id": "T001", + "name": "赵六", + "position": "前端工程师", + "salary": 18000, + "skills": [ + "JavaScript", + "Vue", + "React" + ] + }, + { + "id": "T002", + "name": "钱七", + "position": "后端工程师", + "salary": 20000, + "skills": [ + "Java", + "Spring Boot", + "MySQL" + ] + }, + { + "id": "T003", + "name": "孙八", + "position": "测试工程师", + "salary": 15000, + "skills": [ + "自动化测试", + "性能测试" + ] + } + ] + }, + { + "name": "市场部", + "manager": "周九", + "members": [ + { + "id": "M001", + "name": "吴十", + "position": "市场专员", + "salary": 12000, + "clients": 15 + } + ] + } + ] + } +}