kotlin-fork/compiler/testData/lazyResolve/namespaceComparatorWithJavaMerge/stdlib-log.txt

namespace <root>

// <namespace name="jet">
namespace jet

public open class jet.Any {
    public final /*constructor*/ fun <init>(): jet.Any
}
public final class jet.Array</*0,r*/ T : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0,r*/ T : jet.Any?><init>(/*0*/ size: jet.Int, /*1*/ init: jet.Function1<jet.Int, T>): jet.Array<T>
    public final fun get(/*0*/ index: jet.Int): T
    public final val indices: jet.IntRange
    public final fun iterator(): jet.Iterator<T>
    public final fun set(/*0*/ index: jet.Int, /*1*/ value: T): jet.Tuple0
    public final val size: jet.Int
}
public final class jet.Boolean : jet.Comparable<jet.Boolean> {
    public final /*constructor*/ fun <init>(): jet.Boolean
    public final fun and(/*0*/ other: jet.Boolean): jet.Boolean
    public open override /*1*/ fun compareTo(/*0*/ that: jet.Boolean): jet.Int
    public final fun equals(/*0*/ other: jet.Any?): jet.Boolean
    public final fun not(): jet.Boolean
    public final fun or(/*0*/ other: jet.Boolean): jet.Boolean
    public final fun xor(/*0*/ other: jet.Boolean): jet.Boolean
}
public final class jet.BooleanArray : jet.Any {
    public final /*constructor*/ fun <init>(/*0*/ size: jet.Int): jet.BooleanArray
    public final fun get(/*0*/ index: jet.Int): jet.Boolean
    public final val indices: jet.IntRange
    public final fun iterator(): jet.BooleanIterator
    public final fun set(/*0*/ index: jet.Int, /*1*/ value: jet.Boolean): jet.Tuple0
    public final val size: jet.Int
}
public abstract trait jet.BooleanIterable : jet.Iterable<jet.Boolean> {
    public abstract override /*1*/ fun iterator(): jet.BooleanIterator
}
public abstract class jet.BooleanIterator : jet.Iterator<jet.Boolean> {
    public final /*constructor*/ fun <init>(): jet.BooleanIterator
    public abstract override /*1*/ val hasNext: jet.Boolean
    public open override /*1*/ fun next(): jet.Boolean
    public abstract fun nextBoolean(): jet.Boolean
}
public final class jet.Byte : jet.Number, jet.Comparable<jet.Byte> {
    public final /*constructor*/ fun <init>(): jet.Byte
    public open override /*1*/ fun compareTo(/*0*/ other: jet.Byte): jet.Int
    public final fun compareTo(/*0*/ other: jet.Char): jet.Int
    public final fun compareTo(/*0*/ other: jet.Double): jet.Int
    public final fun compareTo(/*0*/ other: jet.Float): jet.Int
    public final fun compareTo(/*0*/ other: jet.Int): jet.Int
    public final fun compareTo(/*0*/ other: jet.Long): jet.Int
    public final fun compareTo(/*0*/ other: jet.Short): jet.Int
    public final fun dec(): jet.Byte
    public final fun div(/*0*/ other: jet.Byte): jet.Int
    public final fun div(/*0*/ other: jet.Char): jet.Int
    public final fun div(/*0*/ other: jet.Double): jet.Double
    public final fun div(/*0*/ other: jet.Float): jet.Float
    public final fun div(/*0*/ other: jet.Int): jet.Int
    public final fun div(/*0*/ other: jet.Long): jet.Long
    public final fun div(/*0*/ other: jet.Short): jet.Int
    public final fun downto(/*0*/ other: jet.Byte): jet.ByteRange
    public final fun downto(/*0*/ other: jet.Char): jet.CharRange
    public final fun downto(/*0*/ other: jet.Double): jet.DoubleRange
    public final fun downto(/*0*/ other: jet.Float): jet.FloatRange
    public final fun downto(/*0*/ other: jet.Int): jet.IntRange
    public final fun downto(/*0*/ other: jet.Long): jet.LongRange
    public final fun downto(/*0*/ other: jet.Short): jet.ShortRange
    public open override /*1*/ fun equals(/*0*/ other: jet.Any?): jet.Boolean
    public open override /*1*/ fun hashCode(): jet.Int
    public final fun inc(): jet.Byte
    public final fun minus(): jet.Byte
    public final fun minus(/*0*/ other: jet.Byte): jet.Int
    public final fun minus(/*0*/ other: jet.Char): jet.Int
    public final fun minus(/*0*/ other: jet.Double): jet.Double
    public final fun minus(/*0*/ other: jet.Float): jet.Float
    public final fun minus(/*0*/ other: jet.Int): jet.Int
    public final fun minus(/*0*/ other: jet.Long): jet.Long
    public final fun minus(/*0*/ other: jet.Short): jet.Int
    public final fun mod(/*0*/ other: jet.Byte): jet.Int
    public final fun mod(/*0*/ other: jet.Char): jet.Int
    public final fun mod(/*0*/ other: jet.Double): jet.Double
    public final fun mod(/*0*/ other: jet.Float): jet.Float
    public final fun mod(/*0*/ other: jet.Int): jet.Int
    public final fun mod(/*0*/ other: jet.Long): jet.Long
    public final fun mod(/*0*/ other: jet.Short): jet.Int
    public final fun plus(): jet.Byte
    public final fun plus(/*0*/ other: jet.Byte): jet.Int
    public final fun plus(/*0*/ other: jet.Char): jet.Int
    public final fun plus(/*0*/ other: jet.Double): jet.Double
    public final fun plus(/*0*/ other: jet.Float): jet.Float
    public final fun plus(/*0*/ other: jet.Int): jet.Int
    public final fun plus(/*0*/ other: jet.Long): jet.Long
    public final fun plus(/*0*/ other: jet.Short): jet.Int
    public final fun rangeTo(/*0*/ other: jet.Byte): jet.ByteRange
    public final fun rangeTo(/*0*/ other: jet.Char): jet.CharRange
    public final fun rangeTo(/*0*/ other: jet.Double): jet.DoubleRange
    public final fun rangeTo(/*0*/ other: jet.Float): jet.FloatRange
    public final fun rangeTo(/*0*/ other: jet.Int): jet.IntRange
    public final fun rangeTo(/*0*/ other: jet.Long): jet.LongRange
    public final fun rangeTo(/*0*/ other: jet.Short): jet.ShortRange
    public final fun times(/*0*/ other: jet.Byte): jet.Int
    public final fun times(/*0*/ other: jet.Char): jet.Int
    public final fun times(/*0*/ other: jet.Double): jet.Double
    public final fun times(/*0*/ other: jet.Float): jet.Float
    public final fun times(/*0*/ other: jet.Int): jet.Int
    public final fun times(/*0*/ other: jet.Long): jet.Long
    public final fun times(/*0*/ other: jet.Short): jet.Int
    public open override /*1*/ fun toByte(): jet.Byte
    public open override /*1*/ fun toChar(): jet.Char
    public open override /*1*/ fun toDouble(): jet.Double
    public open override /*1*/ fun toFloat(): jet.Float
    public open override /*1*/ fun toInt(): jet.Int
    public open override /*1*/ fun toLong(): jet.Long
    public open override /*1*/ fun toShort(): jet.Short
    public final fun upto(/*0*/ other: jet.Byte): jet.ByteRange
    public final fun upto(/*0*/ other: jet.Char): jet.CharRange
    public final fun upto(/*0*/ other: jet.Double): jet.DoubleRange
    public final fun upto(/*0*/ other: jet.Float): jet.FloatRange
    public final fun upto(/*0*/ other: jet.Int): jet.IntRange
    public final fun upto(/*0*/ other: jet.Long): jet.LongRange
    public final fun upto(/*0*/ other: jet.Short): jet.ShortRange
}
public final class jet.ByteArray : jet.Any {
    public final /*constructor*/ fun <init>(/*0*/ size: jet.Int): jet.ByteArray
    public final fun get(/*0*/ index: jet.Int): jet.Byte
    public final val indices: jet.IntRange
    public final fun iterator(): jet.ByteIterator
    public final fun set(/*0*/ index: jet.Int, /*1*/ value: jet.Byte): jet.Tuple0
    public final val size: jet.Int
}
public abstract trait jet.ByteIterable : jet.Iterable<jet.Byte> {
    public abstract override /*1*/ fun iterator(): jet.ByteIterator
}
public abstract class jet.ByteIterator : jet.Iterator<jet.Byte> {
    public final /*constructor*/ fun <init>(): jet.ByteIterator
    public abstract override /*1*/ val hasNext: jet.Boolean
    public open override /*1*/ fun next(): jet.Byte
    public abstract fun nextByte(): jet.Byte
}
public final class jet.ByteRange : jet.Range<jet.Byte>, jet.ByteIterable {
    public final /*constructor*/ fun <init>(/*0*/ start: jet.Byte, /*1*/ size: jet.Int): jet.ByteRange
    public open override /*1*/ fun contains(/*0*/ elem: jet.Byte): jet.Boolean
    public final val end: jet.Byte
    public final val isReversed: jet.Boolean
    public open override /*1*/ fun iterator(): jet.ByteIterator
    public final val iteratorStart: jet.Byte
    public final fun minus(): jet.ByteRange
    public final val size: jet.Int
    public final val start: jet.Byte
    public final fun step(/*0*/ step: jet.Int): jet.ByteIterator
}
public final class jet.Char : jet.Number, jet.Comparable<jet.Char> {
    public final /*constructor*/ fun <init>(): jet.Char
    public final fun compareTo(/*0*/ other: jet.Byte): jet.Int
    public open override /*1*/ fun compareTo(/*0*/ other: jet.Char): jet.Int
    public final fun compareTo(/*0*/ other: jet.Double): jet.Int
    public final fun compareTo(/*0*/ other: jet.Float): jet.Int
    public final fun compareTo(/*0*/ other: jet.Int): jet.Int
    public final fun compareTo(/*0*/ other: jet.Long): jet.Int
    public final fun compareTo(/*0*/ other: jet.Short): jet.Int
    public final fun dec(): jet.Char
    public final fun div(/*0*/ other: jet.Byte): jet.Int
    public final fun div(/*0*/ other: jet.Double): jet.Double
    public final fun div(/*0*/ other: jet.Float): jet.Float
    public final fun div(/*0*/ other: jet.Int): jet.Int
    public final fun div(/*0*/ other: jet.Long): jet.Long
    public final fun div(/*0*/ other: jet.Short): jet.Int
    public final fun downto(/*0*/ other: jet.Byte): jet.CharRange
    public final fun downto(/*0*/ other: jet.Char): jet.CharRange
    public final fun downto(/*0*/ other: jet.Double): jet.DoubleRange
    public final fun downto(/*0*/ other: jet.Float): jet.FloatRange
    public final fun downto(/*0*/ other: jet.Int): jet.IntRange
    public final fun downto(/*0*/ other: jet.Long): jet.LongRange
    public final fun downto(/*0*/ other: jet.Short): jet.ShortRange
    public open override /*1*/ fun equals(/*0*/ other: jet.Any?): jet.Boolean
    public open override /*1*/ fun hashCode(): jet.Int
    public final fun inc(): jet.Char
    public final fun minus(): jet.Int
    public final fun minus(/*0*/ other: jet.Byte): jet.Int
    public final fun minus(/*0*/ other: jet.Char): jet.Int
    public final fun minus(/*0*/ other: jet.Double): jet.Double
    public final fun minus(/*0*/ other: jet.Float): jet.Float
    public final fun minus(/*0*/ other: jet.Int): jet.Int
    public final fun minus(/*0*/ other: jet.Long): jet.Long
    public final fun minus(/*0*/ other: jet.Short): jet.Int
    public final fun mod(/*0*/ other: jet.Byte): jet.Int
    public final fun mod(/*0*/ other: jet.Double): jet.Double
    public final fun mod(/*0*/ other: jet.Float): jet.Float
    public final fun mod(/*0*/ other: jet.Int): jet.Int
    public final fun mod(/*0*/ other: jet.Long): jet.Long
    public final fun mod(/*0*/ other: jet.Short): jet.Int
    public final fun plus(): jet.Int
    public final fun plus(/*0*/ other: jet.Byte): jet.Int
    public final fun plus(/*0*/ other: jet.Double): jet.Double
    public final fun plus(/*0*/ other: jet.Float): jet.Float
    public final fun plus(/*0*/ other: jet.Int): jet.Int
    public final fun plus(/*0*/ other: jet.Long): jet.Long
    public final fun plus(/*0*/ other: jet.Short): jet.Int
    public final fun rangeTo(/*0*/ other: jet.Byte): jet.CharRange
    public final fun rangeTo(/*0*/ other: jet.Char): jet.CharRange
    public final fun rangeTo(/*0*/ other: jet.Double): jet.DoubleRange
    public final fun rangeTo(/*0*/ other: jet.Float): jet.FloatRange
    public final fun rangeTo(/*0*/ other: jet.Int): jet.IntRange
    public final fun rangeTo(/*0*/ other: jet.Long): jet.LongRange
    public final fun rangeTo(/*0*/ other: jet.Short): jet.ShortRange
    public final fun times(/*0*/ other: jet.Byte): jet.Int
    public final fun times(/*0*/ other: jet.Double): jet.Double
    public final fun times(/*0*/ other: jet.Float): jet.Float
    public final fun times(/*0*/ other: jet.Int): jet.Int
    public final fun times(/*0*/ other: jet.Long): jet.Long
    public final fun times(/*0*/ other: jet.Short): jet.Int
    public open override /*1*/ fun toByte(): jet.Byte
    public open override /*1*/ fun toChar(): jet.Char
    public open override /*1*/ fun toDouble(): jet.Double
    public open override /*1*/ fun toFloat(): jet.Float
    public open override /*1*/ fun toInt(): jet.Int
    public open override /*1*/ fun toLong(): jet.Long
    public open override /*1*/ fun toShort(): jet.Short
    public final fun upto(/*0*/ other: jet.Byte): jet.CharRange
    public final fun upto(/*0*/ other: jet.Char): jet.CharRange
    public final fun upto(/*0*/ other: jet.Double): jet.DoubleRange
    public final fun upto(/*0*/ other: jet.Float): jet.FloatRange
    public final fun upto(/*0*/ other: jet.Int): jet.IntRange
    public final fun upto(/*0*/ other: jet.Long): jet.LongRange
    public final fun upto(/*0*/ other: jet.Short): jet.ShortRange
}
public final class jet.CharArray : jet.Any {
    public final /*constructor*/ fun <init>(/*0*/ size: jet.Int): jet.CharArray
    public final fun get(/*0*/ index: jet.Int): jet.Char
    public final val indices: jet.IntRange
    public final fun iterator(): jet.CharIterator
    public final fun set(/*0*/ index: jet.Int, /*1*/ value: jet.Char): jet.Tuple0
    public final val size: jet.Int
}
public abstract trait jet.CharIterable : jet.Iterable<jet.Char> {
    public abstract override /*1*/ fun iterator(): jet.CharIterator
}
public abstract class jet.CharIterator : jet.Iterator<jet.Char> {
    public final /*constructor*/ fun <init>(): jet.CharIterator
    public abstract override /*1*/ val hasNext: jet.Boolean
    public open override /*1*/ fun next(): jet.Char
    public abstract fun nextChar(): jet.Char
}
public final class jet.CharRange : jet.Range<jet.Char>, jet.CharIterable {
    public final /*constructor*/ fun <init>(/*0*/ start: jet.Char, /*1*/ size: jet.Int): jet.CharRange
    public open override /*1*/ fun contains(/*0*/ elem: jet.Char): jet.Boolean
    public final val end: jet.Char
    public final val isReversed: jet.Boolean
    public open override /*1*/ fun iterator(): jet.CharIterator
    public final val iteratorStart: jet.Char
    public final fun minus(): jet.CharRange
    public final val size: jet.Int
    public final val start: jet.Char
    public final fun step(/*0*/ step: jet.Int): jet.CharIterator
}
public abstract trait jet.CharSequence : jet.Any {
    public abstract fun get(/*0*/ index: jet.Int): jet.Char
    public abstract val length: jet.Int
    public abstract fun toString(): jet.String
}
public abstract trait jet.Comparable</*0*/ in T : jet.Any?> : jet.Any {
    public abstract fun compareTo(/*0*/ other: T): jet.Int
}
public final class jet.Double : jet.Number, jet.Comparable<jet.Double> {
    public final /*constructor*/ fun <init>(): jet.Double
    public final fun compareTo(/*0*/ other: jet.Byte): jet.Int
    public final fun compareTo(/*0*/ other: jet.Char): jet.Int
    public open override /*1*/ fun compareTo(/*0*/ other: jet.Double): jet.Int
    public final fun compareTo(/*0*/ other: jet.Float): jet.Int
    public final fun compareTo(/*0*/ other: jet.Int): jet.Int
    public final fun compareTo(/*0*/ other: jet.Long): jet.Int
    public final fun compareTo(/*0*/ other: jet.Short): jet.Int
    public final fun dec(): jet.Double
    public final fun div(/*0*/ other: jet.Byte): jet.Double
    public final fun div(/*0*/ other: jet.Char): jet.Double
    public final fun div(/*0*/ other: jet.Double): jet.Double
    public final fun div(/*0*/ other: jet.Float): jet.Double
    public final fun div(/*0*/ other: jet.Int): jet.Double
    public final fun div(/*0*/ other: jet.Long): jet.Double
    public final fun div(/*0*/ other: jet.Short): jet.Double
    public final fun downto(/*0*/ other: jet.Byte): jet.DoubleRange
    public final fun downto(/*0*/ other: jet.Char): jet.DoubleRange
    public final fun downto(/*0*/ other: jet.Double): jet.DoubleRange
    public final fun downto(/*0*/ other: jet.Float): jet.DoubleRange
    public final fun downto(/*0*/ other: jet.Int): jet.DoubleRange
    public final fun downto(/*0*/ other: jet.Long): jet.DoubleRange
    public final fun downto(/*0*/ other: jet.Short): jet.DoubleRange
    public open override /*1*/ fun equals(/*0*/ other: jet.Any?): jet.Boolean
    public open override /*1*/ fun hashCode(): jet.Int
    public final fun inc(): jet.Double
    public final fun minus(): jet.Double
    public final fun minus(/*0*/ other: jet.Byte): jet.Double
    public final fun minus(/*0*/ other: jet.Char): jet.Double
    public final fun minus(/*0*/ other: jet.Double): jet.Double
    public final fun minus(/*0*/ other: jet.Float): jet.Double
    public final fun minus(/*0*/ other: jet.Int): jet.Double
    public final fun minus(/*0*/ other: jet.Long): jet.Double
    public final fun minus(/*0*/ other: jet.Short): jet.Double
    public final fun mod(/*0*/ other: jet.Byte): jet.Double
    public final fun mod(/*0*/ other: jet.Double): jet.Double
    public final fun mod(/*0*/ other: jet.Float): jet.Double
    public final fun mod(/*0*/ other: jet.Int): jet.Double
    public final fun mod(/*0*/ other: jet.Long): jet.Double
    public final fun mod(/*0*/ other: jet.Short): jet.Double
    public final fun plus(): jet.Double
    public final fun plus(/*0*/ other: jet.Byte): jet.Double
    public final fun plus(/*0*/ other: jet.Char): jet.Double
    public final fun plus(/*0*/ other: jet.Double): jet.Double
    public final fun plus(/*0*/ other: jet.Float): jet.Double
    public final fun plus(/*0*/ other: jet.Int): jet.Double
    public final fun plus(/*0*/ other: jet.Long): jet.Double
    public final fun plus(/*0*/ other: jet.Short): jet.Double
    public final fun rangeTo(/*0*/ other: jet.Byte): jet.DoubleRange
    public final fun rangeTo(/*0*/ other: jet.Char): jet.DoubleRange
    public final fun rangeTo(/*0*/ other: jet.Double): jet.DoubleRange
    public final fun rangeTo(/*0*/ other: jet.Float): jet.DoubleRange
    public final fun rangeTo(/*0*/ other: jet.Int): jet.DoubleRange
    public final fun rangeTo(/*0*/ other: jet.Long): jet.DoubleRange
    public final fun rangeTo(/*0*/ other: jet.Short): jet.DoubleRange
    public final fun times(/*0*/ other: jet.Byte): jet.Double
    public final fun times(/*0*/ other: jet.Char): jet.Double
    public final fun times(/*0*/ other: jet.Double): jet.Double
    public final fun times(/*0*/ other: jet.Float): jet.Double
    public final fun times(/*0*/ other: jet.Int): jet.Double
    public final fun times(/*0*/ other: jet.Long): jet.Double
    public final fun times(/*0*/ other: jet.Short): jet.Double
    public open override /*1*/ fun toByte(): jet.Byte
    public open override /*1*/ fun toChar(): jet.Char
    public open override /*1*/ fun toDouble(): jet.Double
    public open override /*1*/ fun toFloat(): jet.Float
    public open override /*1*/ fun toInt(): jet.Int
    public open override /*1*/ fun toLong(): jet.Long
    public open override /*1*/ fun toShort(): jet.Short
    public final fun upto(/*0*/ other: jet.Byte): jet.DoubleRange
    public final fun upto(/*0*/ other: jet.Char): jet.DoubleRange
    public final fun upto(/*0*/ other: jet.Double): jet.DoubleRange
    public final fun upto(/*0*/ other: jet.Float): jet.DoubleRange
    public final fun upto(/*0*/ other: jet.Int): jet.DoubleRange
    public final fun upto(/*0*/ other: jet.Long): jet.DoubleRange
    public final fun upto(/*0*/ other: jet.Short): jet.DoubleRange
}
public final class jet.DoubleArray : jet.Any {
    public final /*constructor*/ fun <init>(/*0*/ size: jet.Int): jet.DoubleArray
    public final fun get(/*0*/ index: jet.Int): jet.Double
    public final val indices: jet.IntRange
    public final fun iterator(): jet.DoubleIterator
    public final fun set(/*0*/ index: jet.Int, /*1*/ value: jet.Double): jet.Tuple0
    public final val size: jet.Int
}
public abstract trait jet.DoubleIterable : jet.Iterable<jet.Double> {
    public abstract override /*1*/ fun iterator(): jet.DoubleIterator
}
public abstract class jet.DoubleIterator : jet.Iterator<jet.Double> {
    public final /*constructor*/ fun <init>(): jet.DoubleIterator
    public abstract override /*1*/ val hasNext: jet.Boolean
    public open override /*1*/ fun next(): jet.Double
    public abstract fun nextDouble(): jet.Double
}
public final class jet.DoubleRange : jet.Range<jet.Double> {
    public final /*constructor*/ fun <init>(/*0*/ start: jet.Double, /*1*/ size: jet.Double): jet.DoubleRange
    public open override /*1*/ fun contains(/*0*/ elem: jet.Double): jet.Boolean
    public final val end: jet.Double
    public final val isReversed: jet.Boolean
    public final fun minus(): jet.DoubleRange
    public final val size: jet.Double
    public final val start: jet.Double
    public final fun step(/*0*/ step: jet.Double): jet.DoubleIterator
}
public abstract class jet.ExtensionFunction0</*0*/ in T : jet.Any?, /*1*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ in T : jet.Any?, /*1*/ out R : jet.Any?><init>(): jet.ExtensionFunction0<T, R>
    public abstract fun T.invoke(): R
}
public abstract class jet.ExtensionFunction1</*0*/ in T : jet.Any?, /*1*/ in P1 : jet.Any?, /*2*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ in T : jet.Any?, /*1*/ in P1 : jet.Any?, /*2*/ out R : jet.Any?><init>(): jet.ExtensionFunction1<T, P1, R>
    public abstract fun T.invoke(/*0*/ p1: P1): R
}
public abstract class jet.ExtensionFunction10</*0*/ in T : jet.Any?, /*1*/ in P1 : jet.Any?, /*2*/ in P2 : jet.Any?, /*3*/ in P3 : jet.Any?, /*4*/ in P4 : jet.Any?, /*5*/ in P5 : jet.Any?, /*6*/ in P6 : jet.Any?, /*7*/ in P7 : jet.Any?, /*8*/ in P8 : jet.Any?, /*9*/ in P9 : jet.Any?, /*10*/ in P10 : jet.Any?, /*11*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ in T : jet.Any?, /*1*/ in P1 : jet.Any?, /*2*/ in P2 : jet.Any?, /*3*/ in P3 : jet.Any?, /*4*/ in P4 : jet.Any?, /*5*/ in P5 : jet.Any?, /*6*/ in P6 : jet.Any?, /*7*/ in P7 : jet.Any?, /*8*/ in P8 : jet.Any?, /*9*/ in P9 : jet.Any?, /*10*/ in P10 : jet.Any?, /*11*/ out R : jet.Any?><init>(): jet.ExtensionFunction10<T, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, R>
    public abstract fun T.invoke(/*0*/ p1: P1, /*1*/ p2: P2, /*2*/ p3: P3, /*3*/ p4: P4, /*4*/ p5: P5, /*5*/ p6: P6, /*6*/ p7: P7, /*7*/ p8: P8, /*8*/ p9: P9, /*9*/ p10: P10): R
}
public abstract class jet.ExtensionFunction11</*0*/ in T : jet.Any?, /*1*/ in P1 : jet.Any?, /*2*/ in P2 : jet.Any?, /*3*/ in P3 : jet.Any?, /*4*/ in P4 : jet.Any?, /*5*/ in P5 : jet.Any?, /*6*/ in P6 : jet.Any?, /*7*/ in P7 : jet.Any?, /*8*/ in P8 : jet.Any?, /*9*/ in P9 : jet.Any?, /*10*/ in P10 : jet.Any?, /*11*/ in P11 : jet.Any?, /*12*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ in T : jet.Any?, /*1*/ in P1 : jet.Any?, /*2*/ in P2 : jet.Any?, /*3*/ in P3 : jet.Any?, /*4*/ in P4 : jet.Any?, /*5*/ in P5 : jet.Any?, /*6*/ in P6 : jet.Any?, /*7*/ in P7 : jet.Any?, /*8*/ in P8 : jet.Any?, /*9*/ in P9 : jet.Any?, /*10*/ in P10 : jet.Any?, /*11*/ in P11 : jet.Any?, /*12*/ out R : jet.Any?><init>(): jet.ExtensionFunction11<T, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, R>
    public abstract fun T.invoke(/*0*/ p1: P1, /*1*/ p2: P2, /*2*/ p3: P3, /*3*/ p4: P4, /*4*/ p5: P5, /*5*/ p6: P6, /*6*/ p7: P7, /*7*/ p8: P8, /*8*/ p9: P9, /*9*/ p10: P10, /*10*/ p11: P11): R
}
public abstract class jet.ExtensionFunction12</*0*/ in T : jet.Any?, /*1*/ in P1 : jet.Any?, /*2*/ in P2 : jet.Any?, /*3*/ in P3 : jet.Any?, /*4*/ in P4 : jet.Any?, /*5*/ in P5 : jet.Any?, /*6*/ in P6 : jet.Any?, /*7*/ in P7 : jet.Any?, /*8*/ in P8 : jet.Any?, /*9*/ in P9 : jet.Any?, /*10*/ in P10 : jet.Any?, /*11*/ in P11 : jet.Any?, /*12*/ in P12 : jet.Any?, /*13*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ in T : jet.Any?, /*1*/ in P1 : jet.Any?, /*2*/ in P2 : jet.Any?, /*3*/ in P3 : jet.Any?, /*4*/ in P4 : jet.Any?, /*5*/ in P5 : jet.Any?, /*6*/ in P6 : jet.Any?, /*7*/ in P7 : jet.Any?, /*8*/ in P8 : jet.Any?, /*9*/ in P9 : jet.Any?, /*10*/ in P10 : jet.Any?, /*11*/ in P11 : jet.Any?, /*12*/ in P12 : jet.Any?, /*13*/ out R : jet.Any?><init>(): jet.ExtensionFunction12<T, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, R>
    public abstract fun T.invoke(/*0*/ p1: P1, /*1*/ p2: P2, /*2*/ p3: P3, /*3*/ p4: P4, /*4*/ p5: P5, /*5*/ p6: P6, /*6*/ p7: P7, /*7*/ p8: P8, /*8*/ p9: P9, /*9*/ p10: P10, /*10*/ p11: P11, /*11*/ p12: P12): R
}
public abstract class jet.ExtensionFunction13</*0*/ in T : jet.Any?, /*1*/ in P1 : jet.Any?, /*2*/ in P2 : jet.Any?, /*3*/ in P3 : jet.Any?, /*4*/ in P4 : jet.Any?, /*5*/ in P5 : jet.Any?, /*6*/ in P6 : jet.Any?, /*7*/ in P7 : jet.Any?, /*8*/ in P8 : jet.Any?, /*9*/ in P9 : jet.Any?, /*10*/ in P10 : jet.Any?, /*11*/ in P11 : jet.Any?, /*12*/ in P12 : jet.Any?, /*13*/ in P13 : jet.Any?, /*14*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ in T : jet.Any?, /*1*/ in P1 : jet.Any?, /*2*/ in P2 : jet.Any?, /*3*/ in P3 : jet.Any?, /*4*/ in P4 : jet.Any?, /*5*/ in P5 : jet.Any?, /*6*/ in P6 : jet.Any?, /*7*/ in P7 : jet.Any?, /*8*/ in P8 : jet.Any?, /*9*/ in P9 : jet.Any?, /*10*/ in P10 : jet.Any?, /*11*/ in P11 : jet.Any?, /*12*/ in P12 : jet.Any?, /*13*/ in P13 : jet.Any?, /*14*/ out R : jet.Any?><init>(): jet.ExtensionFunction13<T, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, R>
    public abstract fun T.invoke(/*0*/ p1: P1, /*1*/ p2: P2, /*2*/ p3: P3, /*3*/ p4: P4, /*4*/ p5: P5, /*5*/ p6: P6, /*6*/ p7: P7, /*7*/ p8: P8, /*8*/ p9: P9, /*9*/ p10: P10, /*10*/ p11: P11, /*11*/ p12: P12, /*12*/ p13: P13): R
}
public abstract class jet.ExtensionFunction14</*0*/ in T : jet.Any?, /*1*/ in P1 : jet.Any?, /*2*/ in P2 : jet.Any?, /*3*/ in P3 : jet.Any?, /*4*/ in P4 : jet.Any?, /*5*/ in P5 : jet.Any?, /*6*/ in P6 : jet.Any?, /*7*/ in P7 : jet.Any?, /*8*/ in P8 : jet.Any?, /*9*/ in P9 : jet.Any?, /*10*/ in P10 : jet.Any?, /*11*/ in P11 : jet.Any?, /*12*/ in P12 : jet.Any?, /*13*/ in P13 : jet.Any?, /*14*/ in P14 : jet.Any?, /*15*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ in T : jet.Any?, /*1*/ in P1 : jet.Any?, /*2*/ in P2 : jet.Any?, /*3*/ in P3 : jet.Any?, /*4*/ in P4 : jet.Any?, /*5*/ in P5 : jet.Any?, /*6*/ in P6 : jet.Any?, /*7*/ in P7 : jet.Any?, /*8*/ in P8 : jet.Any?, /*9*/ in P9 : jet.Any?, /*10*/ in P10 : jet.Any?, /*11*/ in P11 : jet.Any?, /*12*/ in P12 : jet.Any?, /*13*/ in P13 : jet.Any?, /*14*/ in P14 : jet.Any?, /*15*/ out R : jet.Any?><init>(): jet.ExtensionFunction14<T, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, R>
    public abstract fun T.invoke(/*0*/ p1: P1, /*1*/ p2: P2, /*2*/ p3: P3, /*3*/ p4: P4, /*4*/ p5: P5, /*5*/ p6: P6, /*6*/ p7: P7, /*7*/ p8: P8, /*8*/ p9: P9, /*9*/ p10: P10, /*10*/ p11: P11, /*11*/ p12: P12, /*12*/ p13: P13, /*13*/ p14: P14): R
}
public abstract class jet.ExtensionFunction15</*0*/ in T : jet.Any?, /*1*/ in P1 : jet.Any?, /*2*/ in P2 : jet.Any?, /*3*/ in P3 : jet.Any?, /*4*/ in P4 : jet.Any?, /*5*/ in P5 : jet.Any?, /*6*/ in P6 : jet.Any?, /*7*/ in P7 : jet.Any?, /*8*/ in P8 : jet.Any?, /*9*/ in P9 : jet.Any?, /*10*/ in P10 : jet.Any?, /*11*/ in P11 : jet.Any?, /*12*/ in P12 : jet.Any?, /*13*/ in P13 : jet.Any?, /*14*/ in P14 : jet.Any?, /*15*/ in P15 : jet.Any?, /*16*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ in T : jet.Any?, /*1*/ in P1 : jet.Any?, /*2*/ in P2 : jet.Any?, /*3*/ in P3 : jet.Any?, /*4*/ in P4 : jet.Any?, /*5*/ in P5 : jet.Any?, /*6*/ in P6 : jet.Any?, /*7*/ in P7 : jet.Any?, /*8*/ in P8 : jet.Any?, /*9*/ in P9 : jet.Any?, /*10*/ in P10 : jet.Any?, /*11*/ in P11 : jet.Any?, /*12*/ in P12 : jet.Any?, /*13*/ in P13 : jet.Any?, /*14*/ in P14 : jet.Any?, /*15*/ in P15 : jet.Any?, /*16*/ out R : jet.Any?><init>(): jet.ExtensionFunction15<T, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, R>
    public abstract fun T.invoke(/*0*/ p1: P1, /*1*/ p2: P2, /*2*/ p3: P3, /*3*/ p4: P4, /*4*/ p5: P5, /*5*/ p6: P6, /*6*/ p7: P7, /*7*/ p8: P8, /*8*/ p9: P9, /*9*/ p10: P10, /*10*/ p11: P11, /*11*/ p12: P12, /*12*/ p13: P13, /*13*/ p14: P14, /*14*/ p15: P15): R
}
public abstract class jet.ExtensionFunction16</*0*/ in T : jet.Any?, /*1*/ in P1 : jet.Any?, /*2*/ in P2 : jet.Any?, /*3*/ in P3 : jet.Any?, /*4*/ in P4 : jet.Any?, /*5*/ in P5 : jet.Any?, /*6*/ in P6 : jet.Any?, /*7*/ in P7 : jet.Any?, /*8*/ in P8 : jet.Any?, /*9*/ in P9 : jet.Any?, /*10*/ in P10 : jet.Any?, /*11*/ in P11 : jet.Any?, /*12*/ in P12 : jet.Any?, /*13*/ in P13 : jet.Any?, /*14*/ in P14 : jet.Any?, /*15*/ in P15 : jet.Any?, /*16*/ in P16 : jet.Any?, /*17*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ in T : jet.Any?, /*1*/ in P1 : jet.Any?, /*2*/ in P2 : jet.Any?, /*3*/ in P3 : jet.Any?, /*4*/ in P4 : jet.Any?, /*5*/ in P5 : jet.Any?, /*6*/ in P6 : jet.Any?, /*7*/ in P7 : jet.Any?, /*8*/ in P8 : jet.Any?, /*9*/ in P9 : jet.Any?, /*10*/ in P10 : jet.Any?, /*11*/ in P11 : jet.Any?, /*12*/ in P12 : jet.Any?, /*13*/ in P13 : jet.Any?, /*14*/ in P14 : jet.Any?, /*15*/ in P15 : jet.Any?, /*16*/ in P16 : jet.Any?, /*17*/ out R : jet.Any?><init>(): jet.ExtensionFunction16<T, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, R>
    public abstract fun T.invoke(/*0*/ p1: P1, /*1*/ p2: P2, /*2*/ p3: P3, /*3*/ p4: P4, /*4*/ p5: P5, /*5*/ p6: P6, /*6*/ p7: P7, /*7*/ p8: P8, /*8*/ p9: P9, /*9*/ p10: P10, /*10*/ p11: P11, /*11*/ p12: P12, /*12*/ p13: P13, /*13*/ p14: P14, /*14*/ p15: P15, /*15*/ p16: P16): R
}
public abstract class jet.ExtensionFunction17</*0*/ in T : jet.Any?, /*1*/ in P1 : jet.Any?, /*2*/ in P2 : jet.Any?, /*3*/ in P3 : jet.Any?, /*4*/ in P4 : jet.Any?, /*5*/ in P5 : jet.Any?, /*6*/ in P6 : jet.Any?, /*7*/ in P7 : jet.Any?, /*8*/ in P8 : jet.Any?, /*9*/ in P9 : jet.Any?, /*10*/ in P10 : jet.Any?, /*11*/ in P11 : jet.Any?, /*12*/ in P12 : jet.Any?, /*13*/ in P13 : jet.Any?, /*14*/ in P14 : jet.Any?, /*15*/ in P15 : jet.Any?, /*16*/ in P16 : jet.Any?, /*17*/ in P17 : jet.Any?, /*18*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ in T : jet.Any?, /*1*/ in P1 : jet.Any?, /*2*/ in P2 : jet.Any?, /*3*/ in P3 : jet.Any?, /*4*/ in P4 : jet.Any?, /*5*/ in P5 : jet.Any?, /*6*/ in P6 : jet.Any?, /*7*/ in P7 : jet.Any?, /*8*/ in P8 : jet.Any?, /*9*/ in P9 : jet.Any?, /*10*/ in P10 : jet.Any?, /*11*/ in P11 : jet.Any?, /*12*/ in P12 : jet.Any?, /*13*/ in P13 : jet.Any?, /*14*/ in P14 : jet.Any?, /*15*/ in P15 : jet.Any?, /*16*/ in P16 : jet.Any?, /*17*/ in P17 : jet.Any?, /*18*/ out R : jet.Any?><init>(): jet.ExtensionFunction17<T, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, R>
    public abstract fun T.invoke(/*0*/ p1: P1, /*1*/ p2: P2, /*2*/ p3: P3, /*3*/ p4: P4, /*4*/ p5: P5, /*5*/ p6: P6, /*6*/ p7: P7, /*7*/ p8: P8, /*8*/ p9: P9, /*9*/ p10: P10, /*10*/ p11: P11, /*11*/ p12: P12, /*12*/ p13: P13, /*13*/ p14: P14, /*14*/ p15: P15, /*15*/ p16: P16, /*16*/ p17: P17): R
}
public abstract class jet.ExtensionFunction18</*0*/ in T : jet.Any?, /*1*/ in P1 : jet.Any?, /*2*/ in P2 : jet.Any?, /*3*/ in P3 : jet.Any?, /*4*/ in P4 : jet.Any?, /*5*/ in P5 : jet.Any?, /*6*/ in P6 : jet.Any?, /*7*/ in P7 : jet.Any?, /*8*/ in P8 : jet.Any?, /*9*/ in P9 : jet.Any?, /*10*/ in P10 : jet.Any?, /*11*/ in P11 : jet.Any?, /*12*/ in P12 : jet.Any?, /*13*/ in P13 : jet.Any?, /*14*/ in P14 : jet.Any?, /*15*/ in P15 : jet.Any?, /*16*/ in P16 : jet.Any?, /*17*/ in P17 : jet.Any?, /*18*/ in P18 : jet.Any?, /*19*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ in T : jet.Any?, /*1*/ in P1 : jet.Any?, /*2*/ in P2 : jet.Any?, /*3*/ in P3 : jet.Any?, /*4*/ in P4 : jet.Any?, /*5*/ in P5 : jet.Any?, /*6*/ in P6 : jet.Any?, /*7*/ in P7 : jet.Any?, /*8*/ in P8 : jet.Any?, /*9*/ in P9 : jet.Any?, /*10*/ in P10 : jet.Any?, /*11*/ in P11 : jet.Any?, /*12*/ in P12 : jet.Any?, /*13*/ in P13 : jet.Any?, /*14*/ in P14 : jet.Any?, /*15*/ in P15 : jet.Any?, /*16*/ in P16 : jet.Any?, /*17*/ in P17 : jet.Any?, /*18*/ in P18 : jet.Any?, /*19*/ out R : jet.Any?><init>(): jet.ExtensionFunction18<T, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, R>
    public abstract fun T.invoke(/*0*/ p1: P1, /*1*/ p2: P2, /*2*/ p3: P3, /*3*/ p4: P4, /*4*/ p5: P5, /*5*/ p6: P6, /*6*/ p7: P7, /*7*/ p8: P8, /*8*/ p9: P9, /*9*/ p10: P10, /*10*/ p11: P11, /*11*/ p12: P12, /*12*/ p13: P13, /*13*/ p14: P14, /*14*/ p15: P15, /*15*/ p16: P16, /*16*/ p17: P17, /*17*/ p18: P18): R
}
public abstract class jet.ExtensionFunction19</*0*/ in T : jet.Any?, /*1*/ in P1 : jet.Any?, /*2*/ in P2 : jet.Any?, /*3*/ in P3 : jet.Any?, /*4*/ in P4 : jet.Any?, /*5*/ in P5 : jet.Any?, /*6*/ in P6 : jet.Any?, /*7*/ in P7 : jet.Any?, /*8*/ in P8 : jet.Any?, /*9*/ in P9 : jet.Any?, /*10*/ in P10 : jet.Any?, /*11*/ in P11 : jet.Any?, /*12*/ in P12 : jet.Any?, /*13*/ in P13 : jet.Any?, /*14*/ in P14 : jet.Any?, /*15*/ in P15 : jet.Any?, /*16*/ in P16 : jet.Any?, /*17*/ in P17 : jet.Any?, /*18*/ in P18 : jet.Any?, /*19*/ in P19 : jet.Any?, /*20*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ in T : jet.Any?, /*1*/ in P1 : jet.Any?, /*2*/ in P2 : jet.Any?, /*3*/ in P3 : jet.Any?, /*4*/ in P4 : jet.Any?, /*5*/ in P5 : jet.Any?, /*6*/ in P6 : jet.Any?, /*7*/ in P7 : jet.Any?, /*8*/ in P8 : jet.Any?, /*9*/ in P9 : jet.Any?, /*10*/ in P10 : jet.Any?, /*11*/ in P11 : jet.Any?, /*12*/ in P12 : jet.Any?, /*13*/ in P13 : jet.Any?, /*14*/ in P14 : jet.Any?, /*15*/ in P15 : jet.Any?, /*16*/ in P16 : jet.Any?, /*17*/ in P17 : jet.Any?, /*18*/ in P18 : jet.Any?, /*19*/ in P19 : jet.Any?, /*20*/ out R : jet.Any?><init>(): jet.ExtensionFunction19<T, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, R>
    public abstract fun T.invoke(/*0*/ p1: P1, /*1*/ p2: P2, /*2*/ p3: P3, /*3*/ p4: P4, /*4*/ p5: P5, /*5*/ p6: P6, /*6*/ p7: P7, /*7*/ p8: P8, /*8*/ p9: P9, /*9*/ p10: P10, /*10*/ p11: P11, /*11*/ p12: P12, /*12*/ p13: P13, /*13*/ p14: P14, /*14*/ p15: P15, /*15*/ p16: P16, /*16*/ p17: P17, /*17*/ p18: P18, /*18*/ p19: P19): R
}
public abstract class jet.ExtensionFunction2</*0*/ in T : jet.Any?, /*1*/ in P1 : jet.Any?, /*2*/ in P2 : jet.Any?, /*3*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ in T : jet.Any?, /*1*/ in P1 : jet.Any?, /*2*/ in P2 : jet.Any?, /*3*/ out R : jet.Any?><init>(): jet.ExtensionFunction2<T, P1, P2, R>
    public abstract fun T.invoke(/*0*/ p1: P1, /*1*/ p2: P2): R
}
public abstract class jet.ExtensionFunction20</*0*/ in T : jet.Any?, /*1*/ in P1 : jet.Any?, /*2*/ in P2 : jet.Any?, /*3*/ in P3 : jet.Any?, /*4*/ in P4 : jet.Any?, /*5*/ in P5 : jet.Any?, /*6*/ in P6 : jet.Any?, /*7*/ in P7 : jet.Any?, /*8*/ in P8 : jet.Any?, /*9*/ in P9 : jet.Any?, /*10*/ in P10 : jet.Any?, /*11*/ in P11 : jet.Any?, /*12*/ in P12 : jet.Any?, /*13*/ in P13 : jet.Any?, /*14*/ in P14 : jet.Any?, /*15*/ in P15 : jet.Any?, /*16*/ in P16 : jet.Any?, /*17*/ in P17 : jet.Any?, /*18*/ in P18 : jet.Any?, /*19*/ in P19 : jet.Any?, /*20*/ in P20 : jet.Any?, /*21*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ in T : jet.Any?, /*1*/ in P1 : jet.Any?, /*2*/ in P2 : jet.Any?, /*3*/ in P3 : jet.Any?, /*4*/ in P4 : jet.Any?, /*5*/ in P5 : jet.Any?, /*6*/ in P6 : jet.Any?, /*7*/ in P7 : jet.Any?, /*8*/ in P8 : jet.Any?, /*9*/ in P9 : jet.Any?, /*10*/ in P10 : jet.Any?, /*11*/ in P11 : jet.Any?, /*12*/ in P12 : jet.Any?, /*13*/ in P13 : jet.Any?, /*14*/ in P14 : jet.Any?, /*15*/ in P15 : jet.Any?, /*16*/ in P16 : jet.Any?, /*17*/ in P17 : jet.Any?, /*18*/ in P18 : jet.Any?, /*19*/ in P19 : jet.Any?, /*20*/ in P20 : jet.Any?, /*21*/ out R : jet.Any?><init>(): jet.ExtensionFunction20<T, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, R>
    public abstract fun T.invoke(/*0*/ p1: P1, /*1*/ p2: P2, /*2*/ p3: P3, /*3*/ p4: P4, /*4*/ p5: P5, /*5*/ p6: P6, /*6*/ p7: P7, /*7*/ p8: P8, /*8*/ p9: P9, /*9*/ p10: P10, /*10*/ p11: P11, /*11*/ p12: P12, /*12*/ p13: P13, /*13*/ p14: P14, /*14*/ p15: P15, /*15*/ p16: P16, /*16*/ p17: P17, /*17*/ p18: P18, /*18*/ p19: P19, /*19*/ p20: P20): R
}
public abstract class jet.ExtensionFunction21</*0*/ in T : jet.Any?, /*1*/ in P1 : jet.Any?, /*2*/ in P2 : jet.Any?, /*3*/ in P3 : jet.Any?, /*4*/ in P4 : jet.Any?, /*5*/ in P5 : jet.Any?, /*6*/ in P6 : jet.Any?, /*7*/ in P7 : jet.Any?, /*8*/ in P8 : jet.Any?, /*9*/ in P9 : jet.Any?, /*10*/ in P10 : jet.Any?, /*11*/ in P11 : jet.Any?, /*12*/ in P12 : jet.Any?, /*13*/ in P13 : jet.Any?, /*14*/ in P14 : jet.Any?, /*15*/ in P15 : jet.Any?, /*16*/ in P16 : jet.Any?, /*17*/ in P17 : jet.Any?, /*18*/ in P18 : jet.Any?, /*19*/ in P19 : jet.Any?, /*20*/ in P20 : jet.Any?, /*21*/ in P21 : jet.Any?, /*22*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ in T : jet.Any?, /*1*/ in P1 : jet.Any?, /*2*/ in P2 : jet.Any?, /*3*/ in P3 : jet.Any?, /*4*/ in P4 : jet.Any?, /*5*/ in P5 : jet.Any?, /*6*/ in P6 : jet.Any?, /*7*/ in P7 : jet.Any?, /*8*/ in P8 : jet.Any?, /*9*/ in P9 : jet.Any?, /*10*/ in P10 : jet.Any?, /*11*/ in P11 : jet.Any?, /*12*/ in P12 : jet.Any?, /*13*/ in P13 : jet.Any?, /*14*/ in P14 : jet.Any?, /*15*/ in P15 : jet.Any?, /*16*/ in P16 : jet.Any?, /*17*/ in P17 : jet.Any?, /*18*/ in P18 : jet.Any?, /*19*/ in P19 : jet.Any?, /*20*/ in P20 : jet.Any?, /*21*/ in P21 : jet.Any?, /*22*/ out R : jet.Any?><init>(): jet.ExtensionFunction21<T, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, R>
    public abstract fun T.invoke(/*0*/ p1: P1, /*1*/ p2: P2, /*2*/ p3: P3, /*3*/ p4: P4, /*4*/ p5: P5, /*5*/ p6: P6, /*6*/ p7: P7, /*7*/ p8: P8, /*8*/ p9: P9, /*9*/ p10: P10, /*10*/ p11: P11, /*11*/ p12: P12, /*12*/ p13: P13, /*13*/ p14: P14, /*14*/ p15: P15, /*15*/ p16: P16, /*16*/ p17: P17, /*17*/ p18: P18, /*18*/ p19: P19, /*19*/ p20: P20, /*20*/ p21: P21): R
}
public abstract class jet.ExtensionFunction22</*0*/ in T : jet.Any?, /*1*/ in P1 : jet.Any?, /*2*/ in P2 : jet.Any?, /*3*/ in P3 : jet.Any?, /*4*/ in P4 : jet.Any?, /*5*/ in P5 : jet.Any?, /*6*/ in P6 : jet.Any?, /*7*/ in P7 : jet.Any?, /*8*/ in P8 : jet.Any?, /*9*/ in P9 : jet.Any?, /*10*/ in P10 : jet.Any?, /*11*/ in P11 : jet.Any?, /*12*/ in P12 : jet.Any?, /*13*/ in P13 : jet.Any?, /*14*/ in P14 : jet.Any?, /*15*/ in P15 : jet.Any?, /*16*/ in P16 : jet.Any?, /*17*/ in P17 : jet.Any?, /*18*/ in P18 : jet.Any?, /*19*/ in P19 : jet.Any?, /*20*/ in P20 : jet.Any?, /*21*/ in P21 : jet.Any?, /*22*/ in P22 : jet.Any?, /*23*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ in T : jet.Any?, /*1*/ in P1 : jet.Any?, /*2*/ in P2 : jet.Any?, /*3*/ in P3 : jet.Any?, /*4*/ in P4 : jet.Any?, /*5*/ in P5 : jet.Any?, /*6*/ in P6 : jet.Any?, /*7*/ in P7 : jet.Any?, /*8*/ in P8 : jet.Any?, /*9*/ in P9 : jet.Any?, /*10*/ in P10 : jet.Any?, /*11*/ in P11 : jet.Any?, /*12*/ in P12 : jet.Any?, /*13*/ in P13 : jet.Any?, /*14*/ in P14 : jet.Any?, /*15*/ in P15 : jet.Any?, /*16*/ in P16 : jet.Any?, /*17*/ in P17 : jet.Any?, /*18*/ in P18 : jet.Any?, /*19*/ in P19 : jet.Any?, /*20*/ in P20 : jet.Any?, /*21*/ in P21 : jet.Any?, /*22*/ in P22 : jet.Any?, /*23*/ out R : jet.Any?><init>(): jet.ExtensionFunction22<T, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, R>
    public abstract fun T.invoke(/*0*/ p1: P1, /*1*/ p2: P2, /*2*/ p3: P3, /*3*/ p4: P4, /*4*/ p5: P5, /*5*/ p6: P6, /*6*/ p7: P7, /*7*/ p8: P8, /*8*/ p9: P9, /*9*/ p10: P10, /*10*/ p11: P11, /*11*/ p12: P12, /*12*/ p13: P13, /*13*/ p14: P14, /*14*/ p15: P15, /*15*/ p16: P16, /*16*/ p17: P17, /*17*/ p18: P18, /*18*/ p19: P19, /*19*/ p20: P20, /*20*/ p21: P21, /*21*/ p22: P22): R
}
public abstract class jet.ExtensionFunction3</*0*/ in T : jet.Any?, /*1*/ in P1 : jet.Any?, /*2*/ in P2 : jet.Any?, /*3*/ in P3 : jet.Any?, /*4*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ in T : jet.Any?, /*1*/ in P1 : jet.Any?, /*2*/ in P2 : jet.Any?, /*3*/ in P3 : jet.Any?, /*4*/ out R : jet.Any?><init>(): jet.ExtensionFunction3<T, P1, P2, P3, R>
    public abstract fun T.invoke(/*0*/ p1: P1, /*1*/ p2: P2, /*2*/ p3: P3): R
}
public abstract class jet.ExtensionFunction4</*0*/ in T : jet.Any?, /*1*/ in P1 : jet.Any?, /*2*/ in P2 : jet.Any?, /*3*/ in P3 : jet.Any?, /*4*/ in P4 : jet.Any?, /*5*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ in T : jet.Any?, /*1*/ in P1 : jet.Any?, /*2*/ in P2 : jet.Any?, /*3*/ in P3 : jet.Any?, /*4*/ in P4 : jet.Any?, /*5*/ out R : jet.Any?><init>(): jet.ExtensionFunction4<T, P1, P2, P3, P4, R>
    public abstract fun T.invoke(/*0*/ p1: P1, /*1*/ p2: P2, /*2*/ p3: P3, /*3*/ p4: P4): R
}
public abstract class jet.ExtensionFunction5</*0*/ in T : jet.Any?, /*1*/ in P1 : jet.Any?, /*2*/ in P2 : jet.Any?, /*3*/ in P3 : jet.Any?, /*4*/ in P4 : jet.Any?, /*5*/ in P5 : jet.Any?, /*6*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ in T : jet.Any?, /*1*/ in P1 : jet.Any?, /*2*/ in P2 : jet.Any?, /*3*/ in P3 : jet.Any?, /*4*/ in P4 : jet.Any?, /*5*/ in P5 : jet.Any?, /*6*/ out R : jet.Any?><init>(): jet.ExtensionFunction5<T, P1, P2, P3, P4, P5, R>
    public abstract fun T.invoke(/*0*/ p1: P1, /*1*/ p2: P2, /*2*/ p3: P3, /*3*/ p4: P4, /*4*/ p5: P5): R
}
public abstract class jet.ExtensionFunction6</*0*/ in T : jet.Any?, /*1*/ in P1 : jet.Any?, /*2*/ in P2 : jet.Any?, /*3*/ in P3 : jet.Any?, /*4*/ in P4 : jet.Any?, /*5*/ in P5 : jet.Any?, /*6*/ in P6 : jet.Any?, /*7*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ in T : jet.Any?, /*1*/ in P1 : jet.Any?, /*2*/ in P2 : jet.Any?, /*3*/ in P3 : jet.Any?, /*4*/ in P4 : jet.Any?, /*5*/ in P5 : jet.Any?, /*6*/ in P6 : jet.Any?, /*7*/ out R : jet.Any?><init>(): jet.ExtensionFunction6<T, P1, P2, P3, P4, P5, P6, R>
    public abstract fun T.invoke(/*0*/ p1: P1, /*1*/ p2: P2, /*2*/ p3: P3, /*3*/ p4: P4, /*4*/ p5: P5, /*5*/ p6: P6): R
}
public abstract class jet.ExtensionFunction7</*0*/ in T : jet.Any?, /*1*/ in P1 : jet.Any?, /*2*/ in P2 : jet.Any?, /*3*/ in P3 : jet.Any?, /*4*/ in P4 : jet.Any?, /*5*/ in P5 : jet.Any?, /*6*/ in P6 : jet.Any?, /*7*/ in P7 : jet.Any?, /*8*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ in T : jet.Any?, /*1*/ in P1 : jet.Any?, /*2*/ in P2 : jet.Any?, /*3*/ in P3 : jet.Any?, /*4*/ in P4 : jet.Any?, /*5*/ in P5 : jet.Any?, /*6*/ in P6 : jet.Any?, /*7*/ in P7 : jet.Any?, /*8*/ out R : jet.Any?><init>(): jet.ExtensionFunction7<T, P1, P2, P3, P4, P5, P6, P7, R>
    public abstract fun T.invoke(/*0*/ p1: P1, /*1*/ p2: P2, /*2*/ p3: P3, /*3*/ p4: P4, /*4*/ p5: P5, /*5*/ p6: P6, /*6*/ p7: P7): R
}
public abstract class jet.ExtensionFunction8</*0*/ in T : jet.Any?, /*1*/ in P1 : jet.Any?, /*2*/ in P2 : jet.Any?, /*3*/ in P3 : jet.Any?, /*4*/ in P4 : jet.Any?, /*5*/ in P5 : jet.Any?, /*6*/ in P6 : jet.Any?, /*7*/ in P7 : jet.Any?, /*8*/ in P8 : jet.Any?, /*9*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ in T : jet.Any?, /*1*/ in P1 : jet.Any?, /*2*/ in P2 : jet.Any?, /*3*/ in P3 : jet.Any?, /*4*/ in P4 : jet.Any?, /*5*/ in P5 : jet.Any?, /*6*/ in P6 : jet.Any?, /*7*/ in P7 : jet.Any?, /*8*/ in P8 : jet.Any?, /*9*/ out R : jet.Any?><init>(): jet.ExtensionFunction8<T, P1, P2, P3, P4, P5, P6, P7, P8, R>
    public abstract fun T.invoke(/*0*/ p1: P1, /*1*/ p2: P2, /*2*/ p3: P3, /*3*/ p4: P4, /*4*/ p5: P5, /*5*/ p6: P6, /*6*/ p7: P7, /*7*/ p8: P8): R
}
public abstract class jet.ExtensionFunction9</*0*/ in T : jet.Any?, /*1*/ in P1 : jet.Any?, /*2*/ in P2 : jet.Any?, /*3*/ in P3 : jet.Any?, /*4*/ in P4 : jet.Any?, /*5*/ in P5 : jet.Any?, /*6*/ in P6 : jet.Any?, /*7*/ in P7 : jet.Any?, /*8*/ in P8 : jet.Any?, /*9*/ in P9 : jet.Any?, /*10*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ in T : jet.Any?, /*1*/ in P1 : jet.Any?, /*2*/ in P2 : jet.Any?, /*3*/ in P3 : jet.Any?, /*4*/ in P4 : jet.Any?, /*5*/ in P5 : jet.Any?, /*6*/ in P6 : jet.Any?, /*7*/ in P7 : jet.Any?, /*8*/ in P8 : jet.Any?, /*9*/ in P9 : jet.Any?, /*10*/ out R : jet.Any?><init>(): jet.ExtensionFunction9<T, P1, P2, P3, P4, P5, P6, P7, P8, P9, R>
    public abstract fun T.invoke(/*0*/ p1: P1, /*1*/ p2: P2, /*2*/ p3: P3, /*3*/ p4: P4, /*4*/ p5: P5, /*5*/ p6: P6, /*6*/ p7: P7, /*7*/ p8: P8, /*8*/ p9: P9): R
}
public final class jet.Float : jet.Number, jet.Comparable<jet.Float> {
    public final /*constructor*/ fun <init>(): jet.Float
    public final fun compareTo(/*0*/ other: jet.Byte): jet.Int
    public final fun compareTo(/*0*/ other: jet.Char): jet.Int
    public final fun compareTo(/*0*/ other: jet.Double): jet.Int
    public open override /*1*/ fun compareTo(/*0*/ other: jet.Float): jet.Int
    public final fun compareTo(/*0*/ other: jet.Int): jet.Int
    public final fun compareTo(/*0*/ other: jet.Long): jet.Int
    public final fun compareTo(/*0*/ other: jet.Short): jet.Int
    public final fun dec(): jet.Float
    public final fun div(/*0*/ other: jet.Byte): jet.Float
    public final fun div(/*0*/ other: jet.Char): jet.Float
    public final fun div(/*0*/ other: jet.Double): jet.Double
    public final fun div(/*0*/ other: jet.Float): jet.Float
    public final fun div(/*0*/ other: jet.Int): jet.Float
    public final fun div(/*0*/ other: jet.Long): jet.Float
    public final fun div(/*0*/ other: jet.Short): jet.Float
    public final fun downto(/*0*/ other: jet.Byte): jet.FloatRange
    public final fun downto(/*0*/ other: jet.Char): jet.FloatRange
    public final fun downto(/*0*/ other: jet.Double): jet.DoubleRange
    public final fun downto(/*0*/ other: jet.Float): jet.FloatRange
    public final fun downto(/*0*/ other: jet.Int): jet.FloatRange
    public final fun downto(/*0*/ other: jet.Long): jet.DoubleRange
    public final fun downto(/*0*/ other: jet.Short): jet.FloatRange
    public open override /*1*/ fun equals(/*0*/ other: jet.Any?): jet.Boolean
    public open override /*1*/ fun hashCode(): jet.Int
    public final fun inc(): jet.Float
    public final fun minus(): jet.Float
    public final fun minus(/*0*/ other: jet.Byte): jet.Float
    public final fun minus(/*0*/ other: jet.Char): jet.Float
    public final fun minus(/*0*/ other: jet.Double): jet.Double
    public final fun minus(/*0*/ other: jet.Float): jet.Float
    public final fun minus(/*0*/ other: jet.Int): jet.Float
    public final fun minus(/*0*/ other: jet.Long): jet.Float
    public final fun minus(/*0*/ other: jet.Short): jet.Float
    public final fun mod(/*0*/ other: jet.Byte): jet.Float
    public final fun mod(/*0*/ other: jet.Char): jet.Float
    public final fun mod(/*0*/ other: jet.Double): jet.Double
    public final fun mod(/*0*/ other: jet.Float): jet.Float
    public final fun mod(/*0*/ other: jet.Int): jet.Float
    public final fun mod(/*0*/ other: jet.Long): jet.Float
    public final fun mod(/*0*/ other: jet.Short): jet.Float
    public final fun plus(): jet.Float
    public final fun plus(/*0*/ other: jet.Byte): jet.Float
    public final fun plus(/*0*/ other: jet.Char): jet.Float
    public final fun plus(/*0*/ other: jet.Double): jet.Double
    public final fun plus(/*0*/ other: jet.Float): jet.Float
    public final fun plus(/*0*/ other: jet.Int): jet.Float
    public final fun plus(/*0*/ other: jet.Long): jet.Float
    public final fun plus(/*0*/ other: jet.Short): jet.Float
    public final fun rangeTo(/*0*/ other: jet.Byte): jet.FloatRange
    public final fun rangeTo(/*0*/ other: jet.Char): jet.FloatRange
    public final fun rangeTo(/*0*/ other: jet.Double): jet.DoubleRange
    public final fun rangeTo(/*0*/ other: jet.Float): jet.FloatRange
    public final fun rangeTo(/*0*/ other: jet.Int): jet.FloatRange
    public final fun rangeTo(/*0*/ other: jet.Long): jet.DoubleRange
    public final fun rangeTo(/*0*/ other: jet.Short): jet.FloatRange
    public final fun times(/*0*/ other: jet.Byte): jet.Float
    public final fun times(/*0*/ other: jet.Char): jet.Float
    public final fun times(/*0*/ other: jet.Double): jet.Double
    public final fun times(/*0*/ other: jet.Float): jet.Float
    public final fun times(/*0*/ other: jet.Int): jet.Float
    public final fun times(/*0*/ other: jet.Long): jet.Float
    public final fun times(/*0*/ other: jet.Short): jet.Float
    public open override /*1*/ fun toByte(): jet.Byte
    public open override /*1*/ fun toChar(): jet.Char
    public open override /*1*/ fun toDouble(): jet.Double
    public open override /*1*/ fun toFloat(): jet.Float
    public open override /*1*/ fun toInt(): jet.Int
    public open override /*1*/ fun toLong(): jet.Long
    public open override /*1*/ fun toShort(): jet.Short
    public final fun upto(/*0*/ other: jet.Byte): jet.FloatRange
    public final fun upto(/*0*/ other: jet.Char): jet.FloatRange
    public final fun upto(/*0*/ other: jet.Double): jet.DoubleRange
    public final fun upto(/*0*/ other: jet.Float): jet.FloatRange
    public final fun upto(/*0*/ other: jet.Int): jet.FloatRange
    public final fun upto(/*0*/ other: jet.Long): jet.DoubleRange
    public final fun upto(/*0*/ other: jet.Short): jet.FloatRange
}
public final class jet.FloatArray : jet.Any {
    public final /*constructor*/ fun <init>(/*0*/ size: jet.Int): jet.FloatArray
    public final fun get(/*0*/ index: jet.Int): jet.Float
    public final val indices: jet.IntRange
    public final fun iterator(): jet.FloatIterator
    public final fun set(/*0*/ index: jet.Int, /*1*/ value: jet.Float): jet.Tuple0
    public final val size: jet.Int
}
public abstract trait jet.FloatIterable : jet.Iterable<jet.Float> {
    public abstract override /*1*/ fun iterator(): jet.FloatIterator
}
public abstract class jet.FloatIterator : jet.Iterator<jet.Float> {
    public final /*constructor*/ fun <init>(): jet.FloatIterator
    public abstract override /*1*/ val hasNext: jet.Boolean
    public open override /*1*/ fun next(): jet.Float
    public abstract fun nextFloat(): jet.Float
}
public final class jet.FloatRange : jet.Range<jet.Float> {
    public final /*constructor*/ fun <init>(/*0*/ start: jet.Float, /*1*/ size: jet.Float): jet.FloatRange
    public open override /*1*/ fun contains(/*0*/ elem: jet.Float): jet.Boolean
    public final val end: jet.Float
    public final val isReversed: jet.Boolean
    public final fun minus(): jet.FloatRange
    public final val size: jet.Float
    public final val start: jet.Float
    public final fun step(/*0*/ step: jet.Float): jet.FloatIterator
}
public abstract class jet.Function0</*0*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ out R : jet.Any?><init>(): jet.Function0<R>
    public abstract fun invoke(): R
}
public abstract class jet.Function1</*0*/ in P1 : jet.Any?, /*1*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ in P1 : jet.Any?, /*1*/ out R : jet.Any?><init>(): jet.Function1<P1, R>
    public abstract fun invoke(/*0*/ p1: P1): R
}
public abstract class jet.Function10</*0*/ in P1 : jet.Any?, /*1*/ in P2 : jet.Any?, /*2*/ in P3 : jet.Any?, /*3*/ in P4 : jet.Any?, /*4*/ in P5 : jet.Any?, /*5*/ in P6 : jet.Any?, /*6*/ in P7 : jet.Any?, /*7*/ in P8 : jet.Any?, /*8*/ in P9 : jet.Any?, /*9*/ in P10 : jet.Any?, /*10*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ in P1 : jet.Any?, /*1*/ in P2 : jet.Any?, /*2*/ in P3 : jet.Any?, /*3*/ in P4 : jet.Any?, /*4*/ in P5 : jet.Any?, /*5*/ in P6 : jet.Any?, /*6*/ in P7 : jet.Any?, /*7*/ in P8 : jet.Any?, /*8*/ in P9 : jet.Any?, /*9*/ in P10 : jet.Any?, /*10*/ out R : jet.Any?><init>(): jet.Function10<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, R>
    public abstract fun invoke(/*0*/ p1: P1, /*1*/ p2: P2, /*2*/ p3: P3, /*3*/ p4: P4, /*4*/ p5: P5, /*5*/ p6: P6, /*6*/ p7: P7, /*7*/ p8: P8, /*8*/ p9: P9, /*9*/ p10: P10): R
}
public abstract class jet.Function11</*0*/ in P1 : jet.Any?, /*1*/ in P2 : jet.Any?, /*2*/ in P3 : jet.Any?, /*3*/ in P4 : jet.Any?, /*4*/ in P5 : jet.Any?, /*5*/ in P6 : jet.Any?, /*6*/ in P7 : jet.Any?, /*7*/ in P8 : jet.Any?, /*8*/ in P9 : jet.Any?, /*9*/ in P10 : jet.Any?, /*10*/ in P11 : jet.Any?, /*11*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ in P1 : jet.Any?, /*1*/ in P2 : jet.Any?, /*2*/ in P3 : jet.Any?, /*3*/ in P4 : jet.Any?, /*4*/ in P5 : jet.Any?, /*5*/ in P6 : jet.Any?, /*6*/ in P7 : jet.Any?, /*7*/ in P8 : jet.Any?, /*8*/ in P9 : jet.Any?, /*9*/ in P10 : jet.Any?, /*10*/ in P11 : jet.Any?, /*11*/ out R : jet.Any?><init>(): jet.Function11<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, R>
    public abstract fun invoke(/*0*/ p1: P1, /*1*/ p2: P2, /*2*/ p3: P3, /*3*/ p4: P4, /*4*/ p5: P5, /*5*/ p6: P6, /*6*/ p7: P7, /*7*/ p8: P8, /*8*/ p9: P9, /*9*/ p10: P10, /*10*/ p11: P11): R
}
public abstract class jet.Function12</*0*/ in P1 : jet.Any?, /*1*/ in P2 : jet.Any?, /*2*/ in P3 : jet.Any?, /*3*/ in P4 : jet.Any?, /*4*/ in P5 : jet.Any?, /*5*/ in P6 : jet.Any?, /*6*/ in P7 : jet.Any?, /*7*/ in P8 : jet.Any?, /*8*/ in P9 : jet.Any?, /*9*/ in P10 : jet.Any?, /*10*/ in P11 : jet.Any?, /*11*/ in P12 : jet.Any?, /*12*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ in P1 : jet.Any?, /*1*/ in P2 : jet.Any?, /*2*/ in P3 : jet.Any?, /*3*/ in P4 : jet.Any?, /*4*/ in P5 : jet.Any?, /*5*/ in P6 : jet.Any?, /*6*/ in P7 : jet.Any?, /*7*/ in P8 : jet.Any?, /*8*/ in P9 : jet.Any?, /*9*/ in P10 : jet.Any?, /*10*/ in P11 : jet.Any?, /*11*/ in P12 : jet.Any?, /*12*/ out R : jet.Any?><init>(): jet.Function12<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, R>
    public abstract fun invoke(/*0*/ p1: P1, /*1*/ p2: P2, /*2*/ p3: P3, /*3*/ p4: P4, /*4*/ p5: P5, /*5*/ p6: P6, /*6*/ p7: P7, /*7*/ p8: P8, /*8*/ p9: P9, /*9*/ p10: P10, /*10*/ p11: P11, /*11*/ p12: P12): R
}
public abstract class jet.Function13</*0*/ in P1 : jet.Any?, /*1*/ in P2 : jet.Any?, /*2*/ in P3 : jet.Any?, /*3*/ in P4 : jet.Any?, /*4*/ in P5 : jet.Any?, /*5*/ in P6 : jet.Any?, /*6*/ in P7 : jet.Any?, /*7*/ in P8 : jet.Any?, /*8*/ in P9 : jet.Any?, /*9*/ in P10 : jet.Any?, /*10*/ in P11 : jet.Any?, /*11*/ in P12 : jet.Any?, /*12*/ in P13 : jet.Any?, /*13*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ in P1 : jet.Any?, /*1*/ in P2 : jet.Any?, /*2*/ in P3 : jet.Any?, /*3*/ in P4 : jet.Any?, /*4*/ in P5 : jet.Any?, /*5*/ in P6 : jet.Any?, /*6*/ in P7 : jet.Any?, /*7*/ in P8 : jet.Any?, /*8*/ in P9 : jet.Any?, /*9*/ in P10 : jet.Any?, /*10*/ in P11 : jet.Any?, /*11*/ in P12 : jet.Any?, /*12*/ in P13 : jet.Any?, /*13*/ out R : jet.Any?><init>(): jet.Function13<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, R>
    public abstract fun invoke(/*0*/ p1: P1, /*1*/ p2: P2, /*2*/ p3: P3, /*3*/ p4: P4, /*4*/ p5: P5, /*5*/ p6: P6, /*6*/ p7: P7, /*7*/ p8: P8, /*8*/ p9: P9, /*9*/ p10: P10, /*10*/ p11: P11, /*11*/ p12: P12, /*12*/ p13: P13): R
}
public abstract class jet.Function14</*0*/ in P1 : jet.Any?, /*1*/ in P2 : jet.Any?, /*2*/ in P3 : jet.Any?, /*3*/ in P4 : jet.Any?, /*4*/ in P5 : jet.Any?, /*5*/ in P6 : jet.Any?, /*6*/ in P7 : jet.Any?, /*7*/ in P8 : jet.Any?, /*8*/ in P9 : jet.Any?, /*9*/ in P10 : jet.Any?, /*10*/ in P11 : jet.Any?, /*11*/ in P12 : jet.Any?, /*12*/ in P13 : jet.Any?, /*13*/ in P14 : jet.Any?, /*14*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ in P1 : jet.Any?, /*1*/ in P2 : jet.Any?, /*2*/ in P3 : jet.Any?, /*3*/ in P4 : jet.Any?, /*4*/ in P5 : jet.Any?, /*5*/ in P6 : jet.Any?, /*6*/ in P7 : jet.Any?, /*7*/ in P8 : jet.Any?, /*8*/ in P9 : jet.Any?, /*9*/ in P10 : jet.Any?, /*10*/ in P11 : jet.Any?, /*11*/ in P12 : jet.Any?, /*12*/ in P13 : jet.Any?, /*13*/ in P14 : jet.Any?, /*14*/ out R : jet.Any?><init>(): jet.Function14<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, R>
    public abstract fun invoke(/*0*/ p1: P1, /*1*/ p2: P2, /*2*/ p3: P3, /*3*/ p4: P4, /*4*/ p5: P5, /*5*/ p6: P6, /*6*/ p7: P7, /*7*/ p8: P8, /*8*/ p9: P9, /*9*/ p10: P10, /*10*/ p11: P11, /*11*/ p12: P12, /*12*/ p13: P13, /*13*/ p14: P14): R
}
public abstract class jet.Function15</*0*/ in P1 : jet.Any?, /*1*/ in P2 : jet.Any?, /*2*/ in P3 : jet.Any?, /*3*/ in P4 : jet.Any?, /*4*/ in P5 : jet.Any?, /*5*/ in P6 : jet.Any?, /*6*/ in P7 : jet.Any?, /*7*/ in P8 : jet.Any?, /*8*/ in P9 : jet.Any?, /*9*/ in P10 : jet.Any?, /*10*/ in P11 : jet.Any?, /*11*/ in P12 : jet.Any?, /*12*/ in P13 : jet.Any?, /*13*/ in P14 : jet.Any?, /*14*/ in P15 : jet.Any?, /*15*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ in P1 : jet.Any?, /*1*/ in P2 : jet.Any?, /*2*/ in P3 : jet.Any?, /*3*/ in P4 : jet.Any?, /*4*/ in P5 : jet.Any?, /*5*/ in P6 : jet.Any?, /*6*/ in P7 : jet.Any?, /*7*/ in P8 : jet.Any?, /*8*/ in P9 : jet.Any?, /*9*/ in P10 : jet.Any?, /*10*/ in P11 : jet.Any?, /*11*/ in P12 : jet.Any?, /*12*/ in P13 : jet.Any?, /*13*/ in P14 : jet.Any?, /*14*/ in P15 : jet.Any?, /*15*/ out R : jet.Any?><init>(): jet.Function15<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, R>
    public abstract fun invoke(/*0*/ p1: P1, /*1*/ p2: P2, /*2*/ p3: P3, /*3*/ p4: P4, /*4*/ p5: P5, /*5*/ p6: P6, /*6*/ p7: P7, /*7*/ p8: P8, /*8*/ p9: P9, /*9*/ p10: P10, /*10*/ p11: P11, /*11*/ p12: P12, /*12*/ p13: P13, /*13*/ p14: P14, /*14*/ p15: P15): R
}
public abstract class jet.Function16</*0*/ in P1 : jet.Any?, /*1*/ in P2 : jet.Any?, /*2*/ in P3 : jet.Any?, /*3*/ in P4 : jet.Any?, /*4*/ in P5 : jet.Any?, /*5*/ in P6 : jet.Any?, /*6*/ in P7 : jet.Any?, /*7*/ in P8 : jet.Any?, /*8*/ in P9 : jet.Any?, /*9*/ in P10 : jet.Any?, /*10*/ in P11 : jet.Any?, /*11*/ in P12 : jet.Any?, /*12*/ in P13 : jet.Any?, /*13*/ in P14 : jet.Any?, /*14*/ in P15 : jet.Any?, /*15*/ in P16 : jet.Any?, /*16*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ in P1 : jet.Any?, /*1*/ in P2 : jet.Any?, /*2*/ in P3 : jet.Any?, /*3*/ in P4 : jet.Any?, /*4*/ in P5 : jet.Any?, /*5*/ in P6 : jet.Any?, /*6*/ in P7 : jet.Any?, /*7*/ in P8 : jet.Any?, /*8*/ in P9 : jet.Any?, /*9*/ in P10 : jet.Any?, /*10*/ in P11 : jet.Any?, /*11*/ in P12 : jet.Any?, /*12*/ in P13 : jet.Any?, /*13*/ in P14 : jet.Any?, /*14*/ in P15 : jet.Any?, /*15*/ in P16 : jet.Any?, /*16*/ out R : jet.Any?><init>(): jet.Function16<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, R>
    public abstract fun invoke(/*0*/ p1: P1, /*1*/ p2: P2, /*2*/ p3: P3, /*3*/ p4: P4, /*4*/ p5: P5, /*5*/ p6: P6, /*6*/ p7: P7, /*7*/ p8: P8, /*8*/ p9: P9, /*9*/ p10: P10, /*10*/ p11: P11, /*11*/ p12: P12, /*12*/ p13: P13, /*13*/ p14: P14, /*14*/ p15: P15, /*15*/ p16: P16): R
}
public abstract class jet.Function17</*0*/ in P1 : jet.Any?, /*1*/ in P2 : jet.Any?, /*2*/ in P3 : jet.Any?, /*3*/ in P4 : jet.Any?, /*4*/ in P5 : jet.Any?, /*5*/ in P6 : jet.Any?, /*6*/ in P7 : jet.Any?, /*7*/ in P8 : jet.Any?, /*8*/ in P9 : jet.Any?, /*9*/ in P10 : jet.Any?, /*10*/ in P11 : jet.Any?, /*11*/ in P12 : jet.Any?, /*12*/ in P13 : jet.Any?, /*13*/ in P14 : jet.Any?, /*14*/ in P15 : jet.Any?, /*15*/ in P16 : jet.Any?, /*16*/ in P17 : jet.Any?, /*17*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ in P1 : jet.Any?, /*1*/ in P2 : jet.Any?, /*2*/ in P3 : jet.Any?, /*3*/ in P4 : jet.Any?, /*4*/ in P5 : jet.Any?, /*5*/ in P6 : jet.Any?, /*6*/ in P7 : jet.Any?, /*7*/ in P8 : jet.Any?, /*8*/ in P9 : jet.Any?, /*9*/ in P10 : jet.Any?, /*10*/ in P11 : jet.Any?, /*11*/ in P12 : jet.Any?, /*12*/ in P13 : jet.Any?, /*13*/ in P14 : jet.Any?, /*14*/ in P15 : jet.Any?, /*15*/ in P16 : jet.Any?, /*16*/ in P17 : jet.Any?, /*17*/ out R : jet.Any?><init>(): jet.Function17<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, R>
    public abstract fun invoke(/*0*/ p1: P1, /*1*/ p2: P2, /*2*/ p3: P3, /*3*/ p4: P4, /*4*/ p5: P5, /*5*/ p6: P6, /*6*/ p7: P7, /*7*/ p8: P8, /*8*/ p9: P9, /*9*/ p10: P10, /*10*/ p11: P11, /*11*/ p12: P12, /*12*/ p13: P13, /*13*/ p14: P14, /*14*/ p15: P15, /*15*/ p16: P16, /*16*/ p17: P17): R
}
public abstract class jet.Function18</*0*/ in P1 : jet.Any?, /*1*/ in P2 : jet.Any?, /*2*/ in P3 : jet.Any?, /*3*/ in P4 : jet.Any?, /*4*/ in P5 : jet.Any?, /*5*/ in P6 : jet.Any?, /*6*/ in P7 : jet.Any?, /*7*/ in P8 : jet.Any?, /*8*/ in P9 : jet.Any?, /*9*/ in P10 : jet.Any?, /*10*/ in P11 : jet.Any?, /*11*/ in P12 : jet.Any?, /*12*/ in P13 : jet.Any?, /*13*/ in P14 : jet.Any?, /*14*/ in P15 : jet.Any?, /*15*/ in P16 : jet.Any?, /*16*/ in P17 : jet.Any?, /*17*/ in P18 : jet.Any?, /*18*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ in P1 : jet.Any?, /*1*/ in P2 : jet.Any?, /*2*/ in P3 : jet.Any?, /*3*/ in P4 : jet.Any?, /*4*/ in P5 : jet.Any?, /*5*/ in P6 : jet.Any?, /*6*/ in P7 : jet.Any?, /*7*/ in P8 : jet.Any?, /*8*/ in P9 : jet.Any?, /*9*/ in P10 : jet.Any?, /*10*/ in P11 : jet.Any?, /*11*/ in P12 : jet.Any?, /*12*/ in P13 : jet.Any?, /*13*/ in P14 : jet.Any?, /*14*/ in P15 : jet.Any?, /*15*/ in P16 : jet.Any?, /*16*/ in P17 : jet.Any?, /*17*/ in P18 : jet.Any?, /*18*/ out R : jet.Any?><init>(): jet.Function18<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, R>
    public abstract fun invoke(/*0*/ p1: P1, /*1*/ p2: P2, /*2*/ p3: P3, /*3*/ p4: P4, /*4*/ p5: P5, /*5*/ p6: P6, /*6*/ p7: P7, /*7*/ p8: P8, /*8*/ p9: P9, /*9*/ p10: P10, /*10*/ p11: P11, /*11*/ p12: P12, /*12*/ p13: P13, /*13*/ p14: P14, /*14*/ p15: P15, /*15*/ p16: P16, /*16*/ p17: P17, /*17*/ p18: P18): R
}
public abstract class jet.Function19</*0*/ in P1 : jet.Any?, /*1*/ in P2 : jet.Any?, /*2*/ in P3 : jet.Any?, /*3*/ in P4 : jet.Any?, /*4*/ in P5 : jet.Any?, /*5*/ in P6 : jet.Any?, /*6*/ in P7 : jet.Any?, /*7*/ in P8 : jet.Any?, /*8*/ in P9 : jet.Any?, /*9*/ in P10 : jet.Any?, /*10*/ in P11 : jet.Any?, /*11*/ in P12 : jet.Any?, /*12*/ in P13 : jet.Any?, /*13*/ in P14 : jet.Any?, /*14*/ in P15 : jet.Any?, /*15*/ in P16 : jet.Any?, /*16*/ in P17 : jet.Any?, /*17*/ in P18 : jet.Any?, /*18*/ in P19 : jet.Any?, /*19*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ in P1 : jet.Any?, /*1*/ in P2 : jet.Any?, /*2*/ in P3 : jet.Any?, /*3*/ in P4 : jet.Any?, /*4*/ in P5 : jet.Any?, /*5*/ in P6 : jet.Any?, /*6*/ in P7 : jet.Any?, /*7*/ in P8 : jet.Any?, /*8*/ in P9 : jet.Any?, /*9*/ in P10 : jet.Any?, /*10*/ in P11 : jet.Any?, /*11*/ in P12 : jet.Any?, /*12*/ in P13 : jet.Any?, /*13*/ in P14 : jet.Any?, /*14*/ in P15 : jet.Any?, /*15*/ in P16 : jet.Any?, /*16*/ in P17 : jet.Any?, /*17*/ in P18 : jet.Any?, /*18*/ in P19 : jet.Any?, /*19*/ out R : jet.Any?><init>(): jet.Function19<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, R>
    public abstract fun invoke(/*0*/ p1: P1, /*1*/ p2: P2, /*2*/ p3: P3, /*3*/ p4: P4, /*4*/ p5: P5, /*5*/ p6: P6, /*6*/ p7: P7, /*7*/ p8: P8, /*8*/ p9: P9, /*9*/ p10: P10, /*10*/ p11: P11, /*11*/ p12: P12, /*12*/ p13: P13, /*13*/ p14: P14, /*14*/ p15: P15, /*15*/ p16: P16, /*16*/ p17: P17, /*17*/ p18: P18, /*18*/ p19: P19): R
}
public abstract class jet.Function2</*0*/ in P1 : jet.Any?, /*1*/ in P2 : jet.Any?, /*2*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ in P1 : jet.Any?, /*1*/ in P2 : jet.Any?, /*2*/ out R : jet.Any?><init>(): jet.Function2<P1, P2, R>
    public abstract fun invoke(/*0*/ p1: P1, /*1*/ p2: P2): R
}
public abstract class jet.Function20</*0*/ in P1 : jet.Any?, /*1*/ in P2 : jet.Any?, /*2*/ in P3 : jet.Any?, /*3*/ in P4 : jet.Any?, /*4*/ in P5 : jet.Any?, /*5*/ in P6 : jet.Any?, /*6*/ in P7 : jet.Any?, /*7*/ in P8 : jet.Any?, /*8*/ in P9 : jet.Any?, /*9*/ in P10 : jet.Any?, /*10*/ in P11 : jet.Any?, /*11*/ in P12 : jet.Any?, /*12*/ in P13 : jet.Any?, /*13*/ in P14 : jet.Any?, /*14*/ in P15 : jet.Any?, /*15*/ in P16 : jet.Any?, /*16*/ in P17 : jet.Any?, /*17*/ in P18 : jet.Any?, /*18*/ in P19 : jet.Any?, /*19*/ in P20 : jet.Any?, /*20*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ in P1 : jet.Any?, /*1*/ in P2 : jet.Any?, /*2*/ in P3 : jet.Any?, /*3*/ in P4 : jet.Any?, /*4*/ in P5 : jet.Any?, /*5*/ in P6 : jet.Any?, /*6*/ in P7 : jet.Any?, /*7*/ in P8 : jet.Any?, /*8*/ in P9 : jet.Any?, /*9*/ in P10 : jet.Any?, /*10*/ in P11 : jet.Any?, /*11*/ in P12 : jet.Any?, /*12*/ in P13 : jet.Any?, /*13*/ in P14 : jet.Any?, /*14*/ in P15 : jet.Any?, /*15*/ in P16 : jet.Any?, /*16*/ in P17 : jet.Any?, /*17*/ in P18 : jet.Any?, /*18*/ in P19 : jet.Any?, /*19*/ in P20 : jet.Any?, /*20*/ out R : jet.Any?><init>(): jet.Function20<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, R>
    public abstract fun invoke(/*0*/ p1: P1, /*1*/ p2: P2, /*2*/ p3: P3, /*3*/ p4: P4, /*4*/ p5: P5, /*5*/ p6: P6, /*6*/ p7: P7, /*7*/ p8: P8, /*8*/ p9: P9, /*9*/ p10: P10, /*10*/ p11: P11, /*11*/ p12: P12, /*12*/ p13: P13, /*13*/ p14: P14, /*14*/ p15: P15, /*15*/ p16: P16, /*16*/ p17: P17, /*17*/ p18: P18, /*18*/ p19: P19, /*19*/ p20: P20): R
}
public abstract class jet.Function21</*0*/ in P1 : jet.Any?, /*1*/ in P2 : jet.Any?, /*2*/ in P3 : jet.Any?, /*3*/ in P4 : jet.Any?, /*4*/ in P5 : jet.Any?, /*5*/ in P6 : jet.Any?, /*6*/ in P7 : jet.Any?, /*7*/ in P8 : jet.Any?, /*8*/ in P9 : jet.Any?, /*9*/ in P10 : jet.Any?, /*10*/ in P11 : jet.Any?, /*11*/ in P12 : jet.Any?, /*12*/ in P13 : jet.Any?, /*13*/ in P14 : jet.Any?, /*14*/ in P15 : jet.Any?, /*15*/ in P16 : jet.Any?, /*16*/ in P17 : jet.Any?, /*17*/ in P18 : jet.Any?, /*18*/ in P19 : jet.Any?, /*19*/ in P20 : jet.Any?, /*20*/ in P21 : jet.Any?, /*21*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ in P1 : jet.Any?, /*1*/ in P2 : jet.Any?, /*2*/ in P3 : jet.Any?, /*3*/ in P4 : jet.Any?, /*4*/ in P5 : jet.Any?, /*5*/ in P6 : jet.Any?, /*6*/ in P7 : jet.Any?, /*7*/ in P8 : jet.Any?, /*8*/ in P9 : jet.Any?, /*9*/ in P10 : jet.Any?, /*10*/ in P11 : jet.Any?, /*11*/ in P12 : jet.Any?, /*12*/ in P13 : jet.Any?, /*13*/ in P14 : jet.Any?, /*14*/ in P15 : jet.Any?, /*15*/ in P16 : jet.Any?, /*16*/ in P17 : jet.Any?, /*17*/ in P18 : jet.Any?, /*18*/ in P19 : jet.Any?, /*19*/ in P20 : jet.Any?, /*20*/ in P21 : jet.Any?, /*21*/ out R : jet.Any?><init>(): jet.Function21<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, R>
    public abstract fun invoke(/*0*/ p1: P1, /*1*/ p2: P2, /*2*/ p3: P3, /*3*/ p4: P4, /*4*/ p5: P5, /*5*/ p6: P6, /*6*/ p7: P7, /*7*/ p8: P8, /*8*/ p9: P9, /*9*/ p10: P10, /*10*/ p11: P11, /*11*/ p12: P12, /*12*/ p13: P13, /*13*/ p14: P14, /*14*/ p15: P15, /*15*/ p16: P16, /*16*/ p17: P17, /*17*/ p18: P18, /*18*/ p19: P19, /*19*/ p20: P20, /*20*/ p21: P21): R
}
public abstract class jet.Function22</*0*/ in P1 : jet.Any?, /*1*/ in P2 : jet.Any?, /*2*/ in P3 : jet.Any?, /*3*/ in P4 : jet.Any?, /*4*/ in P5 : jet.Any?, /*5*/ in P6 : jet.Any?, /*6*/ in P7 : jet.Any?, /*7*/ in P8 : jet.Any?, /*8*/ in P9 : jet.Any?, /*9*/ in P10 : jet.Any?, /*10*/ in P11 : jet.Any?, /*11*/ in P12 : jet.Any?, /*12*/ in P13 : jet.Any?, /*13*/ in P14 : jet.Any?, /*14*/ in P15 : jet.Any?, /*15*/ in P16 : jet.Any?, /*16*/ in P17 : jet.Any?, /*17*/ in P18 : jet.Any?, /*18*/ in P19 : jet.Any?, /*19*/ in P20 : jet.Any?, /*20*/ in P21 : jet.Any?, /*21*/ in P22 : jet.Any?, /*22*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ in P1 : jet.Any?, /*1*/ in P2 : jet.Any?, /*2*/ in P3 : jet.Any?, /*3*/ in P4 : jet.Any?, /*4*/ in P5 : jet.Any?, /*5*/ in P6 : jet.Any?, /*6*/ in P7 : jet.Any?, /*7*/ in P8 : jet.Any?, /*8*/ in P9 : jet.Any?, /*9*/ in P10 : jet.Any?, /*10*/ in P11 : jet.Any?, /*11*/ in P12 : jet.Any?, /*12*/ in P13 : jet.Any?, /*13*/ in P14 : jet.Any?, /*14*/ in P15 : jet.Any?, /*15*/ in P16 : jet.Any?, /*16*/ in P17 : jet.Any?, /*17*/ in P18 : jet.Any?, /*18*/ in P19 : jet.Any?, /*19*/ in P20 : jet.Any?, /*20*/ in P21 : jet.Any?, /*21*/ in P22 : jet.Any?, /*22*/ out R : jet.Any?><init>(): jet.Function22<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, R>
    public abstract fun invoke(/*0*/ p1: P1, /*1*/ p2: P2, /*2*/ p3: P3, /*3*/ p4: P4, /*4*/ p5: P5, /*5*/ p6: P6, /*6*/ p7: P7, /*7*/ p8: P8, /*8*/ p9: P9, /*9*/ p10: P10, /*10*/ p11: P11, /*11*/ p12: P12, /*12*/ p13: P13, /*13*/ p14: P14, /*14*/ p15: P15, /*15*/ p16: P16, /*16*/ p17: P17, /*17*/ p18: P18, /*18*/ p19: P19, /*19*/ p20: P20, /*20*/ p21: P21, /*21*/ p22: P22): R
}
public abstract class jet.Function3</*0*/ in P1 : jet.Any?, /*1*/ in P2 : jet.Any?, /*2*/ in P3 : jet.Any?, /*3*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ in P1 : jet.Any?, /*1*/ in P2 : jet.Any?, /*2*/ in P3 : jet.Any?, /*3*/ out R : jet.Any?><init>(): jet.Function3<P1, P2, P3, R>
    public abstract fun invoke(/*0*/ p1: P1, /*1*/ p2: P2, /*2*/ p3: P3): R
}
public abstract class jet.Function4</*0*/ in P1 : jet.Any?, /*1*/ in P2 : jet.Any?, /*2*/ in P3 : jet.Any?, /*3*/ in P4 : jet.Any?, /*4*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ in P1 : jet.Any?, /*1*/ in P2 : jet.Any?, /*2*/ in P3 : jet.Any?, /*3*/ in P4 : jet.Any?, /*4*/ out R : jet.Any?><init>(): jet.Function4<P1, P2, P3, P4, R>
    public abstract fun invoke(/*0*/ p1: P1, /*1*/ p2: P2, /*2*/ p3: P3, /*3*/ p4: P4): R
}
public abstract class jet.Function5</*0*/ in P1 : jet.Any?, /*1*/ in P2 : jet.Any?, /*2*/ in P3 : jet.Any?, /*3*/ in P4 : jet.Any?, /*4*/ in P5 : jet.Any?, /*5*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ in P1 : jet.Any?, /*1*/ in P2 : jet.Any?, /*2*/ in P3 : jet.Any?, /*3*/ in P4 : jet.Any?, /*4*/ in P5 : jet.Any?, /*5*/ out R : jet.Any?><init>(): jet.Function5<P1, P2, P3, P4, P5, R>
    public abstract fun invoke(/*0*/ p1: P1, /*1*/ p2: P2, /*2*/ p3: P3, /*3*/ p4: P4, /*4*/ p5: P5): R
}
public abstract class jet.Function6</*0*/ in P1 : jet.Any?, /*1*/ in P2 : jet.Any?, /*2*/ in P3 : jet.Any?, /*3*/ in P4 : jet.Any?, /*4*/ in P5 : jet.Any?, /*5*/ in P6 : jet.Any?, /*6*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ in P1 : jet.Any?, /*1*/ in P2 : jet.Any?, /*2*/ in P3 : jet.Any?, /*3*/ in P4 : jet.Any?, /*4*/ in P5 : jet.Any?, /*5*/ in P6 : jet.Any?, /*6*/ out R : jet.Any?><init>(): jet.Function6<P1, P2, P3, P4, P5, P6, R>
    public abstract fun invoke(/*0*/ p1: P1, /*1*/ p2: P2, /*2*/ p3: P3, /*3*/ p4: P4, /*4*/ p5: P5, /*5*/ p6: P6): R
}
public abstract class jet.Function7</*0*/ in P1 : jet.Any?, /*1*/ in P2 : jet.Any?, /*2*/ in P3 : jet.Any?, /*3*/ in P4 : jet.Any?, /*4*/ in P5 : jet.Any?, /*5*/ in P6 : jet.Any?, /*6*/ in P7 : jet.Any?, /*7*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ in P1 : jet.Any?, /*1*/ in P2 : jet.Any?, /*2*/ in P3 : jet.Any?, /*3*/ in P4 : jet.Any?, /*4*/ in P5 : jet.Any?, /*5*/ in P6 : jet.Any?, /*6*/ in P7 : jet.Any?, /*7*/ out R : jet.Any?><init>(): jet.Function7<P1, P2, P3, P4, P5, P6, P7, R>
    public abstract fun invoke(/*0*/ p1: P1, /*1*/ p2: P2, /*2*/ p3: P3, /*3*/ p4: P4, /*4*/ p5: P5, /*5*/ p6: P6, /*6*/ p7: P7): R
}
public abstract class jet.Function8</*0*/ in P1 : jet.Any?, /*1*/ in P2 : jet.Any?, /*2*/ in P3 : jet.Any?, /*3*/ in P4 : jet.Any?, /*4*/ in P5 : jet.Any?, /*5*/ in P6 : jet.Any?, /*6*/ in P7 : jet.Any?, /*7*/ in P8 : jet.Any?, /*8*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ in P1 : jet.Any?, /*1*/ in P2 : jet.Any?, /*2*/ in P3 : jet.Any?, /*3*/ in P4 : jet.Any?, /*4*/ in P5 : jet.Any?, /*5*/ in P6 : jet.Any?, /*6*/ in P7 : jet.Any?, /*7*/ in P8 : jet.Any?, /*8*/ out R : jet.Any?><init>(): jet.Function8<P1, P2, P3, P4, P5, P6, P7, P8, R>
    public abstract fun invoke(/*0*/ p1: P1, /*1*/ p2: P2, /*2*/ p3: P3, /*3*/ p4: P4, /*4*/ p5: P5, /*5*/ p6: P6, /*6*/ p7: P7, /*7*/ p8: P8): R
}
public abstract class jet.Function9</*0*/ in P1 : jet.Any?, /*1*/ in P2 : jet.Any?, /*2*/ in P3 : jet.Any?, /*3*/ in P4 : jet.Any?, /*4*/ in P5 : jet.Any?, /*5*/ in P6 : jet.Any?, /*6*/ in P7 : jet.Any?, /*7*/ in P8 : jet.Any?, /*8*/ in P9 : jet.Any?, /*9*/ out R : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ in P1 : jet.Any?, /*1*/ in P2 : jet.Any?, /*2*/ in P3 : jet.Any?, /*3*/ in P4 : jet.Any?, /*4*/ in P5 : jet.Any?, /*5*/ in P6 : jet.Any?, /*6*/ in P7 : jet.Any?, /*7*/ in P8 : jet.Any?, /*8*/ in P9 : jet.Any?, /*9*/ out R : jet.Any?><init>(): jet.Function9<P1, P2, P3, P4, P5, P6, P7, P8, P9, R>
    public abstract fun invoke(/*0*/ p1: P1, /*1*/ p2: P2, /*2*/ p3: P3, /*3*/ p4: P4, /*4*/ p5: P5, /*5*/ p6: P6, /*6*/ p7: P7, /*7*/ p8: P8, /*8*/ p9: P9): R
}
public abstract trait jet.Hashable : jet.Any {
    public abstract fun equals(/*0*/ other: jet.Any?): jet.Boolean
    public abstract fun hashCode(): jet.Int
}
public final class jet.Int : jet.Number, jet.Comparable<jet.Int> {
    public final /*constructor*/ fun <init>(): jet.Int
    public final fun and(/*0*/ other: jet.Int): jet.Int
    public final fun compareTo(/*0*/ other: jet.Byte): jet.Int
    public final fun compareTo(/*0*/ other: jet.Char): jet.Int
    public final fun compareTo(/*0*/ other: jet.Double): jet.Int
    public final fun compareTo(/*0*/ other: jet.Float): jet.Int
    public open override /*1*/ fun compareTo(/*0*/ other: jet.Int): jet.Int
    public final fun compareTo(/*0*/ other: jet.Long): jet.Int
    public final fun compareTo(/*0*/ other: jet.Short): jet.Int
    public final fun dec(): jet.Int
    public final fun div(/*0*/ other: jet.Byte): jet.Int
    public final fun div(/*0*/ other: jet.Char): jet.Int
    public final fun div(/*0*/ other: jet.Double): jet.Double
    public final fun div(/*0*/ other: jet.Float): jet.Float
    public final fun div(/*0*/ other: jet.Int): jet.Int
    public final fun div(/*0*/ other: jet.Long): jet.Long
    public final fun div(/*0*/ other: jet.Short): jet.Int
    public final fun downto(/*0*/ other: jet.Byte): jet.IntRange
    public final fun downto(/*0*/ other: jet.Char): jet.IntRange
    public final fun downto(/*0*/ other: jet.Double): jet.DoubleRange
    public final fun downto(/*0*/ other: jet.Float): jet.FloatRange
    public final fun downto(/*0*/ other: jet.Int): jet.IntRange
    public final fun downto(/*0*/ other: jet.Long): jet.LongRange
    public final fun downto(/*0*/ other: jet.Short): jet.IntRange
    public open override /*1*/ fun equals(/*0*/ other: jet.Any?): jet.Boolean
    public open override /*1*/ fun hashCode(): jet.Int
    public final fun inc(): jet.Int
    public final fun inv(): jet.Int
    public final fun minus(): jet.Int
    public final fun minus(/*0*/ other: jet.Byte): jet.Int
    public final fun minus(/*0*/ other: jet.Char): jet.Int
    public final fun minus(/*0*/ other: jet.Double): jet.Double
    public final fun minus(/*0*/ other: jet.Float): jet.Float
    public final fun minus(/*0*/ other: jet.Int): jet.Int
    public final fun minus(/*0*/ other: jet.Long): jet.Long
    public final fun minus(/*0*/ other: jet.Short): jet.Int
    public final fun mod(/*0*/ other: jet.Byte): jet.Int
    public final fun mod(/*0*/ other: jet.Char): jet.Int
    public final fun mod(/*0*/ other: jet.Double): jet.Double
    public final fun mod(/*0*/ other: jet.Float): jet.Float
    public final fun mod(/*0*/ other: jet.Int): jet.Int
    public final fun mod(/*0*/ other: jet.Long): jet.Long
    public final fun mod(/*0*/ other: jet.Short): jet.Int
    public final fun or(/*0*/ other: jet.Int): jet.Int
    public final fun plus(): jet.Int
    public final fun plus(/*0*/ other: jet.Byte): jet.Int
    public final fun plus(/*0*/ other: jet.Char): jet.Int
    public final fun plus(/*0*/ other: jet.Double): jet.Double
    public final fun plus(/*0*/ other: jet.Float): jet.Float
    public final fun plus(/*0*/ other: jet.Int): jet.Int
    public final fun plus(/*0*/ other: jet.Long): jet.Long
    public final fun plus(/*0*/ other: jet.Short): jet.Int
    public final fun rangeTo(/*0*/ other: jet.Byte): jet.IntRange
    public final fun rangeTo(/*0*/ other: jet.Char): jet.IntRange
    public final fun rangeTo(/*0*/ other: jet.Double): jet.DoubleRange
    public final fun rangeTo(/*0*/ other: jet.Float): jet.FloatRange
    public final fun rangeTo(/*0*/ other: jet.Int): jet.IntRange
    public final fun rangeTo(/*0*/ other: jet.Long): jet.LongRange
    public final fun rangeTo(/*0*/ other: jet.Short): jet.IntRange
    public final fun shl(/*0*/ bits: jet.Int): jet.Int
    public final fun shr(/*0*/ bits: jet.Int): jet.Int
    public final fun times(/*0*/ other: jet.Byte): jet.Int
    public final fun times(/*0*/ other: jet.Char): jet.Int
    public final fun times(/*0*/ other: jet.Double): jet.Double
    public final fun times(/*0*/ other: jet.Float): jet.Float
    public final fun times(/*0*/ other: jet.Int): jet.Int
    public final fun times(/*0*/ other: jet.Long): jet.Long
    public final fun times(/*0*/ other: jet.Short): jet.Int
    public open override /*1*/ fun toByte(): jet.Byte
    public open override /*1*/ fun toChar(): jet.Char
    public open override /*1*/ fun toDouble(): jet.Double
    public open override /*1*/ fun toFloat(): jet.Float
    public open override /*1*/ fun toInt(): jet.Int
    public open override /*1*/ fun toLong(): jet.Long
    public open override /*1*/ fun toShort(): jet.Short
    public final fun upto(/*0*/ other: jet.Byte): jet.IntRange
    public final fun upto(/*0*/ other: jet.Char): jet.IntRange
    public final fun upto(/*0*/ other: jet.Double): jet.DoubleRange
    public final fun upto(/*0*/ other: jet.Float): jet.FloatRange
    public final fun upto(/*0*/ other: jet.Int): jet.IntRange
    public final fun upto(/*0*/ other: jet.Long): jet.LongRange
    public final fun upto(/*0*/ other: jet.Short): jet.IntRange
    public final fun ushr(/*0*/ bits: jet.Int): jet.Int
    public final fun xor(/*0*/ other: jet.Int): jet.Int
}
public final class jet.IntArray : jet.Any {
    public final /*constructor*/ fun <init>(/*0*/ size: jet.Int): jet.IntArray
    public final fun get(/*0*/ index: jet.Int): jet.Int
    public final val indices: jet.IntRange
    public final fun iterator(): jet.IntIterator
    public final fun set(/*0*/ index: jet.Int, /*1*/ value: jet.Int): jet.Tuple0
    public final val size: jet.Int
}
public abstract trait jet.IntIterable : jet.Iterable<jet.Int> {
    public abstract override /*1*/ fun iterator(): jet.IntIterator
}
public abstract class jet.IntIterator : jet.Iterator<jet.Int> {
    public final /*constructor*/ fun <init>(): jet.IntIterator
    public abstract override /*1*/ val hasNext: jet.Boolean
    public open override /*1*/ fun next(): jet.Int
    public abstract fun nextInt(): jet.Int
}
public final class jet.IntRange : jet.Range<jet.Int>, jet.IntIterable {
    public final /*constructor*/ fun <init>(/*0*/ start: jet.Int, /*1*/ size: jet.Int): jet.IntRange
    public open override /*1*/ fun contains(/*0*/ elem: jet.Int): jet.Boolean
    public final val end: jet.Int
    public final val isReversed: jet.Boolean
    public open override /*1*/ fun iterator(): jet.IntIterator
    public final val iteratorStart: jet.Int
    public final fun minus(): jet.IntRange
    public final val size: jet.Int
    public final val start: jet.Int
    public final fun step(/*0*/ step: jet.Int): jet.IntIterator
}
public abstract trait jet.Iterable</*0*/ out T : jet.Any?> : jet.Any {
    public abstract fun iterator(): jet.Iterator<T>
}
public abstract trait jet.Iterator</*0*/ out T : jet.Any?> : jet.Any {
    public abstract val hasNext: jet.Boolean
    public abstract fun next(): T
}
public final class jet.Long : jet.Number, jet.Comparable<jet.Long> {
    public final /*constructor*/ fun <init>(): jet.Long
    public final fun and(/*0*/ other: jet.Long): jet.Long
    public final fun compareTo(/*0*/ other: jet.Byte): jet.Int
    public final fun compareTo(/*0*/ other: jet.Char): jet.Int
    public final fun compareTo(/*0*/ other: jet.Double): jet.Int
    public final fun compareTo(/*0*/ other: jet.Float): jet.Int
    public final fun compareTo(/*0*/ other: jet.Int): jet.Int
    public open override /*1*/ fun compareTo(/*0*/ other: jet.Long): jet.Int
    public final fun compareTo(/*0*/ other: jet.Short): jet.Int
    public final fun dec(): jet.Long
    public final fun div(/*0*/ other: jet.Byte): jet.Long
    public final fun div(/*0*/ other: jet.Char): jet.Long
    public final fun div(/*0*/ other: jet.Double): jet.Double
    public final fun div(/*0*/ other: jet.Float): jet.Float
    public final fun div(/*0*/ other: jet.Int): jet.Long
    public final fun div(/*0*/ other: jet.Long): jet.Long
    public final fun div(/*0*/ other: jet.Short): jet.Long
    public final fun downto(/*0*/ other: jet.Byte): jet.LongRange
    public final fun downto(/*0*/ other: jet.Char): jet.LongRange
    public final fun downto(/*0*/ other: jet.Double): jet.DoubleRange
    public final fun downto(/*0*/ other: jet.Float): jet.FloatRange
    public final fun downto(/*0*/ other: jet.Int): jet.LongRange
    public final fun downto(/*0*/ other: jet.Long): jet.LongRange
    public final fun downto(/*0*/ other: jet.Short): jet.LongRange
    public open override /*1*/ fun equals(/*0*/ other: jet.Any?): jet.Boolean
    public open override /*1*/ fun hashCode(): jet.Int
    public final fun inc(): jet.Long
    public final fun inv(): jet.Long
    public final fun minus(): jet.Long
    public final fun minus(/*0*/ other: jet.Byte): jet.Long
    public final fun minus(/*0*/ other: jet.Char): jet.Long
    public final fun minus(/*0*/ other: jet.Double): jet.Double
    public final fun minus(/*0*/ other: jet.Float): jet.Float
    public final fun minus(/*0*/ other: jet.Int): jet.Long
    public final fun minus(/*0*/ other: jet.Long): jet.Long
    public final fun minus(/*0*/ other: jet.Short): jet.Long
    public final fun mod(/*0*/ other: jet.Byte): jet.Long
    public final fun mod(/*0*/ other: jet.Char): jet.Long
    public final fun mod(/*0*/ other: jet.Double): jet.Double
    public final fun mod(/*0*/ other: jet.Float): jet.Float
    public final fun mod(/*0*/ other: jet.Int): jet.Long
    public final fun mod(/*0*/ other: jet.Long): jet.Long
    public final fun mod(/*0*/ other: jet.Short): jet.Long
    public final fun or(/*0*/ other: jet.Long): jet.Long
    public final fun plus(): jet.Long
    public final fun plus(/*0*/ other: jet.Byte): jet.Long
    public final fun plus(/*0*/ other: jet.Char): jet.Long
    public final fun plus(/*0*/ other: jet.Double): jet.Double
    public final fun plus(/*0*/ other: jet.Float): jet.Float
    public final fun plus(/*0*/ other: jet.Int): jet.Long
    public final fun plus(/*0*/ other: jet.Long): jet.Long
    public final fun plus(/*0*/ other: jet.Short): jet.Long
    public final fun rangeTo(/*0*/ other: jet.Byte): jet.LongRange
    public final fun rangeTo(/*0*/ other: jet.Char): jet.LongRange
    public final fun rangeTo(/*0*/ other: jet.Double): jet.DoubleRange
    public final fun rangeTo(/*0*/ other: jet.Float): jet.FloatRange
    public final fun rangeTo(/*0*/ other: jet.Int): jet.LongRange
    public final fun rangeTo(/*0*/ other: jet.Long): jet.LongRange
    public final fun rangeTo(/*0*/ other: jet.Short): jet.LongRange
    public final fun shl(/*0*/ bits: jet.Int): jet.Long
    public final fun shr(/*0*/ bits: jet.Int): jet.Long
    public final fun times(/*0*/ other: jet.Byte): jet.Long
    public final fun times(/*0*/ other: jet.Char): jet.Long
    public final fun times(/*0*/ other: jet.Double): jet.Double
    public final fun times(/*0*/ other: jet.Float): jet.Float
    public final fun times(/*0*/ other: jet.Int): jet.Long
    public final fun times(/*0*/ other: jet.Long): jet.Long
    public final fun times(/*0*/ other: jet.Short): jet.Long
    public open override /*1*/ fun toByte(): jet.Byte
    public open override /*1*/ fun toChar(): jet.Char
    public open override /*1*/ fun toDouble(): jet.Double
    public open override /*1*/ fun toFloat(): jet.Float
    public open override /*1*/ fun toInt(): jet.Int
    public open override /*1*/ fun toLong(): jet.Long
    public open override /*1*/ fun toShort(): jet.Short
    public final fun upto(/*0*/ other: jet.Byte): jet.LongRange
    public final fun upto(/*0*/ other: jet.Char): jet.LongRange
    public final fun upto(/*0*/ other: jet.Double): jet.DoubleRange
    public final fun upto(/*0*/ other: jet.Float): jet.FloatRange
    public final fun upto(/*0*/ other: jet.Int): jet.LongRange
    public final fun upto(/*0*/ other: jet.Long): jet.LongRange
    public final fun upto(/*0*/ other: jet.Short): jet.LongRange
    public final fun ushr(/*0*/ bits: jet.Int): jet.Long
    public final fun xor(/*0*/ other: jet.Long): jet.Long
}
public final class jet.LongArray : jet.Any {
    public final /*constructor*/ fun <init>(/*0*/ size: jet.Int): jet.LongArray
    public final fun get(/*0*/ index: jet.Int): jet.Long
    public final val indices: jet.IntRange
    public final fun iterator(): jet.LongIterator
    public final fun set(/*0*/ index: jet.Int, /*1*/ value: jet.Long): jet.Tuple0
    public final val size: jet.Int
}
public abstract trait jet.LongIterable : jet.Iterable<jet.Long> {
    public abstract override /*1*/ fun iterator(): jet.LongIterator
}
public abstract class jet.LongIterator : jet.Iterator<jet.Long> {
    public final /*constructor*/ fun <init>(): jet.LongIterator
    public abstract override /*1*/ val hasNext: jet.Boolean
    public open override /*1*/ fun next(): jet.Long
    public abstract fun nextLong(): jet.Long
}
public final class jet.LongRange : jet.Range<jet.Long>, jet.LongIterable {
    public final /*constructor*/ fun <init>(/*0*/ start: jet.Long, /*1*/ size: jet.Long): jet.LongRange
    public open override /*1*/ fun contains(/*0*/ elem: jet.Long): jet.Boolean
    public final val end: jet.Long
    public final val isReversed: jet.Boolean
    public open override /*1*/ fun iterator(): jet.LongIterator
    public final val iteratorStart: jet.Long
    public final fun minus(): jet.LongRange
    public final val size: jet.Long
    public final val start: jet.Long
    public final fun step(/*0*/ step: jet.Long): jet.LongIterator
}
public final class jet.Nothing {
    private final /*constructor*/ fun <init>(): jet.Nothing
}
public abstract class jet.Number : jet.Hashable {
    public final /*constructor*/ fun <init>(): jet.Number
    public abstract override /*1*/ fun equals(/*0*/ other: jet.Any?): jet.Boolean
    public abstract override /*1*/ fun hashCode(): jet.Int
    public abstract fun toByte(): jet.Byte
    public abstract fun toChar(): jet.Char
    public abstract fun toDouble(): jet.Double
    public abstract fun toFloat(): jet.Float
    public abstract fun toInt(): jet.Int
    public abstract fun toLong(): jet.Long
    public abstract fun toShort(): jet.Short
}
public abstract trait jet.Range</*0*/ in T : jet.Comparable<T>> : jet.Any {
    public abstract fun contains(/*0*/ item: T): jet.Boolean
}
public final class jet.Short : jet.Number, jet.Comparable<jet.Short> {
    public final /*constructor*/ fun <init>(): jet.Short
    public final fun compareTo(/*0*/ other: jet.Byte): jet.Int
    public final fun compareTo(/*0*/ other: jet.Char): jet.Int
    public final fun compareTo(/*0*/ other: jet.Double): jet.Int
    public final fun compareTo(/*0*/ other: jet.Float): jet.Int
    public final fun compareTo(/*0*/ other: jet.Int): jet.Int
    public final fun compareTo(/*0*/ other: jet.Long): jet.Int
    public open override /*1*/ fun compareTo(/*0*/ other: jet.Short): jet.Int
    public final fun dec(): jet.Short
    public final fun div(/*0*/ other: jet.Byte): jet.Int
    public final fun div(/*0*/ other: jet.Char): jet.Int
    public final fun div(/*0*/ other: jet.Double): jet.Double
    public final fun div(/*0*/ other: jet.Float): jet.Float
    public final fun div(/*0*/ other: jet.Int): jet.Int
    public final fun div(/*0*/ other: jet.Long): jet.Long
    public final fun div(/*0*/ other: jet.Short): jet.Int
    public final fun downto(/*0*/ other: jet.Byte): jet.ShortRange
    public final fun downto(/*0*/ other: jet.Char): jet.ShortRange
    public final fun downto(/*0*/ other: jet.Double): jet.DoubleRange
    public final fun downto(/*0*/ other: jet.Float): jet.FloatRange
    public final fun downto(/*0*/ other: jet.Int): jet.IntRange
    public final fun downto(/*0*/ other: jet.Long): jet.LongRange
    public final fun downto(/*0*/ other: jet.Short): jet.ShortRange
    public open override /*1*/ fun equals(/*0*/ other: jet.Any?): jet.Boolean
    public open override /*1*/ fun hashCode(): jet.Int
    public final fun inc(): jet.Short
    public final fun minus(): jet.Short
    public final fun minus(/*0*/ other: jet.Byte): jet.Int
    public final fun minus(/*0*/ other: jet.Char): jet.Int
    public final fun minus(/*0*/ other: jet.Double): jet.Double
    public final fun minus(/*0*/ other: jet.Float): jet.Float
    public final fun minus(/*0*/ other: jet.Int): jet.Int
    public final fun minus(/*0*/ other: jet.Long): jet.Long
    public final fun minus(/*0*/ other: jet.Short): jet.Int
    public final fun mod(/*0*/ other: jet.Byte): jet.Int
    public final fun mod(/*0*/ other: jet.Char): jet.Int
    public final fun mod(/*0*/ other: jet.Double): jet.Double
    public final fun mod(/*0*/ other: jet.Float): jet.Float
    public final fun mod(/*0*/ other: jet.Int): jet.Int
    public final fun mod(/*0*/ other: jet.Long): jet.Long
    public final fun mod(/*0*/ other: jet.Short): jet.Int
    public final fun plus(): jet.Short
    public final fun plus(/*0*/ other: jet.Byte): jet.Int
    public final fun plus(/*0*/ other: jet.Char): jet.Int
    public final fun plus(/*0*/ other: jet.Double): jet.Double
    public final fun plus(/*0*/ other: jet.Float): jet.Float
    public final fun plus(/*0*/ other: jet.Int): jet.Int
    public final fun plus(/*0*/ other: jet.Long): jet.Long
    public final fun plus(/*0*/ other: jet.Short): jet.Int
    public final fun rangeTo(/*0*/ other: jet.Byte): jet.ShortRange
    public final fun rangeTo(/*0*/ other: jet.Char): jet.ShortRange
    public final fun rangeTo(/*0*/ other: jet.Double): jet.DoubleRange
    public final fun rangeTo(/*0*/ other: jet.Float): jet.FloatRange
    public final fun rangeTo(/*0*/ other: jet.Int): jet.IntRange
    public final fun rangeTo(/*0*/ other: jet.Long): jet.LongRange
    public final fun rangeTo(/*0*/ other: jet.Short): jet.ShortRange
    public final fun times(/*0*/ other: jet.Byte): jet.Int
    public final fun times(/*0*/ other: jet.Char): jet.Int
    public final fun times(/*0*/ other: jet.Double): jet.Double
    public final fun times(/*0*/ other: jet.Float): jet.Float
    public final fun times(/*0*/ other: jet.Int): jet.Int
    public final fun times(/*0*/ other: jet.Long): jet.Long
    public final fun times(/*0*/ other: jet.Short): jet.Int
    public open override /*1*/ fun toByte(): jet.Byte
    public open override /*1*/ fun toChar(): jet.Char
    public open override /*1*/ fun toDouble(): jet.Double
    public open override /*1*/ fun toFloat(): jet.Float
    public open override /*1*/ fun toInt(): jet.Int
    public open override /*1*/ fun toLong(): jet.Long
    public open override /*1*/ fun toShort(): jet.Short
    public final fun upto(/*0*/ other: jet.Byte): jet.ShortRange
    public final fun upto(/*0*/ other: jet.Char): jet.ShortRange
    public final fun upto(/*0*/ other: jet.Double): jet.DoubleRange
    public final fun upto(/*0*/ other: jet.Float): jet.FloatRange
    public final fun upto(/*0*/ other: jet.Int): jet.IntRange
    public final fun upto(/*0*/ other: jet.Long): jet.LongRange
    public final fun upto(/*0*/ other: jet.Short): jet.ShortRange
}
public final class jet.ShortArray : jet.Any {
    public final /*constructor*/ fun <init>(/*0*/ size: jet.Int): jet.ShortArray
    public final fun get(/*0*/ index: jet.Int): jet.Short
    public final val indices: jet.IntRange
    public final fun iterator(): jet.ShortIterator
    public final fun set(/*0*/ index: jet.Int, /*1*/ value: jet.Short): jet.Tuple0
    public final val size: jet.Int
}
public abstract trait jet.ShortIterable : jet.Iterable<jet.Short> {
    public abstract override /*1*/ fun iterator(): jet.ShortIterator
}
public abstract class jet.ShortIterator : jet.Iterator<jet.Short> {
    public final /*constructor*/ fun <init>(): jet.ShortIterator
    public abstract override /*1*/ val hasNext: jet.Boolean
    public open override /*1*/ fun next(): jet.Short
    public abstract fun nextShort(): jet.Short
}
public final class jet.ShortRange : jet.Range<jet.Short>, jet.ShortIterable {
    public final /*constructor*/ fun <init>(/*0*/ start: jet.Short, /*1*/ size: jet.Int): jet.ShortRange
    public open override /*1*/ fun contains(/*0*/ elem: jet.Short): jet.Boolean
    public final val end: jet.Short
    public final val isReversed: jet.Boolean
    public open override /*1*/ fun iterator(): jet.ShortIterator
    public final val iteratorStart: jet.Short
    public final fun minus(): jet.ShortRange
    public final val size: jet.Int
    public final val start: jet.Short
    public final fun step(/*0*/ step: jet.Int): jet.ShortIterator
}
public final class jet.String : jet.Comparable<jet.String>, jet.CharSequence {
    public final /*constructor*/ fun <init>(): jet.String
    public open override /*1*/ fun compareTo(/*0*/ that: jet.String): jet.Int
    public final fun equals(/*0*/ other: jet.Any?): jet.Boolean
    public open override /*1*/ fun get(/*0*/ index: jet.Int): jet.Char
    public open override /*1*/ val length: jet.Int
    public final fun plus(/*0*/ other: jet.Any?): jet.String
    public open override /*1*/ fun toString(): jet.String
}
public open class jet.Throwable : jet.Any {
    public final /*constructor*/ fun <init>(/*0*/ message: jet.String? = ?, /*1*/ cause: jet.Throwable? = ?): jet.Throwable
    public final fun getCause(): jet.Throwable?
    public final fun getMessage(): jet.String?
    public final fun printStackTrace(): jet.Tuple0
}
public final class jet.Tuple0 : jet.Any {
    public final /*constructor*/ fun <init>(): jet.Tuple0
}
public final class jet.Tuple1</*0*/ out T1 : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ out T1 : jet.Any?><init>(/*0*/ _1: T1): jet.Tuple1<T1>
    public final val _1: T1
}
public final class jet.Tuple10</*0*/ out T1 : jet.Any?, /*1*/ out T2 : jet.Any?, /*2*/ out T3 : jet.Any?, /*3*/ out T4 : jet.Any?, /*4*/ out T5 : jet.Any?, /*5*/ out T6 : jet.Any?, /*6*/ out T7 : jet.Any?, /*7*/ out T8 : jet.Any?, /*8*/ out T9 : jet.Any?, /*9*/ out T10 : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ out T1 : jet.Any?, /*1*/ out T2 : jet.Any?, /*2*/ out T3 : jet.Any?, /*3*/ out T4 : jet.Any?, /*4*/ out T5 : jet.Any?, /*5*/ out T6 : jet.Any?, /*6*/ out T7 : jet.Any?, /*7*/ out T8 : jet.Any?, /*8*/ out T9 : jet.Any?, /*9*/ out T10 : jet.Any?><init>(/*0*/ _1: T1, /*1*/ _2: T2, /*2*/ _3: T3, /*3*/ _4: T4, /*4*/ _5: T5, /*5*/ _6: T6, /*6*/ _7: T7, /*7*/ _8: T8, /*8*/ _9: T9, /*9*/ _10: T10): jet.Tuple10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
    public final val _10: T10
    public final val _1: T1
    public final val _2: T2
    public final val _3: T3
    public final val _4: T4
    public final val _5: T5
    public final val _6: T6
    public final val _7: T7
    public final val _8: T8
    public final val _9: T9
}
public final class jet.Tuple11</*0*/ out T1 : jet.Any?, /*1*/ out T2 : jet.Any?, /*2*/ out T3 : jet.Any?, /*3*/ out T4 : jet.Any?, /*4*/ out T5 : jet.Any?, /*5*/ out T6 : jet.Any?, /*6*/ out T7 : jet.Any?, /*7*/ out T8 : jet.Any?, /*8*/ out T9 : jet.Any?, /*9*/ out T10 : jet.Any?, /*10*/ out T11 : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ out T1 : jet.Any?, /*1*/ out T2 : jet.Any?, /*2*/ out T3 : jet.Any?, /*3*/ out T4 : jet.Any?, /*4*/ out T5 : jet.Any?, /*5*/ out T6 : jet.Any?, /*6*/ out T7 : jet.Any?, /*7*/ out T8 : jet.Any?, /*8*/ out T9 : jet.Any?, /*9*/ out T10 : jet.Any?, /*10*/ out T11 : jet.Any?><init>(/*0*/ _1: T1, /*1*/ _2: T2, /*2*/ _3: T3, /*3*/ _4: T4, /*4*/ _5: T5, /*5*/ _6: T6, /*6*/ _7: T7, /*7*/ _8: T8, /*8*/ _9: T9, /*9*/ _10: T10, /*10*/ _11: T11): jet.Tuple11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
    public final val _10: T10
    public final val _11: T11
    public final val _1: T1
    public final val _2: T2
    public final val _3: T3
    public final val _4: T4
    public final val _5: T5
    public final val _6: T6
    public final val _7: T7
    public final val _8: T8
    public final val _9: T9
}
public final class jet.Tuple12</*0*/ out T1 : jet.Any?, /*1*/ out T2 : jet.Any?, /*2*/ out T3 : jet.Any?, /*3*/ out T4 : jet.Any?, /*4*/ out T5 : jet.Any?, /*5*/ out T6 : jet.Any?, /*6*/ out T7 : jet.Any?, /*7*/ out T8 : jet.Any?, /*8*/ out T9 : jet.Any?, /*9*/ out T10 : jet.Any?, /*10*/ out T11 : jet.Any?, /*11*/ out T12 : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ out T1 : jet.Any?, /*1*/ out T2 : jet.Any?, /*2*/ out T3 : jet.Any?, /*3*/ out T4 : jet.Any?, /*4*/ out T5 : jet.Any?, /*5*/ out T6 : jet.Any?, /*6*/ out T7 : jet.Any?, /*7*/ out T8 : jet.Any?, /*8*/ out T9 : jet.Any?, /*9*/ out T10 : jet.Any?, /*10*/ out T11 : jet.Any?, /*11*/ out T12 : jet.Any?><init>(/*0*/ _1: T1, /*1*/ _2: T2, /*2*/ _3: T3, /*3*/ _4: T4, /*4*/ _5: T5, /*5*/ _6: T6, /*6*/ _7: T7, /*7*/ _8: T8, /*8*/ _9: T9, /*9*/ _10: T10, /*10*/ _11: T11, /*11*/ _12: T12): jet.Tuple12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
    public final val _10: T10
    public final val _11: T11
    public final val _12: T12
    public final val _1: T1
    public final val _2: T2
    public final val _3: T3
    public final val _4: T4
    public final val _5: T5
    public final val _6: T6
    public final val _7: T7
    public final val _8: T8
    public final val _9: T9
}
public final class jet.Tuple13</*0*/ out T1 : jet.Any?, /*1*/ out T2 : jet.Any?, /*2*/ out T3 : jet.Any?, /*3*/ out T4 : jet.Any?, /*4*/ out T5 : jet.Any?, /*5*/ out T6 : jet.Any?, /*6*/ out T7 : jet.Any?, /*7*/ out T8 : jet.Any?, /*8*/ out T9 : jet.Any?, /*9*/ out T10 : jet.Any?, /*10*/ out T11 : jet.Any?, /*11*/ out T12 : jet.Any?, /*12*/ out T13 : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ out T1 : jet.Any?, /*1*/ out T2 : jet.Any?, /*2*/ out T3 : jet.Any?, /*3*/ out T4 : jet.Any?, /*4*/ out T5 : jet.Any?, /*5*/ out T6 : jet.Any?, /*6*/ out T7 : jet.Any?, /*7*/ out T8 : jet.Any?, /*8*/ out T9 : jet.Any?, /*9*/ out T10 : jet.Any?, /*10*/ out T11 : jet.Any?, /*11*/ out T12 : jet.Any?, /*12*/ out T13 : jet.Any?><init>(/*0*/ _1: T1, /*1*/ _2: T2, /*2*/ _3: T3, /*3*/ _4: T4, /*4*/ _5: T5, /*5*/ _6: T6, /*6*/ _7: T7, /*7*/ _8: T8, /*8*/ _9: T9, /*9*/ _10: T10, /*10*/ _11: T11, /*11*/ _12: T12, /*12*/ _13: T13): jet.Tuple13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
    public final val _10: T10
    public final val _11: T11
    public final val _12: T12
    public final val _13: T13
    public final val _1: T1
    public final val _2: T2
    public final val _3: T3
    public final val _4: T4
    public final val _5: T5
    public final val _6: T6
    public final val _7: T7
    public final val _8: T8
    public final val _9: T9
}
public final class jet.Tuple14</*0*/ out T1 : jet.Any?, /*1*/ out T2 : jet.Any?, /*2*/ out T3 : jet.Any?, /*3*/ out T4 : jet.Any?, /*4*/ out T5 : jet.Any?, /*5*/ out T6 : jet.Any?, /*6*/ out T7 : jet.Any?, /*7*/ out T8 : jet.Any?, /*8*/ out T9 : jet.Any?, /*9*/ out T10 : jet.Any?, /*10*/ out T11 : jet.Any?, /*11*/ out T12 : jet.Any?, /*12*/ out T13 : jet.Any?, /*13*/ out T14 : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ out T1 : jet.Any?, /*1*/ out T2 : jet.Any?, /*2*/ out T3 : jet.Any?, /*3*/ out T4 : jet.Any?, /*4*/ out T5 : jet.Any?, /*5*/ out T6 : jet.Any?, /*6*/ out T7 : jet.Any?, /*7*/ out T8 : jet.Any?, /*8*/ out T9 : jet.Any?, /*9*/ out T10 : jet.Any?, /*10*/ out T11 : jet.Any?, /*11*/ out T12 : jet.Any?, /*12*/ out T13 : jet.Any?, /*13*/ out T14 : jet.Any?><init>(/*0*/ _1: T1, /*1*/ _2: T2, /*2*/ _3: T3, /*3*/ _4: T4, /*4*/ _5: T5, /*5*/ _6: T6, /*6*/ _7: T7, /*7*/ _8: T8, /*8*/ _9: T9, /*9*/ _10: T10, /*10*/ _11: T11, /*11*/ _12: T12, /*12*/ _13: T13, /*13*/ _14: T14): jet.Tuple14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
    public final val _10: T10
    public final val _11: T11
    public final val _12: T12
    public final val _13: T13
    public final val _14: T14
    public final val _1: T1
    public final val _2: T2
    public final val _3: T3
    public final val _4: T4
    public final val _5: T5
    public final val _6: T6
    public final val _7: T7
    public final val _8: T8
    public final val _9: T9
}
public final class jet.Tuple15</*0*/ out T1 : jet.Any?, /*1*/ out T2 : jet.Any?, /*2*/ out T3 : jet.Any?, /*3*/ out T4 : jet.Any?, /*4*/ out T5 : jet.Any?, /*5*/ out T6 : jet.Any?, /*6*/ out T7 : jet.Any?, /*7*/ out T8 : jet.Any?, /*8*/ out T9 : jet.Any?, /*9*/ out T10 : jet.Any?, /*10*/ out T11 : jet.Any?, /*11*/ out T12 : jet.Any?, /*12*/ out T13 : jet.Any?, /*13*/ out T14 : jet.Any?, /*14*/ out T15 : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ out T1 : jet.Any?, /*1*/ out T2 : jet.Any?, /*2*/ out T3 : jet.Any?, /*3*/ out T4 : jet.Any?, /*4*/ out T5 : jet.Any?, /*5*/ out T6 : jet.Any?, /*6*/ out T7 : jet.Any?, /*7*/ out T8 : jet.Any?, /*8*/ out T9 : jet.Any?, /*9*/ out T10 : jet.Any?, /*10*/ out T11 : jet.Any?, /*11*/ out T12 : jet.Any?, /*12*/ out T13 : jet.Any?, /*13*/ out T14 : jet.Any?, /*14*/ out T15 : jet.Any?><init>(/*0*/ _1: T1, /*1*/ _2: T2, /*2*/ _3: T3, /*3*/ _4: T4, /*4*/ _5: T5, /*5*/ _6: T6, /*6*/ _7: T7, /*7*/ _8: T8, /*8*/ _9: T9, /*9*/ _10: T10, /*10*/ _11: T11, /*11*/ _12: T12, /*12*/ _13: T13, /*13*/ _14: T14, /*14*/ _15: T15): jet.Tuple15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
    public final val _10: T10
    public final val _11: T11
    public final val _12: T12
    public final val _13: T13
    public final val _14: T14
    public final val _15: T15
    public final val _1: T1
    public final val _2: T2
    public final val _3: T3
    public final val _4: T4
    public final val _5: T5
    public final val _6: T6
    public final val _7: T7
    public final val _8: T8
    public final val _9: T9
}
public final class jet.Tuple16</*0*/ out T1 : jet.Any?, /*1*/ out T2 : jet.Any?, /*2*/ out T3 : jet.Any?, /*3*/ out T4 : jet.Any?, /*4*/ out T5 : jet.Any?, /*5*/ out T6 : jet.Any?, /*6*/ out T7 : jet.Any?, /*7*/ out T8 : jet.Any?, /*8*/ out T9 : jet.Any?, /*9*/ out T10 : jet.Any?, /*10*/ out T11 : jet.Any?, /*11*/ out T12 : jet.Any?, /*12*/ out T13 : jet.Any?, /*13*/ out T14 : jet.Any?, /*14*/ out T15 : jet.Any?, /*15*/ out T16 : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ out T1 : jet.Any?, /*1*/ out T2 : jet.Any?, /*2*/ out T3 : jet.Any?, /*3*/ out T4 : jet.Any?, /*4*/ out T5 : jet.Any?, /*5*/ out T6 : jet.Any?, /*6*/ out T7 : jet.Any?, /*7*/ out T8 : jet.Any?, /*8*/ out T9 : jet.Any?, /*9*/ out T10 : jet.Any?, /*10*/ out T11 : jet.Any?, /*11*/ out T12 : jet.Any?, /*12*/ out T13 : jet.Any?, /*13*/ out T14 : jet.Any?, /*14*/ out T15 : jet.Any?, /*15*/ out T16 : jet.Any?><init>(/*0*/ _1: T1, /*1*/ _2: T2, /*2*/ _3: T3, /*3*/ _4: T4, /*4*/ _5: T5, /*5*/ _6: T6, /*6*/ _7: T7, /*7*/ _8: T8, /*8*/ _9: T9, /*9*/ _10: T10, /*10*/ _11: T11, /*11*/ _12: T12, /*12*/ _13: T13, /*13*/ _14: T14, /*14*/ _15: T15, /*15*/ _16: T16): jet.Tuple16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>
    public final val _10: T10
    public final val _11: T11
    public final val _12: T12
    public final val _13: T13
    public final val _14: T14
    public final val _15: T15
    public final val _16: T16
    public final val _1: T1
    public final val _2: T2
    public final val _3: T3
    public final val _4: T4
    public final val _5: T5
    public final val _6: T6
    public final val _7: T7
    public final val _8: T8
    public final val _9: T9
}
public final class jet.Tuple17</*0*/ out T1 : jet.Any?, /*1*/ out T2 : jet.Any?, /*2*/ out T3 : jet.Any?, /*3*/ out T4 : jet.Any?, /*4*/ out T5 : jet.Any?, /*5*/ out T6 : jet.Any?, /*6*/ out T7 : jet.Any?, /*7*/ out T8 : jet.Any?, /*8*/ out T9 : jet.Any?, /*9*/ out T10 : jet.Any?, /*10*/ out T11 : jet.Any?, /*11*/ out T12 : jet.Any?, /*12*/ out T13 : jet.Any?, /*13*/ out T14 : jet.Any?, /*14*/ out T15 : jet.Any?, /*15*/ out T16 : jet.Any?, /*16*/ out T17 : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ out T1 : jet.Any?, /*1*/ out T2 : jet.Any?, /*2*/ out T3 : jet.Any?, /*3*/ out T4 : jet.Any?, /*4*/ out T5 : jet.Any?, /*5*/ out T6 : jet.Any?, /*6*/ out T7 : jet.Any?, /*7*/ out T8 : jet.Any?, /*8*/ out T9 : jet.Any?, /*9*/ out T10 : jet.Any?, /*10*/ out T11 : jet.Any?, /*11*/ out T12 : jet.Any?, /*12*/ out T13 : jet.Any?, /*13*/ out T14 : jet.Any?, /*14*/ out T15 : jet.Any?, /*15*/ out T16 : jet.Any?, /*16*/ out T17 : jet.Any?><init>(/*0*/ _1: T1, /*1*/ _2: T2, /*2*/ _3: T3, /*3*/ _4: T4, /*4*/ _5: T5, /*5*/ _6: T6, /*6*/ _7: T7, /*7*/ _8: T8, /*8*/ _9: T9, /*9*/ _10: T10, /*10*/ _11: T11, /*11*/ _12: T12, /*12*/ _13: T13, /*13*/ _14: T14, /*14*/ _15: T15, /*15*/ _16: T16, /*16*/ _17: T17): jet.Tuple17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>
    public final val _10: T10
    public final val _11: T11
    public final val _12: T12
    public final val _13: T13
    public final val _14: T14
    public final val _15: T15
    public final val _16: T16
    public final val _17: T17
    public final val _1: T1
    public final val _2: T2
    public final val _3: T3
    public final val _4: T4
    public final val _5: T5
    public final val _6: T6
    public final val _7: T7
    public final val _8: T8
    public final val _9: T9
}
public final class jet.Tuple18</*0*/ out T1 : jet.Any?, /*1*/ out T2 : jet.Any?, /*2*/ out T3 : jet.Any?, /*3*/ out T4 : jet.Any?, /*4*/ out T5 : jet.Any?, /*5*/ out T6 : jet.Any?, /*6*/ out T7 : jet.Any?, /*7*/ out T8 : jet.Any?, /*8*/ out T9 : jet.Any?, /*9*/ out T10 : jet.Any?, /*10*/ out T11 : jet.Any?, /*11*/ out T12 : jet.Any?, /*12*/ out T13 : jet.Any?, /*13*/ out T14 : jet.Any?, /*14*/ out T15 : jet.Any?, /*15*/ out T16 : jet.Any?, /*16*/ out T17 : jet.Any?, /*17*/ out T18 : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ out T1 : jet.Any?, /*1*/ out T2 : jet.Any?, /*2*/ out T3 : jet.Any?, /*3*/ out T4 : jet.Any?, /*4*/ out T5 : jet.Any?, /*5*/ out T6 : jet.Any?, /*6*/ out T7 : jet.Any?, /*7*/ out T8 : jet.Any?, /*8*/ out T9 : jet.Any?, /*9*/ out T10 : jet.Any?, /*10*/ out T11 : jet.Any?, /*11*/ out T12 : jet.Any?, /*12*/ out T13 : jet.Any?, /*13*/ out T14 : jet.Any?, /*14*/ out T15 : jet.Any?, /*15*/ out T16 : jet.Any?, /*16*/ out T17 : jet.Any?, /*17*/ out T18 : jet.Any?><init>(/*0*/ _1: T1, /*1*/ _2: T2, /*2*/ _3: T3, /*3*/ _4: T4, /*4*/ _5: T5, /*5*/ _6: T6, /*6*/ _7: T7, /*7*/ _8: T8, /*8*/ _9: T9, /*9*/ _10: T10, /*10*/ _11: T11, /*11*/ _12: T12, /*12*/ _13: T13, /*13*/ _14: T14, /*14*/ _15: T15, /*15*/ _16: T16, /*16*/ _17: T17, /*17*/ _18: T18): jet.Tuple18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>
    public final val _10: T10
    public final val _11: T11
    public final val _12: T12
    public final val _13: T13
    public final val _14: T14
    public final val _15: T15
    public final val _16: T16
    public final val _17: T17
    public final val _18: T18
    public final val _1: T1
    public final val _2: T2
    public final val _3: T3
    public final val _4: T4
    public final val _5: T5
    public final val _6: T6
    public final val _7: T7
    public final val _8: T8
    public final val _9: T9
}
public final class jet.Tuple19</*0*/ out T1 : jet.Any?, /*1*/ out T2 : jet.Any?, /*2*/ out T3 : jet.Any?, /*3*/ out T4 : jet.Any?, /*4*/ out T5 : jet.Any?, /*5*/ out T6 : jet.Any?, /*6*/ out T7 : jet.Any?, /*7*/ out T8 : jet.Any?, /*8*/ out T9 : jet.Any?, /*9*/ out T10 : jet.Any?, /*10*/ out T11 : jet.Any?, /*11*/ out T12 : jet.Any?, /*12*/ out T13 : jet.Any?, /*13*/ out T14 : jet.Any?, /*14*/ out T15 : jet.Any?, /*15*/ out T16 : jet.Any?, /*16*/ out T17 : jet.Any?, /*17*/ out T18 : jet.Any?, /*18*/ out T19 : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ out T1 : jet.Any?, /*1*/ out T2 : jet.Any?, /*2*/ out T3 : jet.Any?, /*3*/ out T4 : jet.Any?, /*4*/ out T5 : jet.Any?, /*5*/ out T6 : jet.Any?, /*6*/ out T7 : jet.Any?, /*7*/ out T8 : jet.Any?, /*8*/ out T9 : jet.Any?, /*9*/ out T10 : jet.Any?, /*10*/ out T11 : jet.Any?, /*11*/ out T12 : jet.Any?, /*12*/ out T13 : jet.Any?, /*13*/ out T14 : jet.Any?, /*14*/ out T15 : jet.Any?, /*15*/ out T16 : jet.Any?, /*16*/ out T17 : jet.Any?, /*17*/ out T18 : jet.Any?, /*18*/ out T19 : jet.Any?><init>(/*0*/ _1: T1, /*1*/ _2: T2, /*2*/ _3: T3, /*3*/ _4: T4, /*4*/ _5: T5, /*5*/ _6: T6, /*6*/ _7: T7, /*7*/ _8: T8, /*8*/ _9: T9, /*9*/ _10: T10, /*10*/ _11: T11, /*11*/ _12: T12, /*12*/ _13: T13, /*13*/ _14: T14, /*14*/ _15: T15, /*15*/ _16: T16, /*16*/ _17: T17, /*17*/ _18: T18, /*18*/ _19: T19): jet.Tuple19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
    public final val _10: T10
    public final val _11: T11
    public final val _12: T12
    public final val _13: T13
    public final val _14: T14
    public final val _15: T15
    public final val _16: T16
    public final val _17: T17
    public final val _18: T18
    public final val _19: T19
    public final val _1: T1
    public final val _2: T2
    public final val _3: T3
    public final val _4: T4
    public final val _5: T5
    public final val _6: T6
    public final val _7: T7
    public final val _8: T8
    public final val _9: T9
}
public final class jet.Tuple2</*0*/ out T1 : jet.Any?, /*1*/ out T2 : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ out T1 : jet.Any?, /*1*/ out T2 : jet.Any?><init>(/*0*/ _1: T1, /*1*/ _2: T2): jet.Tuple2<T1, T2>
    public final val _1: T1
    public final val _2: T2
}
public final class jet.Tuple20</*0*/ out T1 : jet.Any?, /*1*/ out T2 : jet.Any?, /*2*/ out T3 : jet.Any?, /*3*/ out T4 : jet.Any?, /*4*/ out T5 : jet.Any?, /*5*/ out T6 : jet.Any?, /*6*/ out T7 : jet.Any?, /*7*/ out T8 : jet.Any?, /*8*/ out T9 : jet.Any?, /*9*/ out T10 : jet.Any?, /*10*/ out T11 : jet.Any?, /*11*/ out T12 : jet.Any?, /*12*/ out T13 : jet.Any?, /*13*/ out T14 : jet.Any?, /*14*/ out T15 : jet.Any?, /*15*/ out T16 : jet.Any?, /*16*/ out T17 : jet.Any?, /*17*/ out T18 : jet.Any?, /*18*/ out T19 : jet.Any?, /*19*/ out T20 : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ out T1 : jet.Any?, /*1*/ out T2 : jet.Any?, /*2*/ out T3 : jet.Any?, /*3*/ out T4 : jet.Any?, /*4*/ out T5 : jet.Any?, /*5*/ out T6 : jet.Any?, /*6*/ out T7 : jet.Any?, /*7*/ out T8 : jet.Any?, /*8*/ out T9 : jet.Any?, /*9*/ out T10 : jet.Any?, /*10*/ out T11 : jet.Any?, /*11*/ out T12 : jet.Any?, /*12*/ out T13 : jet.Any?, /*13*/ out T14 : jet.Any?, /*14*/ out T15 : jet.Any?, /*15*/ out T16 : jet.Any?, /*16*/ out T17 : jet.Any?, /*17*/ out T18 : jet.Any?, /*18*/ out T19 : jet.Any?, /*19*/ out T20 : jet.Any?><init>(/*0*/ _1: T1, /*1*/ _2: T2, /*2*/ _3: T3, /*3*/ _4: T4, /*4*/ _5: T5, /*5*/ _6: T6, /*6*/ _7: T7, /*7*/ _8: T8, /*8*/ _9: T9, /*9*/ _10: T10, /*10*/ _11: T11, /*11*/ _12: T12, /*12*/ _13: T13, /*13*/ _14: T14, /*14*/ _15: T15, /*15*/ _16: T16, /*16*/ _17: T17, /*17*/ _18: T18, /*18*/ _19: T19, /*19*/ _20: T20): jet.Tuple20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>
    public final val _10: T10
    public final val _11: T11
    public final val _12: T12
    public final val _13: T13
    public final val _14: T14
    public final val _15: T15
    public final val _16: T16
    public final val _17: T17
    public final val _18: T18
    public final val _19: T19
    public final val _1: T1
    public final val _20: T20
    public final val _2: T2
    public final val _3: T3
    public final val _4: T4
    public final val _5: T5
    public final val _6: T6
    public final val _7: T7
    public final val _8: T8
    public final val _9: T9
}
public final class jet.Tuple21</*0*/ out T1 : jet.Any?, /*1*/ out T2 : jet.Any?, /*2*/ out T3 : jet.Any?, /*3*/ out T4 : jet.Any?, /*4*/ out T5 : jet.Any?, /*5*/ out T6 : jet.Any?, /*6*/ out T7 : jet.Any?, /*7*/ out T8 : jet.Any?, /*8*/ out T9 : jet.Any?, /*9*/ out T10 : jet.Any?, /*10*/ out T11 : jet.Any?, /*11*/ out T12 : jet.Any?, /*12*/ out T13 : jet.Any?, /*13*/ out T14 : jet.Any?, /*14*/ out T15 : jet.Any?, /*15*/ out T16 : jet.Any?, /*16*/ out T17 : jet.Any?, /*17*/ out T18 : jet.Any?, /*18*/ out T19 : jet.Any?, /*19*/ out T20 : jet.Any?, /*20*/ out T21 : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ out T1 : jet.Any?, /*1*/ out T2 : jet.Any?, /*2*/ out T3 : jet.Any?, /*3*/ out T4 : jet.Any?, /*4*/ out T5 : jet.Any?, /*5*/ out T6 : jet.Any?, /*6*/ out T7 : jet.Any?, /*7*/ out T8 : jet.Any?, /*8*/ out T9 : jet.Any?, /*9*/ out T10 : jet.Any?, /*10*/ out T11 : jet.Any?, /*11*/ out T12 : jet.Any?, /*12*/ out T13 : jet.Any?, /*13*/ out T14 : jet.Any?, /*14*/ out T15 : jet.Any?, /*15*/ out T16 : jet.Any?, /*16*/ out T17 : jet.Any?, /*17*/ out T18 : jet.Any?, /*18*/ out T19 : jet.Any?, /*19*/ out T20 : jet.Any?, /*20*/ out T21 : jet.Any?><init>(/*0*/ _1: T1, /*1*/ _2: T2, /*2*/ _3: T3, /*3*/ _4: T4, /*4*/ _5: T5, /*5*/ _6: T6, /*6*/ _7: T7, /*7*/ _8: T8, /*8*/ _9: T9, /*9*/ _10: T10, /*10*/ _11: T11, /*11*/ _12: T12, /*12*/ _13: T13, /*13*/ _14: T14, /*14*/ _15: T15, /*15*/ _16: T16, /*16*/ _17: T17, /*17*/ _18: T18, /*18*/ _19: T19, /*19*/ _20: T20, /*20*/ _21: T21): jet.Tuple21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>
    public final val _10: T10
    public final val _11: T11
    public final val _12: T12
    public final val _13: T13
    public final val _14: T14
    public final val _15: T15
    public final val _16: T16
    public final val _17: T17
    public final val _18: T18
    public final val _19: T19
    public final val _1: T1
    public final val _20: T20
    public final val _21: T21
    public final val _2: T2
    public final val _3: T3
    public final val _4: T4
    public final val _5: T5
    public final val _6: T6
    public final val _7: T7
    public final val _8: T8
    public final val _9: T9
}
public final class jet.Tuple22</*0*/ out T1 : jet.Any?, /*1*/ out T2 : jet.Any?, /*2*/ out T3 : jet.Any?, /*3*/ out T4 : jet.Any?, /*4*/ out T5 : jet.Any?, /*5*/ out T6 : jet.Any?, /*6*/ out T7 : jet.Any?, /*7*/ out T8 : jet.Any?, /*8*/ out T9 : jet.Any?, /*9*/ out T10 : jet.Any?, /*10*/ out T11 : jet.Any?, /*11*/ out T12 : jet.Any?, /*12*/ out T13 : jet.Any?, /*13*/ out T14 : jet.Any?, /*14*/ out T15 : jet.Any?, /*15*/ out T16 : jet.Any?, /*16*/ out T17 : jet.Any?, /*17*/ out T18 : jet.Any?, /*18*/ out T19 : jet.Any?, /*19*/ out T20 : jet.Any?, /*20*/ out T21 : jet.Any?, /*21*/ out T22 : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ out T1 : jet.Any?, /*1*/ out T2 : jet.Any?, /*2*/ out T3 : jet.Any?, /*3*/ out T4 : jet.Any?, /*4*/ out T5 : jet.Any?, /*5*/ out T6 : jet.Any?, /*6*/ out T7 : jet.Any?, /*7*/ out T8 : jet.Any?, /*8*/ out T9 : jet.Any?, /*9*/ out T10 : jet.Any?, /*10*/ out T11 : jet.Any?, /*11*/ out T12 : jet.Any?, /*12*/ out T13 : jet.Any?, /*13*/ out T14 : jet.Any?, /*14*/ out T15 : jet.Any?, /*15*/ out T16 : jet.Any?, /*16*/ out T17 : jet.Any?, /*17*/ out T18 : jet.Any?, /*18*/ out T19 : jet.Any?, /*19*/ out T20 : jet.Any?, /*20*/ out T21 : jet.Any?, /*21*/ out T22 : jet.Any?><init>(/*0*/ _1: T1, /*1*/ _2: T2, /*2*/ _3: T3, /*3*/ _4: T4, /*4*/ _5: T5, /*5*/ _6: T6, /*6*/ _7: T7, /*7*/ _8: T8, /*8*/ _9: T9, /*9*/ _10: T10, /*10*/ _11: T11, /*11*/ _12: T12, /*12*/ _13: T13, /*13*/ _14: T14, /*14*/ _15: T15, /*15*/ _16: T16, /*16*/ _17: T17, /*17*/ _18: T18, /*18*/ _19: T19, /*19*/ _20: T20, /*20*/ _21: T21, /*21*/ _22: T22): jet.Tuple22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>
    public final val _10: T10
    public final val _11: T11
    public final val _12: T12
    public final val _13: T13
    public final val _14: T14
    public final val _15: T15
    public final val _16: T16
    public final val _17: T17
    public final val _18: T18
    public final val _19: T19
    public final val _1: T1
    public final val _20: T20
    public final val _21: T21
    public final val _22: T22
    public final val _2: T2
    public final val _3: T3
    public final val _4: T4
    public final val _5: T5
    public final val _6: T6
    public final val _7: T7
    public final val _8: T8
    public final val _9: T9
}
public final class jet.Tuple3</*0*/ out T1 : jet.Any?, /*1*/ out T2 : jet.Any?, /*2*/ out T3 : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ out T1 : jet.Any?, /*1*/ out T2 : jet.Any?, /*2*/ out T3 : jet.Any?><init>(/*0*/ _1: T1, /*1*/ _2: T2, /*2*/ _3: T3): jet.Tuple3<T1, T2, T3>
    public final val _1: T1
    public final val _2: T2
    public final val _3: T3
}
public final class jet.Tuple4</*0*/ out T1 : jet.Any?, /*1*/ out T2 : jet.Any?, /*2*/ out T3 : jet.Any?, /*3*/ out T4 : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ out T1 : jet.Any?, /*1*/ out T2 : jet.Any?, /*2*/ out T3 : jet.Any?, /*3*/ out T4 : jet.Any?><init>(/*0*/ _1: T1, /*1*/ _2: T2, /*2*/ _3: T3, /*3*/ _4: T4): jet.Tuple4<T1, T2, T3, T4>
    public final val _1: T1
    public final val _2: T2
    public final val _3: T3
    public final val _4: T4
}
public final class jet.Tuple5</*0*/ out T1 : jet.Any?, /*1*/ out T2 : jet.Any?, /*2*/ out T3 : jet.Any?, /*3*/ out T4 : jet.Any?, /*4*/ out T5 : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ out T1 : jet.Any?, /*1*/ out T2 : jet.Any?, /*2*/ out T3 : jet.Any?, /*3*/ out T4 : jet.Any?, /*4*/ out T5 : jet.Any?><init>(/*0*/ _1: T1, /*1*/ _2: T2, /*2*/ _3: T3, /*3*/ _4: T4, /*4*/ _5: T5): jet.Tuple5<T1, T2, T3, T4, T5>
    public final val _1: T1
    public final val _2: T2
    public final val _3: T3
    public final val _4: T4
    public final val _5: T5
}
public final class jet.Tuple6</*0*/ out T1 : jet.Any?, /*1*/ out T2 : jet.Any?, /*2*/ out T3 : jet.Any?, /*3*/ out T4 : jet.Any?, /*4*/ out T5 : jet.Any?, /*5*/ out T6 : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ out T1 : jet.Any?, /*1*/ out T2 : jet.Any?, /*2*/ out T3 : jet.Any?, /*3*/ out T4 : jet.Any?, /*4*/ out T5 : jet.Any?, /*5*/ out T6 : jet.Any?><init>(/*0*/ _1: T1, /*1*/ _2: T2, /*2*/ _3: T3, /*3*/ _4: T4, /*4*/ _5: T5, /*5*/ _6: T6): jet.Tuple6<T1, T2, T3, T4, T5, T6>
    public final val _1: T1
    public final val _2: T2
    public final val _3: T3
    public final val _4: T4
    public final val _5: T5
    public final val _6: T6
}
public final class jet.Tuple7</*0*/ out T1 : jet.Any?, /*1*/ out T2 : jet.Any?, /*2*/ out T3 : jet.Any?, /*3*/ out T4 : jet.Any?, /*4*/ out T5 : jet.Any?, /*5*/ out T6 : jet.Any?, /*6*/ out T7 : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ out T1 : jet.Any?, /*1*/ out T2 : jet.Any?, /*2*/ out T3 : jet.Any?, /*3*/ out T4 : jet.Any?, /*4*/ out T5 : jet.Any?, /*5*/ out T6 : jet.Any?, /*6*/ out T7 : jet.Any?><init>(/*0*/ _1: T1, /*1*/ _2: T2, /*2*/ _3: T3, /*3*/ _4: T4, /*4*/ _5: T5, /*5*/ _6: T6, /*6*/ _7: T7): jet.Tuple7<T1, T2, T3, T4, T5, T6, T7>
    public final val _1: T1
    public final val _2: T2
    public final val _3: T3
    public final val _4: T4
    public final val _5: T5
    public final val _6: T6
    public final val _7: T7
}
public final class jet.Tuple8</*0*/ out T1 : jet.Any?, /*1*/ out T2 : jet.Any?, /*2*/ out T3 : jet.Any?, /*3*/ out T4 : jet.Any?, /*4*/ out T5 : jet.Any?, /*5*/ out T6 : jet.Any?, /*6*/ out T7 : jet.Any?, /*7*/ out T8 : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ out T1 : jet.Any?, /*1*/ out T2 : jet.Any?, /*2*/ out T3 : jet.Any?, /*3*/ out T4 : jet.Any?, /*4*/ out T5 : jet.Any?, /*5*/ out T6 : jet.Any?, /*6*/ out T7 : jet.Any?, /*7*/ out T8 : jet.Any?><init>(/*0*/ _1: T1, /*1*/ _2: T2, /*2*/ _3: T3, /*3*/ _4: T4, /*4*/ _5: T5, /*5*/ _6: T6, /*6*/ _7: T7, /*7*/ _8: T8): jet.Tuple8<T1, T2, T3, T4, T5, T6, T7, T8>
    public final val _1: T1
    public final val _2: T2
    public final val _3: T3
    public final val _4: T4
    public final val _5: T5
    public final val _6: T6
    public final val _7: T7
    public final val _8: T8
}
public final class jet.Tuple9</*0*/ out T1 : jet.Any?, /*1*/ out T2 : jet.Any?, /*2*/ out T3 : jet.Any?, /*3*/ out T4 : jet.Any?, /*4*/ out T5 : jet.Any?, /*5*/ out T6 : jet.Any?, /*6*/ out T7 : jet.Any?, /*7*/ out T8 : jet.Any?, /*8*/ out T9 : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ out T1 : jet.Any?, /*1*/ out T2 : jet.Any?, /*2*/ out T3 : jet.Any?, /*3*/ out T4 : jet.Any?, /*4*/ out T5 : jet.Any?, /*5*/ out T6 : jet.Any?, /*6*/ out T7 : jet.Any?, /*7*/ out T8 : jet.Any?, /*8*/ out T9 : jet.Any?><init>(/*0*/ _1: T1, /*1*/ _2: T2, /*2*/ _3: T3, /*3*/ _4: T4, /*4*/ _5: T5, /*5*/ _6: T6, /*6*/ _7: T7, /*7*/ _8: T8, /*8*/ _9: T9): jet.Tuple9<T1, T2, T3, T4, T5, T6, T7, T8, T9>
    public final val _1: T1
    public final val _2: T2
    public final val _3: T3
    public final val _4: T4
    public final val _5: T5
    public final val _6: T6
    public final val _7: T7
    public final val _8: T8
    public final val _9: T9
}
public final annotation class jet.atomic : jet.Any {
    public final /*constructor*/ fun <init>(): jet.atomic
}
public final annotation class jet.volatile : jet.Any {
    public final /*constructor*/ fun <init>(): jet.volatile
}
public final fun </*0*/ T : jet.Any?>arrayOfNulls(/*0*/ size: jet.Int): jet.Array<T?>
public final fun jet.Any?.equals(/*0*/ other: jet.Any?): jet.Boolean
public final fun jet.Any?.identityEquals(/*0*/ other: jet.Any?): jet.Boolean
public final fun jet.BooleanIterator.iterator(): jet.BooleanIterator
public final fun jet.ByteIterator.iterator(): jet.ByteIterator
public final fun jet.CharIterator.iterator(): jet.CharIterator
public final fun jet.DoubleIterator.iterator(): jet.DoubleIterator
public final fun jet.FloatIterator.iterator(): jet.FloatIterator
public final fun jet.IntIterator.iterator(): jet.IntIterator
public final fun </*0*/ T : jet.Any?>jet.Iterator<T>.iterator(): jet.Iterator<T>
public final fun jet.LongIterator.iterator(): jet.LongIterator
public final fun jet.ShortIterator.iterator(): jet.ShortIterator
public final fun jet.String?.plus(/*0*/ other: jet.Any?): jet.String
public final fun </*0*/ R : jet.Any?>synchronized(/*0*/ lock: jet.Any, /*1*/ block: jet.Function0<R>): R
public final fun jet.Any?.toString(): jet.String
// </namespace name="jet">
// <namespace name="kotlin">
namespace kotlin

// <namespace name="beans">
namespace beans

private final class kotlin.beans.FunctionPropertyChangeListener : java.beans.PropertyChangeListener {
    public final /*constructor*/ fun <init>(/*0*/ fn: jet.Function1<java.beans.PropertyChangeEvent, jet.Tuple0>): kotlin.beans.FunctionPropertyChangeListener
    protected open override /*1*/ fun clone(): jet.Any
    public open override /*1*/ fun equals(/*0*/ p0: jet.Any?): jet.Boolean
    internal final val fn: jet.Function1<java.beans.PropertyChangeEvent, jet.Tuple0>
    public final override /*1*/ fun getClass(): java.lang.Class<out jet.Any?>?
    public open override /*1*/ fun hashCode(): jet.Int
    protected open override /*1*/ fun finalize(): jet.Tuple0
    public final override /*1*/ fun notify(): jet.Tuple0
    public final override /*1*/ fun notifyAll(): jet.Tuple0
    public open override /*1*/ fun propertyChange(/*0*/ e: java.beans.PropertyChangeEvent?): jet.Tuple0
    public open override /*1*/ fun toString(): jet.String?
    public final override /*1*/ fun wait(): jet.Tuple0
    public final override /*1*/ fun wait(/*0*/ p0: jet.Long): jet.Tuple0
    public final override /*1*/ fun wait(/*0*/ p0: jet.Long, /*1*/ p1: jet.Int): jet.Tuple0
}
internal final fun propertyChangeListener(/*0*/ fn: jet.Function1<java.beans.PropertyChangeEvent, jet.Tuple0>): java.beans.PropertyChangeListener
// </namespace name="beans">
// <namespace name="browser">
namespace browser

private final var _document: org.w3c.dom.Document?
public final js.native() var document: org.w3c.dom.Document
// </namespace name="browser">
// <namespace name="concurrent">
namespace concurrent

internal abstract class kotlin.concurrent.FunctionalList</*0*/ T : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ T : jet.Any?><init>(/*0*/ size: jet.Int): kotlin.concurrent.FunctionalList<T>
    public final fun add(/*0*/ element: T): kotlin.concurrent.FunctionalList<T>
    internal final val empty: jet.Boolean
    public abstract val head: T
    public final fun iterator(): jet.Iterator<T>
    public final fun reversed(): kotlin.concurrent.FunctionalList<T>
    public final val size: jet.Int
    public abstract val tail: kotlin.concurrent.FunctionalList<T>
    internal final object kotlin.concurrent.FunctionalList.<no name provided> : jet.Any {
        internal final /*constructor*/ fun <init>(): kotlin.concurrent.FunctionalList.<no name provided>
        internal final class kotlin.concurrent.FunctionalList.<no name provided>.Empty</*0*/ T : jet.Any?> : kotlin.concurrent.FunctionalList<T> {
            public final /*constructor*/ fun </*0*/ T : jet.Any?><init>(): kotlin.concurrent.FunctionalList.<no name provided>.Empty<T>
            public final override /*1*/ fun add(/*0*/ element: T): kotlin.concurrent.FunctionalList<T>
            internal final override /*1*/ val empty: jet.Boolean
            public open override /*1*/ val head: T
            public final override /*1*/ fun iterator(): jet.Iterator<T>
            public final override /*1*/ fun reversed(): kotlin.concurrent.FunctionalList<T>
            public final override /*1*/ val size: jet.Int
            public open override /*1*/ val tail: kotlin.concurrent.FunctionalList<T>
        }
        internal final class kotlin.concurrent.FunctionalList.<no name provided>.Standard</*0*/ T : jet.Any?> : kotlin.concurrent.FunctionalList<T> {
            public final /*constructor*/ fun </*0*/ T : jet.Any?><init>(/*0*/ head: T, /*1*/ tail: kotlin.concurrent.FunctionalList<T>): kotlin.concurrent.FunctionalList.<no name provided>.Standard<T>
            public final override /*1*/ fun add(/*0*/ element: T): kotlin.concurrent.FunctionalList<T>
            internal final override /*1*/ val empty: jet.Boolean
            public open override /*1*/ val head: T
            public final override /*1*/ fun iterator(): jet.Iterator<T>
            public final override /*1*/ fun reversed(): kotlin.concurrent.FunctionalList<T>
            public final override /*1*/ val size: jet.Int
            public open override /*1*/ val tail: kotlin.concurrent.FunctionalList<T>
        }
        public final fun </*0*/ T : jet.Any?>emptyList(): kotlin.concurrent.FunctionalList<T>
        public final fun </*0*/ T : jet.Any?>of(/*0*/ element: T): kotlin.concurrent.FunctionalList<T>
    }
}
internal final class kotlin.concurrent.FunctionalQueue</*0*/ T : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ T : jet.Any?><init>(/*0*/ input: kotlin.concurrent.FunctionalList<T> = ?, /*1*/ output: kotlin.concurrent.FunctionalList<T> = ?): kotlin.concurrent.FunctionalQueue<T>
    public final fun add(/*0*/ element: T): kotlin.concurrent.FunctionalQueue<T>
    public final fun addFirst(/*0*/ element: T): kotlin.concurrent.FunctionalQueue<T>
    internal final val empty: jet.Boolean
    internal final val input: kotlin.concurrent.FunctionalList<T>
    internal final val output: kotlin.concurrent.FunctionalList<T>
    public final fun removeFirst(): jet.Tuple2<out T, out kotlin.concurrent.FunctionalQueue<T>>
    internal final val size: jet.Int
}
internal final val java.lang.Thread.alive: jet.Boolean
internal final var java.lang.Thread.contextClassLoader: java.lang.ClassLoader?
internal final val currentThread: java.lang.Thread
internal final var java.lang.Thread.daemon: jet.Boolean
internal final var java.lang.Thread.name: jet.String
internal final var java.lang.Thread.priority: jet.Int
public final fun java.util.concurrent.Executor.execute(/*0*/ action: jet.Function0<jet.Tuple0>): jet.Tuple0
public final fun fixedRateTimer(/*0*/ name: jet.String? = ?, /*1*/ daemon: jet.Boolean = ?, /*2*/ initialDelay: jet.Long = ?, /*3*/ period: jet.Long, /*4*/ action: jet.ExtensionFunction0<java.util.TimerTask, jet.Tuple0>): java.util.Timer
public final fun fixedRateTimer(/*0*/ name: jet.String? = ?, /*1*/ daemon: jet.Boolean = ?, /*2*/ startAt: java.util.Date, /*3*/ period: jet.Long, /*4*/ action: jet.ExtensionFunction0<java.util.TimerTask, jet.Tuple0>): java.util.Timer
public final fun </*0*/ T : jet.Any?>java.util.concurrent.locks.ReentrantReadWriteLock.read(/*0*/ action: jet.Function0<T>): T
public final fun java.util.Timer.schedule(/*0*/ delay: jet.Long, /*1*/ action: jet.ExtensionFunction0<java.util.TimerTask, jet.Tuple0>): java.util.TimerTask
public final fun java.util.Timer.schedule(/*0*/ delay: jet.Long, /*1*/ period: jet.Long, /*2*/ action: jet.ExtensionFunction0<java.util.TimerTask, jet.Tuple0>): java.util.TimerTask
public final fun java.util.Timer.schedule(/*0*/ time: java.util.Date, /*1*/ action: jet.ExtensionFunction0<java.util.TimerTask, jet.Tuple0>): java.util.TimerTask
public final fun java.util.Timer.schedule(/*0*/ time: java.util.Date, /*1*/ period: jet.Long, /*2*/ action: jet.ExtensionFunction0<java.util.TimerTask, jet.Tuple0>): java.util.TimerTask
public final fun java.util.Timer.scheduleAtFixedRate(/*0*/ delay: jet.Long, /*1*/ period: jet.Long, /*2*/ action: jet.ExtensionFunction0<java.util.TimerTask, jet.Tuple0>): java.util.TimerTask
public final fun java.util.Timer.scheduleAtFixedRate(/*0*/ time: java.util.Date, /*1*/ period: jet.Long, /*2*/ action: jet.ExtensionFunction0<java.util.TimerTask, jet.Tuple0>): java.util.TimerTask
public final fun thread(/*0*/ start: jet.Boolean = ?, /*1*/ daemon: jet.Boolean = ?, /*2*/ contextClassLoader: java.lang.ClassLoader? = ?, /*3*/ name: jet.String? = ?, /*4*/ priority: jet.Int = ?, /*5*/ block: jet.Function0<jet.Tuple0>): java.lang.Thread
public final fun timer(/*0*/ name: jet.String? = ?, /*1*/ daemon: jet.Boolean = ?, /*2*/ initialDelay: jet.Long = ?, /*3*/ period: jet.Long, /*4*/ action: jet.ExtensionFunction0<java.util.TimerTask, jet.Tuple0>): java.util.Timer
public final fun timer(/*0*/ name: jet.String? = ?, /*1*/ daemon: jet.Boolean = ?, /*2*/ startAt: java.util.Date, /*3*/ period: jet.Long, /*4*/ action: jet.ExtensionFunction0<java.util.TimerTask, jet.Tuple0>): java.util.Timer
public final fun timerTask(/*0*/ action: jet.ExtensionFunction0<java.util.TimerTask, jet.Tuple0>): java.util.TimerTask
public final fun </*0*/ T : jet.Any?>java.util.concurrent.locks.Lock.withLock(/*0*/ action: jet.Function0<T>): T
public final fun </*0*/ T : jet.Any?>java.util.concurrent.locks.ReentrantReadWriteLock.write(/*0*/ action: jet.Function0<T>): T
// </namespace name="concurrent">
// <namespace name="dom">
namespace dom

internal final class kotlin.dom.ElementListAsList : java.util.AbstractList<org.w3c.dom.Element> {
    public final /*constructor*/ fun <init>(/*0*/ nodeList: org.w3c.dom.NodeList): kotlin.dom.ElementListAsList
    public open override /*1*/ fun add(/*0*/ p0: jet.Int, /*1*/ p1: org.w3c.dom.Element): jet.Tuple0
    public open override /*1*/ fun add(/*0*/ p0: org.w3c.dom.Element): jet.Boolean
    public open override /*1*/ fun addAll(/*0*/ p0: java.util.Collection<out org.w3c.dom.Element>): jet.Boolean
    public open override /*1*/ fun addAll(/*0*/ p0: jet.Int, /*1*/ p1: java.util.Collection<out org.w3c.dom.Element>): jet.Boolean
    public open override /*1*/ fun clear(): jet.Tuple0
    protected open override /*1*/ fun clone(): jet.Any
    public open override /*1*/ fun contains(/*0*/ p0: jet.Any?): jet.Boolean
    public open override /*1*/ fun containsAll(/*0*/ p0: java.util.Collection<out jet.Any?>): jet.Boolean
    public open override /*1*/ fun equals(/*0*/ p0: jet.Any?): jet.Boolean
    public open override /*1*/ fun get(/*0*/ index: jet.Int): org.w3c.dom.Element
    public final override /*1*/ fun getClass(): java.lang.Class<out jet.Any?>?
    public open override /*1*/ fun hashCode(): jet.Int
    public open override /*1*/ fun indexOf(/*0*/ p0: jet.Any?): jet.Int
    public open override /*1*/ fun isEmpty(): jet.Boolean
    public open override /*1*/ fun iterator(): java.util.Iterator<org.w3c.dom.Element>
    protected open override /*1*/ fun finalize(): jet.Tuple0
    public open override /*1*/ fun lastIndexOf(/*0*/ p0: jet.Any?): jet.Int
    public open override /*1*/ fun listIterator(): java.util.ListIterator<org.w3c.dom.Element>
    public open override /*1*/ fun listIterator(/*0*/ p0: jet.Int): java.util.ListIterator<org.w3c.dom.Element>
    protected final override /*1*/ var modCount: jet.Int
    internal final val nodeList: org.w3c.dom.NodeList
    public final override /*1*/ fun notify(): jet.Tuple0
    public final override /*1*/ fun notifyAll(): jet.Tuple0
    public open override /*1*/ fun remove(/*0*/ p0: jet.Any?): jet.Boolean
    public open override /*1*/ fun remove(/*0*/ p0: jet.Int): org.w3c.dom.Element?
    public open override /*1*/ fun removeAll(/*0*/ p0: java.util.Collection<out jet.Any?>): jet.Boolean
    protected open override /*1*/ fun removeRange(/*0*/ p0: jet.Int, /*1*/ p1: jet.Int): jet.Tuple0
    public open override /*1*/ fun retainAll(/*0*/ p0: java.util.Collection<out jet.Any?>): jet.Boolean
    public open override /*1*/ fun set(/*0*/ p0: jet.Int, /*1*/ p1: org.w3c.dom.Element): org.w3c.dom.Element
    public open override /*1*/ fun size(): jet.Int
    public open override /*1*/ fun subList(/*0*/ p0: jet.Int, /*1*/ p1: jet.Int): java.util.List<org.w3c.dom.Element>
    public open override /*1*/ fun toArray(): jet.Array<jet.Any?>
    public open override /*1*/ fun </*0*/ T : jet.Any?>toArray(/*0*/ p0: jet.Array<T>): jet.Array<T>
    public open override /*1*/ fun toString(): jet.String?
    public final override /*1*/ fun wait(): jet.Tuple0
    public final override /*1*/ fun wait(/*0*/ p0: jet.Long): jet.Tuple0
    public final override /*1*/ fun wait(/*0*/ p0: jet.Long, /*1*/ p1: jet.Int): jet.Tuple0
}
internal final class kotlin.dom.NextSiblingIterator : kotlin.support.AbstractIterator<org.w3c.dom.Node> {
    public final /*constructor*/ fun <init>(/*0*/ node: org.w3c.dom.Node): kotlin.dom.NextSiblingIterator
    protected open override /*1*/ fun clone(): jet.Any
    protected open override /*1*/ fun computeNext(): jet.Tuple0
    protected final override /*1*/ fun done(): jet.Tuple0
    public open override /*1*/ fun equals(/*0*/ p0: jet.Any?): jet.Boolean
    public final override /*1*/ fun getClass(): java.lang.Class<out jet.Any?>?
    public open override /*1*/ fun hasNext(): jet.Boolean
    public open override /*1*/ fun hashCode(): jet.Int
    invisible_fake final override /*1*/ fun tryToComputeNext(): jet.Boolean
    invisible_fake final override /*1*/ var next: org.w3c.dom.Node? private get private set
    invisible_fake final override /*1*/ var state: jet.Int private get private set
    protected open override /*1*/ fun finalize(): jet.Tuple0
    public open override /*1*/ fun next(): org.w3c.dom.Node
    internal final var node: org.w3c.dom.Node
    public final override /*1*/ fun notify(): jet.Tuple0
    public final override /*1*/ fun notifyAll(): jet.Tuple0
    internal final override /*1*/ fun peek(): org.w3c.dom.Node
    public open override /*1*/ fun remove(): jet.Tuple0
    protected final override /*1*/ fun setNext(/*0*/ value: org.w3c.dom.Node): jet.Tuple0
    public open override /*1*/ fun toString(): jet.String?
    public final override /*1*/ fun wait(): jet.Tuple0
    public final override /*1*/ fun wait(/*0*/ p0: jet.Long): jet.Tuple0
    public final override /*1*/ fun wait(/*0*/ p0: jet.Long, /*1*/ p1: jet.Int): jet.Tuple0
}
internal final class kotlin.dom.NodeListAsList : java.util.AbstractList<org.w3c.dom.Node> {
    public final /*constructor*/ fun <init>(/*0*/ nodeList: org.w3c.dom.NodeList): kotlin.dom.NodeListAsList
    public open override /*1*/ fun add(/*0*/ p0: jet.Int, /*1*/ p1: org.w3c.dom.Node): jet.Tuple0
    public open override /*1*/ fun add(/*0*/ p0: org.w3c.dom.Node): jet.Boolean
    public open override /*1*/ fun addAll(/*0*/ p0: java.util.Collection<out org.w3c.dom.Node>): jet.Boolean
    public open override /*1*/ fun addAll(/*0*/ p0: jet.Int, /*1*/ p1: java.util.Collection<out org.w3c.dom.Node>): jet.Boolean
    public open override /*1*/ fun clear(): jet.Tuple0
    protected open override /*1*/ fun clone(): jet.Any
    public open override /*1*/ fun contains(/*0*/ p0: jet.Any?): jet.Boolean
    public open override /*1*/ fun containsAll(/*0*/ p0: java.util.Collection<out jet.Any?>): jet.Boolean
    public open override /*1*/ fun equals(/*0*/ p0: jet.Any?): jet.Boolean
    public open override /*1*/ fun get(/*0*/ index: jet.Int): org.w3c.dom.Node
    public final override /*1*/ fun getClass(): java.lang.Class<out jet.Any?>?
    public open override /*1*/ fun hashCode(): jet.Int
    public open override /*1*/ fun indexOf(/*0*/ p0: jet.Any?): jet.Int
    public open override /*1*/ fun isEmpty(): jet.Boolean
    public open override /*1*/ fun iterator(): java.util.Iterator<org.w3c.dom.Node>
    protected open override /*1*/ fun finalize(): jet.Tuple0
    public open override /*1*/ fun lastIndexOf(/*0*/ p0: jet.Any?): jet.Int
    public open override /*1*/ fun listIterator(): java.util.ListIterator<org.w3c.dom.Node>
    public open override /*1*/ fun listIterator(/*0*/ p0: jet.Int): java.util.ListIterator<org.w3c.dom.Node>
    protected final override /*1*/ var modCount: jet.Int
    internal final val nodeList: org.w3c.dom.NodeList
    public final override /*1*/ fun notify(): jet.Tuple0
    public final override /*1*/ fun notifyAll(): jet.Tuple0
    public open override /*1*/ fun remove(/*0*/ p0: jet.Any?): jet.Boolean
    public open override /*1*/ fun remove(/*0*/ p0: jet.Int): org.w3c.dom.Node?
    public open override /*1*/ fun removeAll(/*0*/ p0: java.util.Collection<out jet.Any?>): jet.Boolean
    protected open override /*1*/ fun removeRange(/*0*/ p0: jet.Int, /*1*/ p1: jet.Int): jet.Tuple0
    public open override /*1*/ fun retainAll(/*0*/ p0: java.util.Collection<out jet.Any?>): jet.Boolean
    public open override /*1*/ fun set(/*0*/ p0: jet.Int, /*1*/ p1: org.w3c.dom.Node): org.w3c.dom.Node
    public open override /*1*/ fun size(): jet.Int
    public open override /*1*/ fun subList(/*0*/ p0: jet.Int, /*1*/ p1: jet.Int): java.util.List<org.w3c.dom.Node>
    public open override /*1*/ fun toArray(): jet.Array<jet.Any?>
    public open override /*1*/ fun </*0*/ T : jet.Any?>toArray(/*0*/ p0: jet.Array<T>): jet.Array<T>
    public open override /*1*/ fun toString(): jet.String?
    public final override /*1*/ fun wait(): jet.Tuple0
    public final override /*1*/ fun wait(/*0*/ p0: jet.Long): jet.Tuple0
    public final override /*1*/ fun wait(/*0*/ p0: jet.Long, /*1*/ p1: jet.Int): jet.Tuple0
}
internal final class kotlin.dom.PreviousSiblingIterator : kotlin.support.AbstractIterator<org.w3c.dom.Node> {
    public final /*constructor*/ fun <init>(/*0*/ node: org.w3c.dom.Node): kotlin.dom.PreviousSiblingIterator
    protected open override /*1*/ fun clone(): jet.Any
    protected open override /*1*/ fun computeNext(): jet.Tuple0
    protected final override /*1*/ fun done(): jet.Tuple0
    public open override /*1*/ fun equals(/*0*/ p0: jet.Any?): jet.Boolean
    public final override /*1*/ fun getClass(): java.lang.Class<out jet.Any?>?
    public open override /*1*/ fun hasNext(): jet.Boolean
    public open override /*1*/ fun hashCode(): jet.Int
    invisible_fake final override /*1*/ fun tryToComputeNext(): jet.Boolean
    invisible_fake final override /*1*/ var next: org.w3c.dom.Node? private get private set
    invisible_fake final override /*1*/ var state: jet.Int private get private set
    protected open override /*1*/ fun finalize(): jet.Tuple0
    public open override /*1*/ fun next(): org.w3c.dom.Node
    internal final var node: org.w3c.dom.Node
    public final override /*1*/ fun notify(): jet.Tuple0
    public final override /*1*/ fun notifyAll(): jet.Tuple0
    internal final override /*1*/ fun peek(): org.w3c.dom.Node
    public open override /*1*/ fun remove(): jet.Tuple0
    protected final override /*1*/ fun setNext(/*0*/ value: org.w3c.dom.Node): jet.Tuple0
    public open override /*1*/ fun toString(): jet.String?
    public final override /*1*/ fun wait(): jet.Tuple0
    public final override /*1*/ fun wait(/*0*/ p0: jet.Long): jet.Tuple0
    public final override /*1*/ fun wait(/*0*/ p0: jet.Long, /*1*/ p1: jet.Int): jet.Tuple0
}
internal final val org.w3c.dom.Node.attributes: org.w3c.dom.NamedNodeMap?
internal final val org.w3c.dom.Node.baseURI: jet.String
internal final val org.w3c.dom.Node.childNodes: org.w3c.dom.NodeList
internal final var org.w3c.dom.Element.classSet: java.util.Set<jet.String>
internal final var org.w3c.dom.Element.classes: jet.String
internal final val org.w3c.dom.Document.documentElement: org.w3c.dom.Element?
internal final val org.w3c.dom.Document?.elements: java.util.List<org.w3c.dom.Element>
internal final val org.w3c.dom.Element?.elements: java.util.List<org.w3c.dom.Element>
internal final val org.w3c.dom.NodeList?.first: org.w3c.dom.Node?
internal final val org.w3c.dom.Node.firstChild: org.w3c.dom.Node?
internal final val org.w3c.dom.NodeList?.head: org.w3c.dom.Node?
internal final var org.w3c.dom.Element.id: jet.String
public final val org.w3c.dom.Node.innerHTML: jet.String
internal final val org.w3c.dom.NodeList?.last: org.w3c.dom.Node?
internal final val org.w3c.dom.Node.lastChild: org.w3c.dom.Node?
internal final val org.w3c.dom.CharacterData.length: jet.Int
internal final val org.w3c.dom.DOMImplementationList.length: jet.Int
internal final val org.w3c.dom.DOMStringList.length: jet.Int
internal final val org.w3c.dom.NameList.length: jet.Int
internal final val org.w3c.dom.NamedNodeMap.length: jet.Int
internal final val org.w3c.dom.NodeList.length: jet.Int
internal final val org.w3c.dom.Node.localName: jet.String
internal final val org.w3c.dom.Node.namespaceURI: jet.String
internal final val org.w3c.dom.Node.nextSibling: org.w3c.dom.Node?
internal final val org.w3c.dom.Node.nodeName: jet.String
internal final val org.w3c.dom.Node.nodeType: jet.Short
internal final val org.w3c.dom.Node.nodeValue: jet.String
public final val org.w3c.dom.Node.outerHTML: jet.String
public final val org.w3c.dom.NodeList.outerHTML: jet.String
internal final val org.w3c.dom.Node.ownerDocument: org.w3c.dom.Document?
internal final val org.w3c.dom.Node.parentNode: org.w3c.dom.Node?
internal final val org.w3c.dom.Node.prefix: jet.String
internal final val org.w3c.dom.Node.previousSibling: org.w3c.dom.Node?
internal final var org.w3c.dom.Element.style: jet.String
internal final val org.w3c.dom.NodeList?.tail: org.w3c.dom.Node?
internal final var org.w3c.dom.Node.text: jet.String
internal final var org.w3c.dom.Node.textContent: jet.String
internal final fun org.w3c.dom.Element.addClass(/*0*/ cssClass: jet.String): jet.Boolean
internal final fun org.w3c.dom.Document.addElement(/*0*/ name: jet.String, /*1*/ init: jet.ExtensionFunction0<org.w3c.dom.Element, jet.Tuple0>): org.w3c.dom.Element
internal final fun org.w3c.dom.Element.addElement(/*0*/ name: jet.String, /*1*/ doc: org.w3c.dom.Document? = ?, /*2*/ init: jet.ExtensionFunction0<org.w3c.dom.Element, jet.Tuple0>): org.w3c.dom.Element
internal final fun org.w3c.dom.Element.addText(/*0*/ text: jet.String?, /*1*/ doc: org.w3c.dom.Document? = ?): org.w3c.dom.Element
internal final fun org.w3c.dom.Element.attribute(/*0*/ name: jet.String): jet.String
internal final fun org.w3c.dom.Element?.children(): java.util.List<org.w3c.dom.Node>
public final fun createDocument(/*0*/ builder: javax.xml.parsers.DocumentBuilder): org.w3c.dom.Document
public final fun createDocument(/*0*/ builderFactory: javax.xml.parsers.DocumentBuilderFactory = ?): org.w3c.dom.Document
internal final fun org.w3c.dom.Document.createElement(/*0*/ name: jet.String, /*1*/ init: jet.ExtensionFunction0<org.w3c.dom.Element, jet.Tuple0>): org.w3c.dom.Element
internal final fun org.w3c.dom.Element.createElement(/*0*/ name: jet.String, /*1*/ doc: org.w3c.dom.Document? = ?, /*2*/ init: jet.ExtensionFunction0<org.w3c.dom.Element, jet.Tuple0>): org.w3c.dom.Element
public final fun createTransformer(/*0*/ source: javax.xml.transform.Source? = ?, /*1*/ factory: javax.xml.transform.TransformerFactory = ?): javax.xml.transform.Transformer
public final fun defaultDocumentBuilder(/*0*/ builderFactory: javax.xml.parsers.DocumentBuilderFactory = ?): javax.xml.parsers.DocumentBuilder
public final fun defaultDocumentBuilderFactory(): javax.xml.parsers.DocumentBuilderFactory
internal final fun org.w3c.dom.Document?.elements(/*0*/ localName: jet.String): java.util.List<org.w3c.dom.Element>
internal final fun org.w3c.dom.Document?.elements(/*0*/ namespaceUri: jet.String, /*1*/ localName: jet.String): java.util.List<org.w3c.dom.Element>
internal final fun org.w3c.dom.Element?.elements(/*0*/ localName: jet.String): java.util.List<org.w3c.dom.Element>
internal final fun org.w3c.dom.Element?.elements(/*0*/ namespaceUri: jet.String, /*1*/ localName: jet.String): java.util.List<org.w3c.dom.Element>
private final fun emptyElementList(): java.util.List<org.w3c.dom.Element>
private final fun emptyNodeList(): java.util.List<org.w3c.dom.Node>
internal final fun org.w3c.dom.Document?.get(/*0*/ selector: jet.String): java.util.List<org.w3c.dom.Element>
internal final fun org.w3c.dom.Element.get(/*0*/ selector: jet.String): java.util.List<org.w3c.dom.Element>
internal final fun org.w3c.dom.Element.hasClass(/*0*/ cssClass: jet.String): jet.Boolean
internal final fun org.w3c.dom.Node.isText(): jet.Boolean
internal final fun org.w3c.dom.Node.nextElements(): java.util.Iterator<org.w3c.dom.Element>
internal final fun org.w3c.dom.Node.nextSiblings(): java.util.Iterator<org.w3c.dom.Node>
public final fun nodesToXmlString(/*0*/ nodes: java.lang.Iterable<org.w3c.dom.Node>, /*1*/ xmlDeclaration: jet.Boolean = ?): jet.String
internal final fun org.w3c.dom.Node.ownerDocument(/*0*/ doc: org.w3c.dom.Document? = ?): org.w3c.dom.Document
public final fun parseXml(/*0*/ file: java.io.File, /*1*/ builder: javax.xml.parsers.DocumentBuilder = ?): org.w3c.dom.Document
public final fun parseXml(/*0*/ inputSource: org.xml.sax.InputSource, /*1*/ builder: javax.xml.parsers.DocumentBuilder = ?): org.w3c.dom.Document
public final fun parseXml(/*0*/ inputStream: java.io.InputStream, /*1*/ builder: javax.xml.parsers.DocumentBuilder = ?): org.w3c.dom.Document
public final fun parseXml(/*0*/ uri: jet.String, /*1*/ builder: javax.xml.parsers.DocumentBuilder = ?): org.w3c.dom.Document
internal final fun org.w3c.dom.Element.plus(/*0*/ text: jet.String?): org.w3c.dom.Element
internal final fun org.w3c.dom.Node.plus(/*0*/ child: org.w3c.dom.Node?): org.w3c.dom.Node
internal final fun org.w3c.dom.Element.plusAssign(/*0*/ text: jet.String?): org.w3c.dom.Element
internal final fun org.w3c.dom.Node.previousElements(): java.util.Iterator<org.w3c.dom.Element>
internal final fun org.w3c.dom.Node.previousSiblings(): java.util.Iterator<org.w3c.dom.Node>
internal final fun org.w3c.dom.Element.removeClass(/*0*/ cssClass: jet.String): jet.Boolean
internal final fun org.w3c.dom.NodeList?.toElementList(): java.util.List<org.w3c.dom.Element>
internal final fun org.w3c.dom.NodeList?.toList(): java.util.List<org.w3c.dom.Node>
public final fun org.w3c.dom.Node.toXmlString(): jet.String
public final fun org.w3c.dom.Node.toXmlString(/*0*/ xmlDeclaration: jet.Boolean): jet.String
internal final fun org.w3c.dom.NodeList?.toXmlString(/*0*/ xmlDeclaration: jet.Boolean = ?): jet.String
public final fun org.w3c.dom.Node.writeXmlString(/*0*/ writer: java.io.Writer, /*1*/ xmlDeclaration: jet.Boolean): jet.Tuple0
// </namespace name="dom">
// <namespace name="io">
namespace io

internal final class kotlin.io.LineIterator : jet.Iterator<jet.String> {
    public final /*constructor*/ fun <init>(/*0*/ reader: java.io.BufferedReader): kotlin.io.LineIterator
    private final var done: jet.Boolean
    public open override /*1*/ val hasNext: jet.Boolean
    public open override /*1*/ fun next(): jet.String
    private final var nextValue: jet.String?
    internal final val reader: java.io.BufferedReader
}
internal final val java.io.File.canonicalPath: jet.String
public final val defaultBufferSize: jet.Int
public final val defaultCharset: java.nio.charset.Charset
internal final val java.io.File.directory: java.io.File
internal final val java.io.File.extension: jet.String
internal final val java.io.File.name: jet.String
internal final val java.io.File.path: jet.String
private final val stdin: java.io.BufferedReader
public final fun java.io.InputStream.buffered(/*0*/ bufferSize: jet.Int = ?): java.io.InputStream
public final fun java.io.OutputStream.buffered(/*0*/ bufferSize: jet.Int = ?): java.io.BufferedOutputStream
public final fun java.io.Reader.buffered(/*0*/ bufferSize: jet.Int = ?): java.io.BufferedReader
public final fun java.io.Writer.buffered(/*0*/ bufferSize: jet.Int = ?): java.io.BufferedWriter
public final fun java.io.File.copyTo(/*0*/ file: java.io.File, /*1*/ bufferSize: jet.Int = ?): jet.Long
public final fun java.io.InputStream.copyTo(/*0*/ out: java.io.OutputStream, /*1*/ bufferSize: jet.Int = ?): jet.Long
public final fun java.io.Reader.copyTo(/*0*/ out: java.io.Writer, /*1*/ bufferSize: jet.Int = ?): jet.Long
internal final fun java.io.File.forEachBlock(/*0*/ closure: jet.Function2<jet.ByteArray, jet.Int, jet.Tuple0>): jet.Tuple0
public final fun java.io.File.forEachLine(/*0*/ block: jet.Function1<jet.String, jet.Any>): jet.Tuple0
internal final fun java.io.File.forEachLine(/*0*/ charset: jet.String = ?, /*1*/ closure: jet.Function1<jet.String, jet.Tuple0>): jet.Tuple0
public final fun java.io.Reader.forEachLine(/*0*/ block: jet.Function1<jet.String, jet.Any>): jet.Tuple0
public final fun java.io.File.isDescendant(/*0*/ file: java.io.File): jet.Boolean
public final fun java.io.InputStream.iterator(): jet.ByteIterator
public final fun java.io.BufferedReader.lineIterator(): jet.Iterator<jet.String>
internal final fun java.io.File.listFiles(/*0*/ filter: jet.Function1<java.io.File, jet.Boolean>): jet.Array<java.io.File>?
public final fun print(/*0*/ message: jet.Any?): jet.Tuple0
public final fun print(/*0*/ message: jet.Boolean): jet.Tuple0
public final fun print(/*0*/ message: jet.Byte): jet.Tuple0
public final fun print(/*0*/ message: jet.Char): jet.Tuple0
public final fun print(/*0*/ message: jet.CharArray): jet.Tuple0
public final fun print(/*0*/ message: jet.Double): jet.Tuple0
public final fun print(/*0*/ message: jet.Float): jet.Tuple0
public final fun print(/*0*/ message: jet.Int): jet.Tuple0
public final fun print(/*0*/ message: jet.Long): jet.Tuple0
public final fun print(/*0*/ message: jet.Short): jet.Tuple0
public final fun println(): jet.Tuple0
public final fun println(/*0*/ message: jet.Any?): jet.Tuple0
public final fun println(/*0*/ message: jet.Boolean): jet.Tuple0
public final fun println(/*0*/ message: jet.Byte): jet.Tuple0
public final fun println(/*0*/ message: jet.Char): jet.Tuple0
public final fun println(/*0*/ message: jet.CharArray): jet.Tuple0
public final fun println(/*0*/ message: jet.Double): jet.Tuple0
public final fun println(/*0*/ message: jet.Float): jet.Tuple0
public final fun println(/*0*/ message: jet.Int): jet.Tuple0
public final fun println(/*0*/ message: jet.Long): jet.Tuple0
public final fun println(/*0*/ message: jet.Short): jet.Tuple0
public final fun java.io.File.readBytes(): jet.ByteArray
public final fun java.io.InputStream.readBytes(/*0*/ estimatedSize: jet.Int = ?): jet.ByteArray
public final fun java.net.URL.readBytes(): jet.ByteArray
public final fun readLine(): jet.String?
internal final fun java.io.File.readLines(/*0*/ charset: jet.String = ?): java.util.List<jet.String>
public final fun java.io.File.readText(/*0*/ encoding: java.nio.charset.Charset): jet.String
public final fun java.io.File.readText(/*0*/ encoding: jet.String? = ?): jet.String
public final fun java.io.Reader.readText(): jet.String
public final fun java.net.URL.readText(/*0*/ encoding: java.nio.charset.Charset): jet.String
public final fun java.net.URL.readText(/*0*/ encoding: jet.String? = ?): jet.String
public final fun java.io.File.reader(): java.io.FileReader
public final fun java.io.InputStream.reader(/*0*/ encoding: java.nio.charset.Charset = ?): java.io.InputStreamReader
public final fun java.io.InputStream.reader(/*0*/ encoding: java.nio.charset.CharsetDecoder): java.io.InputStreamReader
public final fun java.io.InputStream.reader(/*0*/ encoding: jet.String): java.io.InputStreamReader
public final fun java.io.File.recurse(/*0*/ block: jet.Function1<java.io.File, jet.Tuple0>): jet.Tuple0
public final fun java.io.File.relativePath(/*0*/ descendant: java.io.File): jet.String
public final fun </*0*/ T : java.io.Closeable, /*1*/ R : jet.Any?>T.use(/*0*/ block: jet.Function1<T, R>): R
public final fun </*0*/ T : jet.Any?>java.io.Reader.useLines(/*0*/ block: jet.Function1<jet.Iterator<jet.String>, T>): T
public final fun java.io.File.writeBytes(/*0*/ data: jet.ByteArray): jet.Tuple0
public final fun java.io.File.writeText(/*0*/ text: jet.String, /*1*/ encoding: java.nio.charset.Charset): jet.Tuple0
public final fun java.io.File.writeText(/*0*/ text: jet.String, /*1*/ encoding: jet.String? = ?): jet.Tuple0
public final fun java.io.OutputStream.writer(/*0*/ encoding: java.nio.charset.Charset = ?): java.io.OutputStreamWriter
public final fun java.io.OutputStream.writer(/*0*/ encoding: java.nio.charset.CharsetEncoder): java.io.OutputStreamWriter
public final fun java.io.OutputStream.writer(/*0*/ encoding: jet.String): java.io.OutputStreamWriter
// </namespace name="io">
// <namespace name="math">
namespace math

public final fun java.math.BigDecimal.div(/*0*/ other: java.math.BigDecimal): java.math.BigDecimal
public final fun java.math.BigInteger.div(/*0*/ other: java.math.BigInteger): java.math.BigInteger
public final fun java.math.BigDecimal.minus(): java.math.BigDecimal
public final fun java.math.BigDecimal.minus(/*0*/ other: java.math.BigDecimal): java.math.BigDecimal
public final fun java.math.BigInteger.minus(): java.math.BigInteger
public final fun java.math.BigInteger.minus(/*0*/ other: java.math.BigInteger): java.math.BigInteger
public final fun java.math.BigDecimal.mod(/*0*/ other: java.math.BigDecimal): java.math.BigDecimal
public final fun java.math.BigDecimal.plus(/*0*/ other: java.math.BigDecimal): java.math.BigDecimal
public final fun java.math.BigInteger.plus(/*0*/ other: java.math.BigInteger): java.math.BigInteger
public final fun java.math.BigDecimal.times(/*0*/ other: java.math.BigDecimal): java.math.BigDecimal
public final fun java.math.BigInteger.times(/*0*/ other: java.math.BigInteger): java.math.BigInteger
// </namespace name="math">
// <namespace name="modules">
namespace modules

internal final class kotlin.modules.AnnotationsPathBuilder : jet.Any {
    public final /*constructor*/ fun <init>(/*0*/ parent: kotlin.modules.ModuleBuilder): kotlin.modules.AnnotationsPathBuilder
    internal final val parent: kotlin.modules.ModuleBuilder
    public final fun plusAssign(/*0*/ name: jet.String): jet.Tuple0
}
internal final class kotlin.modules.ClasspathBuilder : jet.Any {
    public final /*constructor*/ fun <init>(/*0*/ parent: kotlin.modules.ModuleBuilder): kotlin.modules.ClasspathBuilder
    internal final val parent: kotlin.modules.ModuleBuilder
    public final fun plusAssign(/*0*/ name: jet.String): jet.Tuple0
}
internal open class kotlin.modules.ModuleBuilder {
    public final /*constructor*/ fun <init>(/*0*/ name: jet.String): kotlin.modules.ModuleBuilder
    public final fun addAnnotationsPathEntry(/*0*/ name: jet.String): jet.Tuple0
    public final fun addClasspathEntry(/*0*/ name: jet.String): jet.Tuple0
    public final fun addSourceFiles(/*0*/ pattern: jet.String): jet.Tuple0
    internal final val annotationsPath: kotlin.modules.AnnotationsPathBuilder
    private final val annotationsRoots0: java.util.ArrayList<jet.String?>
    internal final val classpath: kotlin.modules.ClasspathBuilder
    private final val classpathRoots0: java.util.ArrayList<jet.String?>
    public open fun getAnnotationsRoots(): java.util.List<jet.String?>?
    public open fun getClasspathRoots(): java.util.List<jet.String?>?
    public open fun getModuleName(): jet.String?
    public open fun getSourceFiles(): java.util.List<jet.String?>?
    internal final val name: jet.String
    private final val sourceFiles0: java.util.ArrayList<jet.String?>
    internal final val sources: kotlin.modules.SourcesBuilder
}
internal final class kotlin.modules.SourcesBuilder : jet.Any {
    public final /*constructor*/ fun <init>(/*0*/ parent: kotlin.modules.ModuleBuilder): kotlin.modules.SourcesBuilder
    internal final val parent: kotlin.modules.ModuleBuilder
    public final fun plusAssign(/*0*/ pattern: jet.String): jet.Tuple0
}
public final fun module(/*0*/ name: jet.String, /*1*/ callback: jet.ExtensionFunction0<kotlin.modules.ModuleBuilder, jet.Tuple0>): jet.Tuple0
// </namespace name="modules">
// <namespace name="nullable">
namespace nullable

public final fun </*0*/ T : jet.Any?>T?.all(/*0*/ predicate: jet.Function1<T, jet.Boolean>): jet.Boolean
public final fun </*0*/ T : jet.Any?>T?.any(/*0*/ predicate: jet.Function1<T, jet.Boolean>): jet.Boolean
public final fun </*0*/ T : jet.Any?>T?.count(/*0*/ predicate: jet.Function1<T, jet.Boolean>): jet.Int
public final fun </*0*/ T : jet.Any?>T?.filter(/*0*/ predicate: jet.Function1<T, jet.Boolean>): T?
public final fun </*0*/ T : jet.Any?>T?.filterNot(/*0*/ predicate: jet.Function1<T, jet.Boolean>): java.util.Collection<T>
public final fun </*0*/ T : jet.Any?>T?.filterNotNull(): java.util.Collection<T>
public final fun </*0*/ T : jet.Any?, /*1*/ C : java.util.Collection<in T>>T?.filterNotNullTo(/*0*/ result: C): C
public final fun </*0*/ T : jet.Any?, /*1*/ C : java.util.Collection<in T>>T?.filterNotTo(/*0*/ result: C, /*1*/ predicate: jet.Function1<T, jet.Boolean>): C
public final fun </*0*/ T : jet.Any?, /*1*/ C : java.util.Collection<in T>>T?.filterTo(/*0*/ result: C, /*1*/ predicate: jet.Function1<T, jet.Boolean>): C
public final fun </*0*/ T : jet.Any?>T?.find(/*0*/ predicate: jet.Function1<T, jet.Boolean>): T?
public final fun </*0*/ T : jet.Any?, /*1*/ R : jet.Any?>T?.flatMap(/*0*/ transform: jet.Function1<T, java.util.Collection<R>>): java.util.Collection<R>
public final fun </*0*/ T : jet.Any?, /*1*/ R : jet.Any?>T?.flatMapTo(/*0*/ result: java.util.Collection<R>, /*1*/ transform: jet.Function1<T, java.util.Collection<R>>): java.util.Collection<R>
public final fun </*0*/ T : jet.Any?>T?.fold(/*0*/ initial: T, /*1*/ operation: jet.Function2<T, T, T>): T
public final fun </*0*/ T : jet.Any?>T?.foldRight(/*0*/ initial: T, /*1*/ operation: jet.Function2<T, T, T>): T
public final fun </*0*/ T : jet.Any?>T?.forEach(/*0*/ operation: jet.Function1<T, jet.Tuple0>): jet.Tuple0
public final fun </*0*/ T : jet.Any?, /*1*/ K : jet.Any?>T?.groupBy(/*0*/ result: java.util.Map<K, java.util.List<T>> = ?, /*1*/ toKey: jet.Function1<T, K>): java.util.Map<K, java.util.List<T>>
public final fun </*0*/ T : jet.Any?>T?.makeString(/*0*/ separator: jet.String = ?, /*1*/ prefix: jet.String = ?, /*2*/ postfix: jet.String = ?): jet.String
public final fun </*0*/ T : jet.Any?, /*1*/ R : jet.Any?>T?.map(/*0*/ transform: jet.Function1<T, R>): R?
public final fun </*0*/ T : jet.Any?, /*1*/ R : jet.Any?, /*2*/ C : java.util.Collection<in R>>T?.mapTo(/*0*/ result: C, /*1*/ transform: jet.Function1<T, R>): C
public final fun </*0*/ T : jet.Any?>T?.reverse(): T?
public final fun </*0*/ T : jet.Any?, /*1*/ C : java.util.Collection<T>>T?.toCollection(/*0*/ result: C): C
public final fun </*0*/ T : jet.Any?>T?.toLinkedList(): java.util.LinkedList<T>
public final fun </*0*/ T : jet.Any?>T?.toList(): java.util.List<T>
public final fun </*0*/ T : jet.Any?>T?.toSet(): java.util.Set<T>
public final fun </*0*/ T : jet.Any?>T?.toSortedSet(): java.util.SortedSet<T>
// </namespace name="nullable">
// <namespace name="properties">
namespace properties

public final class kotlin.properties.ChangeEvent : jet.Any {
    public final /*constructor*/ fun <init>(/*0*/ source: jet.Any, /*1*/ name: jet.String, /*2*/ oldValue: jet.Any?, /*3*/ newValue: jet.Any?): kotlin.properties.ChangeEvent
    internal final val name: jet.String
    internal final val newValue: jet.Any?
    internal final val oldValue: jet.Any?
    internal final var propogationId: jet.Any?
    internal final val source: jet.Any
    public final fun toString(): jet.String
}
public abstract trait kotlin.properties.ChangeListener : jet.Any {
    public abstract fun onPropertyChange(/*0*/ event: kotlin.properties.ChangeEvent): jet.Tuple0
}
public abstract class kotlin.properties.ChangeSupport : jet.Any {
    public final /*constructor*/ fun <init>(): kotlin.properties.ChangeSupport
    public final fun addChangeListener(/*0*/ listener: kotlin.properties.ChangeListener): jet.Tuple0
    public final fun addChangeListener(/*0*/ name: jet.String, /*1*/ listener: kotlin.properties.ChangeListener): jet.Tuple0
    private final var allListeners: java.util.List<kotlin.properties.ChangeListener>?
    protected final fun </*0*/ T : jet.Any?>changeProperty(/*0*/ name: jet.String, /*1*/ oldValue: T?, /*2*/ newValue: T?): jet.Tuple0
    protected final fun firePropertyChanged(/*0*/ event: kotlin.properties.ChangeEvent): jet.Tuple0
    private final var nameListeners: java.util.Map<jet.String, java.util.List<kotlin.properties.ChangeListener>>?
    public final fun onPropertyChange(/*0*/ fn: jet.Function1<kotlin.properties.ChangeEvent, jet.Tuple0>): jet.Tuple0
    public final fun onPropertyChange(/*0*/ name: jet.String, /*1*/ fn: jet.Function1<kotlin.properties.ChangeEvent, jet.Tuple0>): jet.Tuple0
}
// </namespace name="properties">
// <namespace name="support">
namespace support

public abstract class kotlin.support.AbstractIterator</*0*/ T : jet.Any?> : java.util.Iterator<T> {
    public final /*constructor*/ fun </*0*/ T : jet.Any?><init>(): kotlin.support.AbstractIterator<T>
    protected open override /*1*/ fun clone(): jet.Any
    protected abstract fun computeNext(): jet.Tuple0
    protected final fun done(): jet.Tuple0
    public open override /*1*/ fun equals(/*0*/ p0: jet.Any?): jet.Boolean
    public final override /*1*/ fun getClass(): java.lang.Class<out jet.Any?>?
    public open override /*1*/ fun hasNext(): jet.Boolean
    public open override /*1*/ fun hashCode(): jet.Int
    protected open override /*1*/ fun finalize(): jet.Tuple0
    public open override /*1*/ fun next(): T
    private final var next: T?
    public final override /*1*/ fun notify(): jet.Tuple0
    public final override /*1*/ fun notifyAll(): jet.Tuple0
    internal final fun peek(): T
    public open override /*1*/ fun remove(): jet.Tuple0
    protected final fun setNext(/*0*/ value: T): jet.Tuple0
    private final var state: jet.Int
    public open override /*1*/ fun toString(): jet.String?
    private final fun tryToComputeNext(): jet.Boolean
    public final override /*1*/ fun wait(): jet.Tuple0
    public final override /*1*/ fun wait(/*0*/ p0: jet.Long): jet.Tuple0
    public final override /*1*/ fun wait(/*0*/ p0: jet.Long, /*1*/ p1: jet.Int): jet.Tuple0
}
internal final class kotlin.support.CompositeIterator</*0*/ T : jet.Any?> : kotlin.support.AbstractIterator<T> {
    public final /*constructor*/ fun </*0*/ T : jet.Any?><init>(/*0*/ vararg iterators: java.util.Iterator<T> /*jet.Array<java.util.Iterator<T>>*/): kotlin.support.CompositeIterator<T>
    protected open override /*1*/ fun clone(): jet.Any
    protected open override /*1*/ fun computeNext(): jet.Tuple0
    internal final var currentIter: java.util.Iterator<T>?
    protected final override /*1*/ fun done(): jet.Tuple0
    public open override /*1*/ fun equals(/*0*/ p0: jet.Any?): jet.Boolean
    public final override /*1*/ fun getClass(): java.lang.Class<out jet.Any?>?
    public open override /*1*/ fun hasNext(): jet.Boolean
    public open override /*1*/ fun hashCode(): jet.Int
    invisible_fake final override /*1*/ fun tryToComputeNext(): jet.Boolean
    invisible_fake final override /*1*/ var next: T? private get private set
    invisible_fake final override /*1*/ var state: jet.Int private get private set
    internal final val iteratorsIter: jet.Iterator<java.util.Iterator<T>>
    protected open override /*1*/ fun finalize(): jet.Tuple0
    public open override /*1*/ fun next(): T
    public final override /*1*/ fun notify(): jet.Tuple0
    public final override /*1*/ fun notifyAll(): jet.Tuple0
    internal final override /*1*/ fun peek(): T
    public open override /*1*/ fun remove(): jet.Tuple0
    protected final override /*1*/ fun setNext(/*0*/ value: T): jet.Tuple0
    public open override /*1*/ fun toString(): jet.String?
    public final override /*1*/ fun wait(): jet.Tuple0
    public final override /*1*/ fun wait(/*0*/ p0: jet.Long): jet.Tuple0
    public final override /*1*/ fun wait(/*0*/ p0: jet.Long, /*1*/ p1: jet.Int): jet.Tuple0
}
internal final class kotlin.support.FunctionIterator</*0*/ T : jet.Any?> : kotlin.support.AbstractIterator<T> {
    public final /*constructor*/ fun </*0*/ T : jet.Any?><init>(/*0*/ nextFunction: jet.Function0<T?>): kotlin.support.FunctionIterator<T>
    protected open override /*1*/ fun clone(): jet.Any
    protected open override /*1*/ fun computeNext(): jet.Tuple0
    protected final override /*1*/ fun done(): jet.Tuple0
    public open override /*1*/ fun equals(/*0*/ p0: jet.Any?): jet.Boolean
    public final override /*1*/ fun getClass(): java.lang.Class<out jet.Any?>?
    public open override /*1*/ fun hasNext(): jet.Boolean
    public open override /*1*/ fun hashCode(): jet.Int
    invisible_fake final override /*1*/ fun tryToComputeNext(): jet.Boolean
    invisible_fake final override /*1*/ var next: T? private get private set
    invisible_fake final override /*1*/ var state: jet.Int private get private set
    protected open override /*1*/ fun finalize(): jet.Tuple0
    public open override /*1*/ fun next(): T
    internal final val nextFunction: jet.Function0<T?>
    public final override /*1*/ fun notify(): jet.Tuple0
    public final override /*1*/ fun notifyAll(): jet.Tuple0
    internal final override /*1*/ fun peek(): T
    public open override /*1*/ fun remove(): jet.Tuple0
    protected final override /*1*/ fun setNext(/*0*/ value: T): jet.Tuple0
    public open override /*1*/ fun toString(): jet.String?
    public final override /*1*/ fun wait(): jet.Tuple0
    public final override /*1*/ fun wait(/*0*/ p0: jet.Long): jet.Tuple0
    public final override /*1*/ fun wait(/*0*/ p0: jet.Long, /*1*/ p1: jet.Int): jet.Tuple0
}
internal final class kotlin.support.SingleIterator</*0*/ T : jet.Any?> : kotlin.support.AbstractIterator<T> {
    public final /*constructor*/ fun </*0*/ T : jet.Any?><init>(/*0*/ value: T): kotlin.support.SingleIterator<T>
    protected open override /*1*/ fun clone(): jet.Any
    protected open override /*1*/ fun computeNext(): jet.Tuple0
    protected final override /*1*/ fun done(): jet.Tuple0
    public open override /*1*/ fun equals(/*0*/ p0: jet.Any?): jet.Boolean
    internal final var first: jet.Boolean
    public final override /*1*/ fun getClass(): java.lang.Class<out jet.Any?>?
    public open override /*1*/ fun hasNext(): jet.Boolean
    public open override /*1*/ fun hashCode(): jet.Int
    invisible_fake final override /*1*/ fun tryToComputeNext(): jet.Boolean
    invisible_fake final override /*1*/ var next: T? private get private set
    invisible_fake final override /*1*/ var state: jet.Int private get private set
    protected open override /*1*/ fun finalize(): jet.Tuple0
    public open override /*1*/ fun next(): T
    public final override /*1*/ fun notify(): jet.Tuple0
    public final override /*1*/ fun notifyAll(): jet.Tuple0
    internal final override /*1*/ fun peek(): T
    public open override /*1*/ fun remove(): jet.Tuple0
    protected final override /*1*/ fun setNext(/*0*/ value: T): jet.Tuple0
    public open override /*1*/ fun toString(): jet.String?
    internal final val value: T
    public final override /*1*/ fun wait(): jet.Tuple0
    public final override /*1*/ fun wait(/*0*/ p0: jet.Long): jet.Tuple0
    public final override /*1*/ fun wait(/*0*/ p0: jet.Long, /*1*/ p1: jet.Int): jet.Tuple0
}
internal final val State: kotlin.support.State
// </namespace name="support">
// <namespace name="template">
namespace template

public abstract trait kotlin.template.Formatter : jet.Any {
    public abstract fun format(/*0*/ buffer: java.lang.Appendable, /*1*/ value: jet.Any?): jet.Tuple0
}
public final class kotlin.template.HtmlFormatter : kotlin.template.LocaleFormatter {
    public final /*constructor*/ fun <init>(/*0*/ locale: java.util.Locale = ?): kotlin.template.HtmlFormatter
    public final override /*1*/ var dateFormat: java.text.DateFormat
    public open override /*1*/ fun format(/*0*/ buffer: java.lang.Appendable, /*1*/ text: jet.String): jet.Tuple0
    public final override /*1*/ fun format(/*0*/ date: java.util.Date): jet.String
    public final override /*1*/ fun format(/*0*/ number: jet.Number): jet.String
    public open override /*1*/ fun format(/*0*/ out: java.lang.Appendable, /*1*/ value: jet.Any?): jet.Tuple0
    internal final override /*1*/ val locale: java.util.Locale
    internal final override /*1*/ var nullString: jet.String
    public final override /*1*/ var numberFormat: java.text.NumberFormat
    public open override /*1*/ fun toString(): jet.String
}
public open class kotlin.template.LocaleFormatter : kotlin.template.ToStringFormatter {
    public final /*constructor*/ fun <init>(/*0*/ locale: java.util.Locale = ?): kotlin.template.LocaleFormatter
    public final var dateFormat: java.text.DateFormat
    public final fun format(/*0*/ date: java.util.Date): jet.String
    public final fun format(/*0*/ number: jet.Number): jet.String
    public open override /*1*/ fun format(/*0*/ out: java.lang.Appendable, /*1*/ text: jet.String): jet.Tuple0
    public open override /*1*/ fun format(/*0*/ out: java.lang.Appendable, /*1*/ value: jet.Any?): jet.Tuple0
    internal final val locale: java.util.Locale
    internal final override /*1*/ var nullString: jet.String
    public final var numberFormat: java.text.NumberFormat
    public open override /*1*/ fun toString(): jet.String
}
internal final class kotlin.template.StringTemplate : jet.Any {
    public final /*constructor*/ fun <init>(/*0*/ values: jet.Array<jet.Any?>): kotlin.template.StringTemplate
    public final fun forEach(/*0*/ fn: jet.Function1<jet.Any?, jet.Tuple0>): jet.Tuple0
    public final fun toString(): jet.String
    internal final val values: jet.Array<jet.Any?>
}
public open class kotlin.template.ToStringFormatter : kotlin.template.Formatter {
    public final /*constructor*/ fun <init>(): kotlin.template.ToStringFormatter
    public open fun format(/*0*/ out: java.lang.Appendable, /*1*/ text: jet.String): jet.Tuple0
    public open override /*1*/ fun format(/*0*/ out: java.lang.Appendable, /*1*/ value: jet.Any?): jet.Tuple0
    internal final var nullString: jet.String
    public open fun toString(): jet.String
}
public final val defaultLocale: java.util.Locale
public final fun kotlin.template.StringTemplate.append(/*0*/ out: java.lang.Appendable, /*1*/ formatter: kotlin.template.Formatter): jet.Tuple0
public final fun kotlin.template.StringTemplate.toHtml(/*0*/ formatter: kotlin.template.HtmlFormatter = ?): jet.String
public final fun kotlin.template.StringTemplate.toLocale(/*0*/ formatter: kotlin.template.LocaleFormatter = ?): jet.String
public final fun kotlin.template.StringTemplate.toString(/*0*/ formatter: kotlin.template.Formatter): jet.String
// </namespace name="template">
// <namespace name="test">
namespace test

internal abstract trait kotlin.test.Asserter : jet.Any {
    public abstract fun assertEquals(/*0*/ message: jet.String, /*1*/ expected: jet.Any?, /*2*/ actual: jet.Any?): jet.Tuple0
    public abstract fun assertNotNull(/*0*/ message: jet.String, /*1*/ actual: jet.Any?): jet.Tuple0
    public abstract fun assertNull(/*0*/ message: jet.String, /*1*/ actual: jet.Any?): jet.Tuple0
    public abstract fun assertTrue(/*0*/ message: jet.String, /*1*/ actual: jet.Boolean): jet.Tuple0
    public abstract fun fail(/*0*/ message: jet.String): jet.Tuple0
}
internal final class kotlin.test.DefaultAsserter : kotlin.test.Asserter {
    public final /*constructor*/ fun <init>(): kotlin.test.DefaultAsserter
    public open override /*1*/ fun assertEquals(/*0*/ message: jet.String, /*1*/ expected: jet.Any?, /*2*/ actual: jet.Any?): jet.Tuple0
    public open override /*1*/ fun assertNotNull(/*0*/ message: jet.String, /*1*/ actual: jet.Any?): jet.Tuple0
    public open override /*1*/ fun assertNull(/*0*/ message: jet.String, /*1*/ actual: jet.Any?): jet.Tuple0
    public open override /*1*/ fun assertTrue(/*0*/ message: jet.String, /*1*/ actual: jet.Boolean): jet.Tuple0
    public open override /*1*/ fun fail(/*0*/ message: jet.String): jet.Tuple0
}
private final var _asserter: kotlin.test.Asserter?
public final var asserter: kotlin.test.Asserter
public final fun assertEquals(/*0*/ expected: jet.Any?, /*1*/ actual: jet.Any?, /*2*/ message: jet.String = ?): jet.Tuple0
public final fun assertFalse(/*0*/ actual: jet.Boolean, /*1*/ message: jet.String = ?): jet.Tuple0
public final fun assertNot(/*0*/ block: jet.Function0<jet.Boolean>): jet.Tuple0
public final fun assertNot(/*0*/ message: jet.String, /*1*/ block: jet.Function0<jet.Boolean>): jet.Tuple0
public final fun </*0*/ T : jet.Any?>assertNotNull(/*0*/ actual: T?, /*1*/ message: jet.String = ?): T
public final fun </*0*/ T : jet.Any?, /*1*/ R : jet.Any?>assertNotNull(/*0*/ actual: T?, /*1*/ message: jet.String = ?, /*2*/ block: jet.Function1<T, R>): jet.Tuple0
public final fun assertNull(/*0*/ actual: jet.Any?, /*1*/ message: jet.String = ?): jet.Tuple0
public final fun assertTrue(/*0*/ actual: jet.Boolean, /*1*/ message: jet.String = ?): jet.Tuple0
public final fun assertTrue(/*0*/ block: jet.Function0<jet.Boolean>): jet.Tuple0
public final fun assertTrue(/*0*/ message: jet.String, /*1*/ block: jet.Function0<jet.Boolean>): jet.Tuple0
public final fun </*0*/ T : jet.Any?>expect(/*0*/ expected: T, /*1*/ block: jet.Function0<T>): jet.Tuple0
public final fun </*0*/ T : jet.Any?>expect(/*0*/ expected: T, /*1*/ message: jet.String, /*2*/ block: jet.Function0<T>): jet.Tuple0
public final fun fail(/*0*/ message: jet.String = ?): jet.Tuple0
public final fun fails(/*0*/ block: jet.Function0<jet.Tuple0>): jet.Throwable?
public final fun </*0*/ T : jet.Throwable>failsWith(/*0*/ block: jet.Function0<jet.Any>): T
public final fun todo(/*0*/ block: jet.Function0<jet.Any>): jet.Tuple0
// </namespace name="test">
// <namespace name="util">
namespace util

public final fun measureTimeMillis(/*0*/ block: jet.Function0<jet.Tuple0>): jet.Long
public final fun measureTimeNano(/*0*/ block: jet.Function0<jet.Tuple0>): jet.Long
// </namespace name="util">
private final class kotlin.FilterIsIterator</*0*/ T : jet.Any?, /*1*/ R : T> : kotlin.support.AbstractIterator<R> {
    public final /*constructor*/ fun </*0*/ T : jet.Any?, /*1*/ R : T><init>(/*0*/ iterator: java.util.Iterator<T>, /*1*/ klass: java.lang.Class<R>): kotlin.FilterIsIterator<T, R>
    protected open override /*1*/ fun clone(): jet.Any
    protected open override /*1*/ fun computeNext(): jet.Tuple0
    protected final override /*1*/ fun done(): jet.Tuple0
    public open override /*1*/ fun equals(/*0*/ p0: jet.Any?): jet.Boolean
    public final override /*1*/ fun getClass(): java.lang.Class<out jet.Any?>?
    public open override /*1*/ fun hasNext(): jet.Boolean
    public open override /*1*/ fun hashCode(): jet.Int
    invisible_fake final override /*1*/ fun tryToComputeNext(): jet.Boolean
    invisible_fake final override /*1*/ var next: R? private get private set
    invisible_fake final override /*1*/ var state: jet.Int private get private set
    internal final val iterator: java.util.Iterator<T>
    protected open override /*1*/ fun finalize(): jet.Tuple0
    internal final val klass: java.lang.Class<R>
    public open override /*1*/ fun next(): R
    public final override /*1*/ fun notify(): jet.Tuple0
    public final override /*1*/ fun notifyAll(): jet.Tuple0
    internal final override /*1*/ fun peek(): R
    public open override /*1*/ fun remove(): jet.Tuple0
    protected final override /*1*/ fun setNext(/*0*/ value: R): jet.Tuple0
    public open override /*1*/ fun toString(): jet.String?
    public final override /*1*/ fun wait(): jet.Tuple0
    public final override /*1*/ fun wait(/*0*/ p0: jet.Long): jet.Tuple0
    public final override /*1*/ fun wait(/*0*/ p0: jet.Long, /*1*/ p1: jet.Int): jet.Tuple0
}
private final class kotlin.FilterIterator</*0*/ T : jet.Any?> : kotlin.support.AbstractIterator<T> {
    public final /*constructor*/ fun </*0*/ T : jet.Any?><init>(/*0*/ iterator: java.util.Iterator<T>, /*1*/ predicate: jet.Function1<T, jet.Boolean>): kotlin.FilterIterator<T>
    protected open override /*1*/ fun clone(): jet.Any
    protected open override /*1*/ fun computeNext(): jet.Tuple0
    protected final override /*1*/ fun done(): jet.Tuple0
    public open override /*1*/ fun equals(/*0*/ p0: jet.Any?): jet.Boolean
    public final override /*1*/ fun getClass(): java.lang.Class<out jet.Any?>?
    public open override /*1*/ fun hasNext(): jet.Boolean
    public open override /*1*/ fun hashCode(): jet.Int
    invisible_fake final override /*1*/ fun tryToComputeNext(): jet.Boolean
    invisible_fake final override /*1*/ var next: T? private get private set
    invisible_fake final override /*1*/ var state: jet.Int private get private set
    internal final val iterator: java.util.Iterator<T>
    protected open override /*1*/ fun finalize(): jet.Tuple0
    public open override /*1*/ fun next(): T
    public final override /*1*/ fun notify(): jet.Tuple0
    public final override /*1*/ fun notifyAll(): jet.Tuple0
    internal final override /*1*/ fun peek(): T
    internal final val predicate: jet.Function1<T, jet.Boolean>
    public open override /*1*/ fun remove(): jet.Tuple0
    protected final override /*1*/ fun setNext(/*0*/ value: T): jet.Tuple0
    public open override /*1*/ fun toString(): jet.String?
    public final override /*1*/ fun wait(): jet.Tuple0
    public final override /*1*/ fun wait(/*0*/ p0: jet.Long): jet.Tuple0
    public final override /*1*/ fun wait(/*0*/ p0: jet.Long, /*1*/ p1: jet.Int): jet.Tuple0
}
private final class kotlin.FilterNotNullIterator</*0*/ T : jet.Any?> : kotlin.support.AbstractIterator<T> {
    public final /*constructor*/ fun </*0*/ T : jet.Any?><init>(/*0*/ iterator: java.util.Iterator<T?>?): kotlin.FilterNotNullIterator<T>
    protected open override /*1*/ fun clone(): jet.Any
    protected open override /*1*/ fun computeNext(): jet.Tuple0
    protected final override /*1*/ fun done(): jet.Tuple0
    public open override /*1*/ fun equals(/*0*/ p0: jet.Any?): jet.Boolean
    public final override /*1*/ fun getClass(): java.lang.Class<out jet.Any?>?
    public open override /*1*/ fun hasNext(): jet.Boolean
    public open override /*1*/ fun hashCode(): jet.Int
    invisible_fake final override /*1*/ fun tryToComputeNext(): jet.Boolean
    invisible_fake final override /*1*/ var next: T? private get private set
    invisible_fake final override /*1*/ var state: jet.Int private get private set
    internal final val iterator: java.util.Iterator<T?>?
    protected open override /*1*/ fun finalize(): jet.Tuple0
    public open override /*1*/ fun next(): T
    public final override /*1*/ fun notify(): jet.Tuple0
    public final override /*1*/ fun notifyAll(): jet.Tuple0
    internal final override /*1*/ fun peek(): T
    public open override /*1*/ fun remove(): jet.Tuple0
    protected final override /*1*/ fun setNext(/*0*/ value: T): jet.Tuple0
    public open override /*1*/ fun toString(): jet.String?
    public final override /*1*/ fun wait(): jet.Tuple0
    public final override /*1*/ fun wait(/*0*/ p0: jet.Long): jet.Tuple0
    public final override /*1*/ fun wait(/*0*/ p0: jet.Long, /*1*/ p1: jet.Int): jet.Tuple0
}
private final class kotlin.FlatMapIterator</*0*/ T : jet.Any?, /*1*/ R : jet.Any?> : kotlin.support.AbstractIterator<R> {
    public final /*constructor*/ fun </*0*/ T : jet.Any?, /*1*/ R : jet.Any?><init>(/*0*/ iterator: java.util.Iterator<T>, /*1*/ transform: jet.Function1<T, java.util.Iterator<R>>): kotlin.FlatMapIterator<T, R>
    protected open override /*1*/ fun clone(): jet.Any
    protected open override /*1*/ fun computeNext(): jet.Tuple0
    protected final override /*1*/ fun done(): jet.Tuple0
    public open override /*1*/ fun equals(/*0*/ p0: jet.Any?): jet.Boolean
    public final override /*1*/ fun getClass(): java.lang.Class<out jet.Any?>?
    public open override /*1*/ fun hasNext(): jet.Boolean
    public open override /*1*/ fun hashCode(): jet.Int
    invisible_fake final override /*1*/ fun tryToComputeNext(): jet.Boolean
    invisible_fake final override /*1*/ var next: R? private get private set
    invisible_fake final override /*1*/ var state: jet.Int private get private set
    internal final val iterator: java.util.Iterator<T>
    protected open override /*1*/ fun finalize(): jet.Tuple0
    public open override /*1*/ fun next(): R
    public final override /*1*/ fun notify(): jet.Tuple0
    public final override /*1*/ fun notifyAll(): jet.Tuple0
    internal final override /*1*/ fun peek(): R
    public open override /*1*/ fun remove(): jet.Tuple0
    protected final override /*1*/ fun setNext(/*0*/ value: R): jet.Tuple0
    public open override /*1*/ fun toString(): jet.String?
    internal final val transform: jet.Function1<T, java.util.Iterator<R>>
    internal final var transformed: java.util.Iterator<R>
    public final override /*1*/ fun wait(): jet.Tuple0
    public final override /*1*/ fun wait(/*0*/ p0: jet.Long): jet.Tuple0
    public final override /*1*/ fun wait(/*0*/ p0: jet.Long, /*1*/ p1: jet.Int): jet.Tuple0
}
private final class kotlin.Function2Comparator</*0*/ T : jet.Any?> : java.util.Comparator<T> {
    public final /*constructor*/ fun </*0*/ T : jet.Any?><init>(/*0*/ compareFn: jet.Function2<T, T, jet.Int>): kotlin.Function2Comparator<T>
    protected open override /*1*/ fun clone(): jet.Any
    public open override /*1*/ fun compare(/*0*/ a: T?, /*1*/ b: T?): jet.Int
    internal final val compareFn: jet.Function2<T, T, jet.Int>
    public open override /*1*/ fun equals(/*0*/ obj: jet.Any?): jet.Boolean
    public final override /*1*/ fun getClass(): java.lang.Class<out jet.Any?>?
    public open override /*1*/ fun hashCode(): jet.Int
    protected open override /*1*/ fun finalize(): jet.Tuple0
    public final override /*1*/ fun notify(): jet.Tuple0
    public final override /*1*/ fun notifyAll(): jet.Tuple0
    public open override /*1*/ fun toString(): jet.String
    public final override /*1*/ fun wait(): jet.Tuple0
    public final override /*1*/ fun wait(/*0*/ p0: jet.Long): jet.Tuple0
    public final override /*1*/ fun wait(/*0*/ p0: jet.Long, /*1*/ p1: jet.Int): jet.Tuple0
}
private final class kotlin.FunctionComparator</*0*/ T : jet.Any?> : java.util.Comparator<T> {
    public final /*constructor*/ fun </*0*/ T : jet.Any?><init>(/*0*/ functions: jet.Array<jet.Function1<T, jet.Any?>>): kotlin.FunctionComparator<T>
    protected open override /*1*/ fun clone(): jet.Any
    public open override /*1*/ fun compare(/*0*/ o1: T?, /*1*/ o2: T?): jet.Int
    internal final val functions: jet.Array<jet.Function1<T, jet.Any?>>
    public open override /*1*/ fun equals(/*0*/ obj: jet.Any?): jet.Boolean
    public final override /*1*/ fun getClass(): java.lang.Class<out jet.Any?>?
    public open override /*1*/ fun hashCode(): jet.Int
    protected open override /*1*/ fun finalize(): jet.Tuple0
    public final override /*1*/ fun notify(): jet.Tuple0
    public final override /*1*/ fun notifyAll(): jet.Tuple0
    public open override /*1*/ fun toString(): jet.String
    public final override /*1*/ fun wait(): jet.Tuple0
    public final override /*1*/ fun wait(/*0*/ p0: jet.Long): jet.Tuple0
    public final override /*1*/ fun wait(/*0*/ p0: jet.Long, /*1*/ p1: jet.Int): jet.Tuple0
}
private final class kotlin.ImmutableArrayList</*0*/ T : jet.Any?> : java.util.AbstractList<T> {
    public final /*constructor*/ fun </*0*/ T : jet.Any?><init>(/*0*/ array: jet.Array<T>, /*1*/ offset: jet.Int, /*2*/ length: jet.Int): kotlin.ImmutableArrayList<T>
    public open override /*1*/ fun add(/*0*/ p0: T): jet.Boolean
    public open override /*1*/ fun add(/*0*/ p0: jet.Int, /*1*/ p1: T): jet.Tuple0
    public open override /*1*/ fun addAll(/*0*/ p0: java.util.Collection<out T>): jet.Boolean
    public open override /*1*/ fun addAll(/*0*/ p0: jet.Int, /*1*/ p1: java.util.Collection<out T>): jet.Boolean
    private final val array: jet.Array<T>
    public open override /*1*/ fun clear(): jet.Tuple0
    protected open override /*1*/ fun clone(): jet.Any
    public open override /*1*/ fun contains(/*0*/ p0: jet.Any?): jet.Boolean
    public open override /*1*/ fun containsAll(/*0*/ p0: java.util.Collection<out jet.Any?>): jet.Boolean
    public open override /*1*/ fun equals(/*0*/ p0: jet.Any?): jet.Boolean
    public open override /*1*/ fun get(/*0*/ index: jet.Int): T
    public final override /*1*/ fun getClass(): java.lang.Class<out jet.Any?>?
    public open override /*1*/ fun hashCode(): jet.Int
    protected final fun indexInArray(/*0*/ index: jet.Int): jet.Int
    public open override /*1*/ fun indexOf(/*0*/ p0: jet.Any?): jet.Int
    public open override /*1*/ fun isEmpty(): jet.Boolean
    public open override /*1*/ fun iterator(): java.util.Iterator<T>
    protected open override /*1*/ fun finalize(): jet.Tuple0
    public open override /*1*/ fun lastIndexOf(/*0*/ p0: jet.Any?): jet.Int
    private final val length: jet.Int
    public open override /*1*/ fun listIterator(): java.util.ListIterator<T>
    public open override /*1*/ fun listIterator(/*0*/ p0: jet.Int): java.util.ListIterator<T>
    protected final override /*1*/ var modCount: jet.Int
    public final override /*1*/ fun notify(): jet.Tuple0
    public final override /*1*/ fun notifyAll(): jet.Tuple0
    private final val offset: jet.Int
    public open override /*1*/ fun remove(/*0*/ p0: jet.Any?): jet.Boolean
    public open override /*1*/ fun remove(/*0*/ p0: jet.Int): T?
    public open override /*1*/ fun removeAll(/*0*/ p0: java.util.Collection<out jet.Any?>): jet.Boolean
    protected open override /*1*/ fun removeRange(/*0*/ p0: jet.Int, /*1*/ p1: jet.Int): jet.Tuple0
    public open override /*1*/ fun retainAll(/*0*/ p0: java.util.Collection<out jet.Any?>): jet.Boolean
    public open override /*1*/ fun set(/*0*/ p0: jet.Int, /*1*/ p1: T): T
    public open override /*1*/ fun size(): jet.Int
    public open override /*1*/ fun subList(/*0*/ fromIndex: jet.Int, /*1*/ toIndex: jet.Int): java.util.List<T>
    public open override /*1*/ fun toArray(): jet.Array<jet.Any?>
    public open override /*1*/ fun </*0*/ T : jet.Any?>toArray(/*0*/ p0: jet.Array<T>): jet.Array<T>
    public open override /*1*/ fun toString(): jet.String?
    public final override /*1*/ fun wait(): jet.Tuple0
    public final override /*1*/ fun wait(/*0*/ p0: jet.Long): jet.Tuple0
    public final override /*1*/ fun wait(/*0*/ p0: jet.Long, /*1*/ p1: jet.Int): jet.Tuple0
}
public final class kotlin.ImmutableArrayListBuilder</*0*/ T : jet.Any?> : jet.Any {
    public final /*constructor*/ fun </*0*/ T : jet.Any?><init>(): kotlin.ImmutableArrayListBuilder<T>
    public final fun add(/*0*/ item: T): jet.Tuple0
    private final var array: jet.Array<jet.Any?>
    public final fun build(): java.util.List<T>
    public final fun ensureCapacity(/*0*/ capacity: jet.Int): jet.Tuple0
    private final var length: jet.Int
}
private final class kotlin.MapIterator</*0*/ T : jet.Any?, /*1*/ R : jet.Any?> : kotlin.support.AbstractIterator<R> {
    public final /*constructor*/ fun </*0*/ T : jet.Any?, /*1*/ R : jet.Any?><init>(/*0*/ iterator: java.util.Iterator<T>, /*1*/ transform: jet.Function1<T, R>): kotlin.MapIterator<T, R>
    protected open override /*1*/ fun clone(): jet.Any
    protected open override /*1*/ fun computeNext(): jet.Tuple0
    protected final override /*1*/ fun done(): jet.Tuple0
    public open override /*1*/ fun equals(/*0*/ p0: jet.Any?): jet.Boolean
    public final override /*1*/ fun getClass(): java.lang.Class<out jet.Any?>?
    public open override /*1*/ fun hasNext(): jet.Boolean
    public open override /*1*/ fun hashCode(): jet.Int
    invisible_fake final override /*1*/ fun tryToComputeNext(): jet.Boolean
    invisible_fake final override /*1*/ var next: R? private get private set
    invisible_fake final override /*1*/ var state: jet.Int private get private set
    internal final val iterator: java.util.Iterator<T>
    protected open override /*1*/ fun finalize(): jet.Tuple0
    public open override /*1*/ fun next(): R
    public final override /*1*/ fun notify(): jet.Tuple0
    public final override /*1*/ fun notifyAll(): jet.Tuple0
    internal final override /*1*/ fun peek(): R
    public open override /*1*/ fun remove(): jet.Tuple0
    protected final override /*1*/ fun setNext(/*0*/ value: R): jet.Tuple0
    public open override /*1*/ fun toString(): jet.String?
    internal final val transform: jet.Function1<T, R>
    public final override /*1*/ fun wait(): jet.Tuple0
    public final override /*1*/ fun wait(/*0*/ p0: jet.Long): jet.Tuple0
    public final override /*1*/ fun wait(/*0*/ p0: jet.Long, /*1*/ p1: jet.Int): jet.Tuple0
}
private final class kotlin.NumberedIterator</*0*/ TT : jet.Any?> : java.util.Iterator<jet.Tuple2<out jet.Int, out TT>> {
    public final /*constructor*/ fun </*0*/ TT : jet.Any?><init>(/*0*/ sourceIterator: java.util.Iterator<TT>): kotlin.NumberedIterator<TT>
    protected open override /*1*/ fun clone(): jet.Any
    public open override /*1*/ fun equals(/*0*/ p0: jet.Any?): jet.Boolean
    public final override /*1*/ fun getClass(): java.lang.Class<out jet.Any?>?
    public open override /*1*/ fun hasNext(): jet.Boolean
    public open override /*1*/ fun hashCode(): jet.Int
    protected open override /*1*/ fun finalize(): jet.Tuple0
    public open override /*1*/ fun next(): jet.Tuple2<out jet.Int, out TT>
    private final var nextIndex: jet.Int
    public final override /*1*/ fun notify(): jet.Tuple0
    public final override /*1*/ fun notifyAll(): jet.Tuple0
    public open override /*1*/ fun remove(): jet.Tuple0
    private final val sourceIterator: java.util.Iterator<TT>
    public open override /*1*/ fun toString(): jet.String?
    public final override /*1*/ fun wait(): jet.Tuple0
    public final override /*1*/ fun wait(/*0*/ p0: jet.Long): jet.Tuple0
    public final override /*1*/ fun wait(/*0*/ p0: jet.Long, /*1*/ p1: jet.Int): jet.Tuple0
}
private final class kotlin.TakeWhileIterator</*0*/ T : jet.Any?> : kotlin.support.AbstractIterator<T> {
    public final /*constructor*/ fun </*0*/ T : jet.Any?><init>(/*0*/ iterator: java.util.Iterator<T>, /*1*/ predicate: jet.Function1<T, jet.Boolean>): kotlin.TakeWhileIterator<T>
    protected open override /*1*/ fun clone(): jet.Any
    protected open override /*1*/ fun computeNext(): jet.Tuple0
    protected final override /*1*/ fun done(): jet.Tuple0
    public open override /*1*/ fun equals(/*0*/ p0: jet.Any?): jet.Boolean
    public final override /*1*/ fun getClass(): java.lang.Class<out jet.Any?>?
    public open override /*1*/ fun hasNext(): jet.Boolean
    public open override /*1*/ fun hashCode(): jet.Int
    invisible_fake final override /*1*/ fun tryToComputeNext(): jet.Boolean
    invisible_fake final override /*1*/ var next: T? private get private set
    invisible_fake final override /*1*/ var state: jet.Int private get private set
    internal final val iterator: java.util.Iterator<T>
    protected open override /*1*/ fun finalize(): jet.Tuple0
    public open override /*1*/ fun next(): T
    public final override /*1*/ fun notify(): jet.Tuple0
    public final override /*1*/ fun notifyAll(): jet.Tuple0
    internal final override /*1*/ fun peek(): T
    internal final val predicate: jet.Function1<T, jet.Boolean>
    public open override /*1*/ fun remove(): jet.Tuple0
    protected final override /*1*/ fun setNext(/*0*/ value: T): jet.Tuple0
    public open override /*1*/ fun toString(): jet.String?
    public final override /*1*/ fun wait(): jet.Tuple0
    public final override /*1*/ fun wait(/*0*/ p0: jet.Long): jet.Tuple0
    public final override /*1*/ fun wait(/*0*/ p0: jet.Long, /*1*/ p1: jet.Int): jet.Tuple0
}
internal final val Assertions: kotlin.Assertions
internal final val java.util.Collection<out jet.Any?>.empty: jet.Boolean
internal final val java.util.Map<out jet.Any?, out jet.Any?>.empty: jet.Boolean
internal final val emptyArray: jet.Array<jet.Any?>
internal final val emptyImmutableArrayList: kotlin.ImmutableArrayList<jet.Any?>
internal final val  </*0*/ T : jet.Any?> java.util.List<T>.first: T?
internal final val  </*0*/ T : jet.Any?> java.util.List<T>.head: T?
internal final val java.util.Collection<out jet.Any?>.indices: jet.IntRange
public final val jet.ByteArray.inputStream: java.io.ByteArrayInputStream
public final val  </*0*/ out T : jet.Any?> T.javaClass: java.lang.Class<T>
internal final val  </*0*/ K : jet.Any?, /*1*/ V : jet.Any?> java.util.Map.Entry<K, V>.key: K
internal final val  </*0*/ T : jet.Any?> java.util.List<T>.last: T?
internal final val  </*0*/ T : jet.Any?> java.util.List<T>.lastIndex: jet.Int
public final val  </*0*/ in T : jet.Any?> jet.Array<T>.lastIndex: jet.Int
public final val jet.BooleanArray.lastIndex: jet.Int
public final val jet.ByteArray.lastIndex: jet.Int
public final val jet.CharArray.lastIndex: jet.Int
public final val jet.DoubleArray.lastIndex: jet.Int
public final val jet.FloatArray.lastIndex: jet.Int
public final val jet.IntArray.lastIndex: jet.Int
public final val jet.LongArray.lastIndex: jet.Int
public final val jet.ShortArray.lastIndex: jet.Int
internal final val jet.String.reader: java.io.StringReader
internal final val java.util.Collection<out jet.Any?>.size: jet.Int
internal final val java.util.Map<out jet.Any?, out jet.Any?>.size: jet.Int
internal final val jet.CharSequence.size: jet.Int
internal final val jet.String.size: jet.Int
internal final val  </*0*/ T : jet.Any?> java.util.List<T>.tail: java.util.List<T>
internal final val  </*0*/ K : jet.Any?, /*1*/ V : jet.Any?> java.util.Map.Entry<K, V>.value: V
public final fun String(/*0*/ bytes: jet.ByteArray): jet.String
public final fun String(/*0*/ bytes: jet.ByteArray, /*1*/ charset: java.nio.charset.Charset): jet.String
public final fun String(/*0*/ bytes: jet.ByteArray, /*1*/ charsetName: jet.String?): jet.String
public final fun String(/*0*/ bytes: jet.ByteArray, /*1*/ i: jet.Int, /*2*/ i1: jet.Int): jet.String
public final fun String(/*0*/ bytes: jet.ByteArray, /*1*/ offset: jet.Int, /*2*/ length: jet.Int, /*3*/ charset: java.nio.charset.Charset): jet.String
public final fun String(/*0*/ bytes: jet.ByteArray, /*1*/ offset: jet.Int, /*2*/ length: jet.Int, /*3*/ charsetName: jet.String): jet.String
public final fun String(/*0*/ chars: jet.CharArray): jet.String
public final fun String(/*0*/ stringBuffer: java.lang.StringBuffer): jet.String
public final fun String(/*0*/ stringBuilder: java.lang.StringBuilder): jet.String
public final fun </*0*/ T : jet.Any?>java.lang.Iterable<T>.all(/*0*/ predicate: jet.Function1<T, jet.Boolean>): jet.Boolean
public final fun </*0*/ T : jet.Any?>java.util.Iterator<T>.all(/*0*/ predicate: jet.Function1<T, jet.Boolean>): jet.Boolean
public final fun </*0*/ T : jet.Any?>jet.Array<T>.all(/*0*/ predicate: jet.Function1<T, jet.Boolean>): jet.Boolean
public final fun jet.BooleanArray.all(/*0*/ predicate: jet.Function1<jet.Boolean, jet.Boolean>): jet.Boolean
public final fun jet.ByteArray.all(/*0*/ predicate: jet.Function1<jet.Byte, jet.Boolean>): jet.Boolean
public final fun jet.CharArray.all(/*0*/ predicate: jet.Function1<jet.Char, jet.Boolean>): jet.Boolean
public final fun jet.DoubleArray.all(/*0*/ predicate: jet.Function1<jet.Double, jet.Boolean>): jet.Boolean
public final fun jet.FloatArray.all(/*0*/ predicate: jet.Function1<jet.Float, jet.Boolean>): jet.Boolean
public final fun jet.IntArray.all(/*0*/ predicate: jet.Function1<jet.Int, jet.Boolean>): jet.Boolean
public final fun </*0*/ T : jet.Any?>jet.Iterable<T>.all(/*0*/ predicate: jet.Function1<T, jet.Boolean>): jet.Boolean
public final fun jet.LongArray.all(/*0*/ predicate: jet.Function1<jet.Long, jet.Boolean>): jet.Boolean
public final fun jet.ShortArray.all(/*0*/ predicate: jet.Function1<jet.Short, jet.Boolean>): jet.Boolean
public final fun </*0*/ T : jet.Any?>java.lang.Iterable<T>.any(/*0*/ predicate: jet.Function1<T, jet.Boolean>): jet.Boolean
public final fun </*0*/ T : jet.Any?>java.util.Iterator<T>.any(/*0*/ predicate: jet.Function1<T, jet.Boolean>): jet.Boolean
public final fun </*0*/ T : jet.Any?>jet.Array<T>.any(/*0*/ predicate: jet.Function1<T, jet.Boolean>): jet.Boolean
public final fun jet.BooleanArray.any(/*0*/ predicate: jet.Function1<jet.Boolean, jet.Boolean>): jet.Boolean
public final fun jet.ByteArray.any(/*0*/ predicate: jet.Function1<jet.Byte, jet.Boolean>): jet.Boolean
public final fun jet.CharArray.any(/*0*/ predicate: jet.Function1<jet.Char, jet.Boolean>): jet.Boolean
public final fun jet.DoubleArray.any(/*0*/ predicate: jet.Function1<jet.Double, jet.Boolean>): jet.Boolean
public final fun jet.FloatArray.any(/*0*/ predicate: jet.Function1<jet.Float, jet.Boolean>): jet.Boolean
public final fun jet.IntArray.any(/*0*/ predicate: jet.Function1<jet.Int, jet.Boolean>): jet.Boolean
public final fun </*0*/ T : jet.Any?>jet.Iterable<T>.any(/*0*/ predicate: jet.Function1<T, jet.Boolean>): jet.Boolean
public final fun jet.LongArray.any(/*0*/ predicate: jet.Function1<jet.Long, jet.Boolean>): jet.Boolean
public final fun jet.ShortArray.any(/*0*/ predicate: jet.Function1<jet.Short, jet.Boolean>): jet.Boolean
public final fun </*0*/ T : jet.Any?>java.lang.Iterable<T>.appendString(/*0*/ buffer: java.lang.Appendable, /*1*/ separator: jet.String = ?, /*2*/ prefix: jet.String = ?, /*3*/ postfix: jet.String = ?, /*4*/ limit: jet.Int = ?, /*5*/ truncated: jet.String = ?): jet.Tuple0
public final fun </*0*/ T : jet.Any?>java.util.Iterator<T>.appendString(/*0*/ buffer: java.lang.Appendable, /*1*/ separator: jet.String = ?, /*2*/ prefix: jet.String = ?, /*3*/ postfix: jet.String = ?, /*4*/ limit: jet.Int = ?, /*5*/ truncated: jet.String = ?): jet.Tuple0
public final fun </*0*/ T : jet.Any?>jet.Array<T>.appendString(/*0*/ buffer: java.lang.Appendable, /*1*/ separator: jet.String = ?, /*2*/ prefix: jet.String = ?, /*3*/ postfix: jet.String = ?, /*4*/ limit: jet.Int = ?, /*5*/ truncated: jet.String = ?): jet.Tuple0
public final fun jet.BooleanArray.appendString(/*0*/ buffer: java.lang.Appendable, /*1*/ separator: jet.String = ?, /*2*/ prefix: jet.String = ?, /*3*/ postfix: jet.String = ?, /*4*/ limit: jet.Int = ?, /*5*/ truncated: jet.String = ?): jet.Tuple0
public final fun jet.ByteArray.appendString(/*0*/ buffer: java.lang.Appendable, /*1*/ separator: jet.String = ?, /*2*/ prefix: jet.String = ?, /*3*/ postfix: jet.String = ?, /*4*/ limit: jet.Int = ?, /*5*/ truncated: jet.String = ?): jet.Tuple0
public final fun jet.CharArray.appendString(/*0*/ buffer: java.lang.Appendable, /*1*/ separator: jet.String = ?, /*2*/ prefix: jet.String = ?, /*3*/ postfix: jet.String = ?, /*4*/ limit: jet.Int = ?, /*5*/ truncated: jet.String = ?): jet.Tuple0
public final fun jet.DoubleArray.appendString(/*0*/ buffer: java.lang.Appendable, /*1*/ separator: jet.String = ?, /*2*/ prefix: jet.String = ?, /*3*/ postfix: jet.String = ?, /*4*/ limit: jet.Int = ?, /*5*/ truncated: jet.String = ?): jet.Tuple0
public final fun jet.FloatArray.appendString(/*0*/ buffer: java.lang.Appendable, /*1*/ separator: jet.String = ?, /*2*/ prefix: jet.String = ?, /*3*/ postfix: jet.String = ?, /*4*/ limit: jet.Int = ?, /*5*/ truncated: jet.String = ?): jet.Tuple0
public final fun jet.IntArray.appendString(/*0*/ buffer: java.lang.Appendable, /*1*/ separator: jet.String = ?, /*2*/ prefix: jet.String = ?, /*3*/ postfix: jet.String = ?, /*4*/ limit: jet.Int = ?, /*5*/ truncated: jet.String = ?): jet.Tuple0
public final fun </*0*/ T : jet.Any?>jet.Iterable<T>.appendString(/*0*/ buffer: java.lang.Appendable, /*1*/ separator: jet.String = ?, /*2*/ prefix: jet.String = ?, /*3*/ postfix: jet.String = ?, /*4*/ limit: jet.Int = ?, /*5*/ truncated: jet.String = ?): jet.Tuple0
public final fun jet.LongArray.appendString(/*0*/ buffer: java.lang.Appendable, /*1*/ separator: jet.String = ?, /*2*/ prefix: jet.String = ?, /*3*/ postfix: jet.String = ?, /*4*/ limit: jet.Int = ?, /*5*/ truncated: jet.String = ?): jet.Tuple0
public final fun jet.ShortArray.appendString(/*0*/ buffer: java.lang.Appendable, /*1*/ separator: jet.String = ?, /*2*/ prefix: jet.String = ?, /*3*/ postfix: jet.String = ?, /*4*/ limit: jet.Int = ?, /*5*/ truncated: jet.String = ?): jet.Tuple0
public final [ERROR : <ERROR RETURN TYPE>]() fun </*0*/ T : jet.Any?>array(/*0*/ vararg t: T /*jet.Array<T>*/): jet.Array<T>
public final fun </*0*/ T : jet.Any?>arrayList(/*0*/ vararg values: T /*jet.Array<T>*/): java.util.ArrayList<T>
public final fun assert(/*0*/ value: jet.Boolean, /*1*/ lazyMessage: jet.Function0<jet.String>): jet.Tuple0
public final fun assert(/*0*/ value: jet.Boolean, /*1*/ message: jet.Any = ?): jet.Tuple0
public final fun jet.ByteArray.binarySearch(/*0*/ fromIndex: jet.Int, /*1*/ toIndex: jet.Int, /*2*/ key: jet.Byte): jet.Int
public final fun jet.ByteArray.binarySearch(/*0*/ key: jet.Byte): jet.Int
public final fun jet.CharArray.binarySearch(/*0*/ fromIndex: jet.Int, /*1*/ toIndex: jet.Int, /*2*/ key: jet.Char): jet.Int
public final fun jet.CharArray.binarySearch(/*0*/ key: jet.Char): jet.Int
public final fun jet.DoubleArray.binarySearch(/*0*/ fromIndex: jet.Int, /*1*/ toIndex: jet.Int, /*2*/ key: jet.Double): jet.Int
public final fun jet.DoubleArray.binarySearch(/*0*/ key: jet.Double): jet.Int
public final fun jet.FloatArray.binarySearch(/*0*/ fromIndex: jet.Int, /*1*/ toIndex: jet.Int, /*2*/ key: jet.Float): jet.Int
public final fun jet.FloatArray.binarySearch(/*0*/ key: jet.Float): jet.Int
public final fun jet.IntArray.binarySearch(/*0*/ fromIndex: jet.Int, /*1*/ toIndex: jet.Int, /*2*/ key: jet.Int): jet.Int
public final fun jet.IntArray.binarySearch(/*0*/ key: jet.Int): jet.Int
public final fun jet.LongArray.binarySearch(/*0*/ fromIndex: jet.Int, /*1*/ toIndex: jet.Int, /*2*/ key: jet.Long): jet.Int
public final fun jet.LongArray.binarySearch(/*0*/ key: jet.Long): jet.Int
public final fun jet.ShortArray.binarySearch(/*0*/ fromIndex: jet.Int, /*1*/ toIndex: jet.Int, /*2*/ key: jet.Short): jet.Int
public final fun jet.ShortArray.binarySearch(/*0*/ key: jet.Short): jet.Int
public final [ERROR : <ERROR RETURN TYPE>]() fun booleanArray(/*0*/ vararg content: jet.Boolean /*jet.BooleanArray*/): jet.BooleanArray
public final [ERROR : <ERROR RETURN TYPE>]() fun byteArray(/*0*/ vararg content: jet.Byte /*jet.ByteArray*/): jet.ByteArray
public final fun jet.String.capitalize(): jet.String
public final [ERROR : <ERROR RETURN TYPE>]() fun charArray(/*0*/ vararg content: jet.Char /*jet.CharArray*/): jet.CharArray
public final fun jet.CharSequence.charAt(/*0*/ index: jet.Int): jet.Char
public final fun jet.String.charAt(/*0*/ index: jet.Int): jet.Char
public final fun check(/*0*/ value: jet.Boolean, /*1*/ lazyMessage: jet.Function0<jet.String>): jet.Tuple0
public final fun check(/*0*/ value: jet.Boolean, /*1*/ message: jet.Any = ?): jet.Tuple0
public final fun </*0*/ T : jet.Any?>checkNotNull(/*0*/ value: T?, /*1*/ message: jet.String = ?): T
public final fun jet.String.codePointAt(/*0*/ index: jet.Int): jet.Int
public final fun jet.String.codePointBefore(/*0*/ index: jet.Int): jet.Int
public final fun jet.String.codePointCount(/*0*/ beginIndex: jet.Int, /*1*/ endIndex: jet.Int): jet.Int
public final fun </*0*/ T : jet.Any?>comparator(/*0*/ fn: jet.Function2<T, T, jet.Int>): java.util.Comparator<T>
public final fun </*0*/ T : jet.Any?>comparator(/*0*/ vararg functions: jet.Function1<T, jet.Any?> /*jet.Array<jet.Function1<T, jet.Any?>>*/): java.util.Comparator<T>
internal final fun </*0*/ T : jet.Any?>compareBy(/*0*/ a: T?, /*1*/ b: T?, /*2*/ vararg functions: jet.Function1<T, jet.Any?> /*jet.Array<jet.Function1<T, jet.Any?>>*/): jet.Int
public final fun jet.String.compareToIgnoreCase(/*0*/ str: jet.String): jet.Int
public final fun </*0*/ T : jet.Any?>compareValues(/*0*/ a: T?, /*1*/ b: T?): jet.Int
public final fun jet.String.concat(/*0*/ str: jet.String): jet.String
public final fun </*0*/ T : jet.Any?>java.lang.Iterable<T>.contains(/*0*/ item: T): jet.Boolean
public final fun jet.String.contains(/*0*/ seq: jet.CharSequence): jet.Boolean
public final fun jet.String.contentEquals(/*0*/ cs: jet.CharSequence): jet.Boolean
public final fun jet.String.contentEquals(/*0*/ sb: java.lang.StringBuffer): jet.Boolean
public final fun </*0*/ T : jet.Any?>jet.Array<T>.copyOf(/*0*/ newLength: jet.Int = ?): jet.Array<T>
public final fun jet.BooleanArray.copyOf(/*0*/ newLength: jet.Int = ?): jet.BooleanArray
public final fun jet.ByteArray.copyOf(/*0*/ newLength: jet.Int = ?): jet.ByteArray
public final fun jet.CharArray.copyOf(/*0*/ newLength: jet.Int = ?): jet.CharArray
public final fun jet.DoubleArray.copyOf(/*0*/ newLength: jet.Int = ?): jet.DoubleArray
public final fun jet.FloatArray.copyOf(/*0*/ newLength: jet.Int = ?): jet.FloatArray
public final fun jet.IntArray.copyOf(/*0*/ newLength: jet.Int = ?): jet.IntArray
public final fun jet.LongArray.copyOf(/*0*/ newLength: jet.Int = ?): jet.LongArray
public final fun jet.ShortArray.copyOf(/*0*/ newLength: jet.Int = ?): jet.ShortArray
public final fun </*0*/ T : jet.Any?>jet.Array<T>.copyOfRange(/*0*/ from: jet.Int, /*1*/ to: jet.Int): jet.Array<T>
public final fun jet.BooleanArray.copyOfRange(/*0*/ from: jet.Int, /*1*/ to: jet.Int): jet.BooleanArray
public final fun jet.ByteArray.copyOfRange(/*0*/ from: jet.Int, /*1*/ to: jet.Int): jet.ByteArray
public final fun jet.CharArray.copyOfRange(/*0*/ from: jet.Int, /*1*/ to: jet.Int): jet.CharArray
public final fun jet.DoubleArray.copyOfRange(/*0*/ from: jet.Int, /*1*/ to: jet.Int): jet.DoubleArray
public final fun jet.FloatArray.copyOfRange(/*0*/ from: jet.Int, /*1*/ to: jet.Int): jet.FloatArray
public final fun jet.IntArray.copyOfRange(/*0*/ from: jet.Int, /*1*/ to: jet.Int): jet.IntArray
public final fun jet.LongArray.copyOfRange(/*0*/ from: jet.Int, /*1*/ to: jet.Int): jet.LongArray
public final fun jet.ShortArray.copyOfRange(/*0*/ from: jet.Int, /*1*/ to: jet.Int): jet.ShortArray
public final fun </*0*/ T : jet.Any?>java.lang.Iterable<T>.count(): jet.Int
public final fun </*0*/ T : jet.Any?>java.lang.Iterable<T>.count(/*0*/ predicate: jet.Function1<T, jet.Boolean>): jet.Int
public final fun </*0*/ T : jet.Any?>java.util.Iterator<T>.count(/*0*/ predicate: jet.Function1<T, jet.Boolean>): jet.Int
public final fun </*0*/ T : jet.Any?>jet.Array<T>.count(/*0*/ predicate: jet.Function1<T, jet.Boolean>): jet.Int
public final fun jet.BooleanArray.count(/*0*/ predicate: jet.Function1<jet.Boolean, jet.Boolean>): jet.Int
public final fun jet.ByteArray.count(/*0*/ predicate: jet.Function1<jet.Byte, jet.Boolean>): jet.Int
public final fun jet.CharArray.count(/*0*/ predicate: jet.Function1<jet.Char, jet.Boolean>): jet.Int
public final fun jet.DoubleArray.count(/*0*/ predicate: jet.Function1<jet.Double, jet.Boolean>): jet.Int
public final fun jet.FloatArray.count(/*0*/ predicate: jet.Function1<jet.Float, jet.Boolean>): jet.Int
public final fun jet.IntArray.count(/*0*/ predicate: jet.Function1<jet.Int, jet.Boolean>): jet.Int
public final fun </*0*/ T : jet.Any?>jet.Iterable<T>.count(/*0*/ predicate: jet.Function1<T, jet.Boolean>): jet.Int
public final fun jet.LongArray.count(/*0*/ predicate: jet.Function1<jet.Long, jet.Boolean>): jet.Int
public final fun jet.ShortArray.count(/*0*/ predicate: jet.Function1<jet.Short, jet.Boolean>): jet.Int
public final fun jet.String.count(/*0*/ predicate: jet.Function1<jet.Char, jet.Boolean>): jet.Int
private final fun </*0*/ T : jet.Any?>countTo(/*0*/ n: jet.Int): jet.Function1<T, jet.Boolean>
public final fun jet.String.decapitalize(): jet.String
public final [ERROR : <ERROR RETURN TYPE>]() fun doubleArray(/*0*/ vararg content: jet.Double /*jet.DoubleArray*/): jet.DoubleArray
public final fun </*0*/ T : jet.Any?>java.lang.Iterable<T>.drop(/*0*/ n: jet.Int): java.util.List<T>
public final fun </*0*/ T : jet.Any?>jet.Array<T>.drop(/*0*/ n: jet.Int): java.util.List<T>
public final fun jet.BooleanArray.drop(/*0*/ n: jet.Int): java.util.List<jet.Boolean>
public final fun jet.ByteArray.drop(/*0*/ n: jet.Int): java.util.List<jet.Byte>
public final fun jet.CharArray.drop(/*0*/ n: jet.Int): java.util.List<jet.Char>
public final fun jet.DoubleArray.drop(/*0*/ n: jet.Int): java.util.List<jet.Double>
public final fun jet.FloatArray.drop(/*0*/ n: jet.Int): java.util.List<jet.Float>
public final fun jet.IntArray.drop(/*0*/ n: jet.Int): java.util.List<jet.Int>
public final fun </*0*/ T : jet.Any?>jet.Iterable<T>.drop(/*0*/ n: jet.Int): java.util.List<T>
public final fun jet.LongArray.drop(/*0*/ n: jet.Int): java.util.List<jet.Long>
public final fun jet.ShortArray.drop(/*0*/ n: jet.Int): java.util.List<jet.Short>
public final fun </*0*/ T : jet.Any?>java.lang.Iterable<T>.dropWhile(/*0*/ predicate: jet.Function1<T, jet.Boolean>): java.util.List<T>
public final fun </*0*/ T : jet.Any?>jet.Array<T>.dropWhile(/*0*/ predicate: jet.Function1<T, jet.Boolean>): java.util.List<T>
public final fun jet.BooleanArray.dropWhile(/*0*/ predicate: jet.Function1<jet.Boolean, jet.Boolean>): java.util.List<jet.Boolean>
public final fun jet.ByteArray.dropWhile(/*0*/ predicate: jet.Function1<jet.Byte, jet.Boolean>): java.util.List<jet.Byte>
public final fun jet.CharArray.dropWhile(/*0*/ predicate: jet.Function1<jet.Char, jet.Boolean>): java.util.List<jet.Char>
public final fun jet.DoubleArray.dropWhile(/*0*/ predicate: jet.Function1<jet.Double, jet.Boolean>): java.util.List<jet.Double>
public final fun jet.FloatArray.dropWhile(/*0*/ predicate: jet.Function1<jet.Float, jet.Boolean>): java.util.List<jet.Float>
public final fun jet.IntArray.dropWhile(/*0*/ predicate: jet.Function1<jet.Int, jet.Boolean>): java.util.List<jet.Int>
public final fun </*0*/ T : jet.Any?>jet.Iterable<T>.dropWhile(/*0*/ predicate: jet.Function1<T, jet.Boolean>): java.util.List<T>
public final fun jet.LongArray.dropWhile(/*0*/ predicate: jet.Function1<jet.Long, jet.Boolean>): java.util.List<jet.Long>
public final fun jet.ShortArray.dropWhile(/*0*/ predicate: jet.Function1<jet.Short, jet.Boolean>): java.util.List<jet.Short>
public final fun </*0*/ T : jet.Any?, /*1*/ L : java.util.List<in T>>java.lang.Iterable<T>.dropWhileTo(/*0*/ result: L, /*1*/ predicate: jet.Function1<T, jet.Boolean>): L
public final fun </*0*/ T : jet.Any?, /*1*/ L : java.util.List<in T>>java.util.Iterator<T>.dropWhileTo(/*0*/ result: L, /*1*/ predicate: jet.Function1<T, jet.Boolean>): L
public final fun </*0*/ T : jet.Any?, /*1*/ L : java.util.List<in T>>jet.Array<T>.dropWhileTo(/*0*/ result: L, /*1*/ predicate: jet.Function1<T, jet.Boolean>): L
public final fun </*0*/ L : java.util.List<jet.Boolean>>jet.BooleanArray.dropWhileTo(/*0*/ result: L, /*1*/ predicate: jet.Function1<jet.Boolean, jet.Boolean>): L
public final fun </*0*/ L : java.util.List<jet.Byte>>jet.ByteArray.dropWhileTo(/*0*/ result: L, /*1*/ predicate: jet.Function1<jet.Byte, jet.Boolean>): L
public final fun </*0*/ L : java.util.List<jet.Char>>jet.CharArray.dropWhileTo(/*0*/ result: L, /*1*/ predicate: jet.Function1<jet.Char, jet.Boolean>): L
public final fun </*0*/ L : java.util.List<jet.Double>>jet.DoubleArray.dropWhileTo(/*0*/ result: L, /*1*/ predicate: jet.Function1<jet.Double, jet.Boolean>): L
public final fun </*0*/ L : java.util.List<jet.Float>>jet.FloatArray.dropWhileTo(/*0*/ result: L, /*1*/ predicate: jet.Function1<jet.Float, jet.Boolean>): L
public final fun </*0*/ L : java.util.List<jet.Int>>jet.IntArray.dropWhileTo(/*0*/ result: L, /*1*/ predicate: jet.Function1<jet.Int, jet.Boolean>): L
public final fun </*0*/ T : jet.Any?, /*1*/ L : java.util.List<in T>>jet.Iterable<T>.dropWhileTo(/*0*/ result: L, /*1*/ predicate: jet.Function1<T, jet.Boolean>): L
public final fun </*0*/ L : java.util.List<jet.Long>>jet.LongArray.dropWhileTo(/*0*/ result: L, /*1*/ predicate: jet.Function1<jet.Long, jet.Boolean>): L
public final fun </*0*/ L : java.util.List<jet.Short>>jet.ShortArray.dropWhileTo(/*0*/ result: L, /*1*/ predicate: jet.Function1<jet.Short, jet.Boolean>): L
public final fun jet.String.endsWith(/*0*/ ch: jet.Char): jet.Boolean
public final fun jet.String.endsWith(/*0*/ suffix: jet.String): jet.Boolean
public final fun jet.String.equalsIgnoreCase(/*0*/ anotherString: jet.String): jet.Boolean
public final fun </*0*/ in T : jet.Any?>jet.Array<T>.fill(/*0*/ value: T): jet.Tuple0
public final fun jet.BooleanArray.fill(/*0*/ value: jet.Boolean): jet.Tuple0
public final fun jet.ByteArray.fill(/*0*/ value: jet.Byte): jet.Tuple0
public final fun jet.CharArray.fill(/*0*/ value: jet.Char): jet.Tuple0
public final fun jet.DoubleArray.fill(/*0*/ value: jet.Double): jet.Tuple0
public final fun jet.FloatArray.fill(/*0*/ value: jet.Float): jet.Tuple0
public final fun jet.IntArray.fill(/*0*/ value: jet.Int): jet.Tuple0
public final fun jet.LongArray.fill(/*0*/ value: jet.Long): jet.Tuple0
public final fun jet.ShortArray.fill(/*0*/ value: jet.Short): jet.Tuple0
public final fun </*0*/ T : jet.Any?>java.lang.Iterable<T>.filter(/*0*/ predicate: jet.Function1<T, jet.Boolean>): java.util.List<T>
public final fun </*0*/ T : jet.Any?>java.util.Iterator<T>.filter(/*0*/ predicate: jet.Function1<T, jet.Boolean>): java.util.Iterator<T>
public final fun </*0*/ T : jet.Any?>jet.Array<T>.filter(/*0*/ predicate: jet.Function1<T, jet.Boolean>): java.util.List<T>
public final fun jet.BooleanArray.filter(/*0*/ predicate: jet.Function1<jet.Boolean, jet.Boolean>): java.util.List<jet.Boolean>
public final fun jet.ByteArray.filter(/*0*/ predicate: jet.Function1<jet.Byte, jet.Boolean>): java.util.List<jet.Byte>
public final fun jet.CharArray.filter(/*0*/ predicate: jet.Function1<jet.Char, jet.Boolean>): java.util.List<jet.Char>
public final fun jet.DoubleArray.filter(/*0*/ predicate: jet.Function1<jet.Double, jet.Boolean>): java.util.List<jet.Double>
public final fun jet.FloatArray.filter(/*0*/ predicate: jet.Function1<jet.Float, jet.Boolean>): java.util.List<jet.Float>
public final fun jet.IntArray.filter(/*0*/ predicate: jet.Function1<jet.Int, jet.Boolean>): java.util.List<jet.Int>
public final fun </*0*/ T : jet.Any?>jet.Iterable<T>.filter(/*0*/ predicate: jet.Function1<T, jet.Boolean>): java.util.List<T>
public final fun jet.LongArray.filter(/*0*/ predicate: jet.Function1<jet.Long, jet.Boolean>): java.util.List<jet.Long>
public final fun jet.ShortArray.filter(/*0*/ predicate: jet.Function1<jet.Short, jet.Boolean>): java.util.List<jet.Short>
public final fun </*0*/ T : jet.Any?, /*1*/ R : T>java.util.Iterator<T>.filterIsInstance(/*0*/ klass: java.lang.Class<R>): java.util.Iterator<R>
public final fun </*0*/ T : jet.Any?>java.lang.Iterable<T>.filterNot(/*0*/ predicate: jet.Function1<T, jet.Boolean>): java.util.List<T>
public final fun </*0*/ T : jet.Any?>java.util.Iterator<T>.filterNot(/*0*/ predicate: jet.Function1<T, jet.Boolean>): java.util.Iterator<T>
public final fun </*0*/ T : jet.Any?>jet.Array<T>.filterNot(/*0*/ predicate: jet.Function1<T, jet.Boolean>): java.util.List<T>
public final fun jet.BooleanArray.filterNot(/*0*/ predicate: jet.Function1<jet.Boolean, jet.Boolean>): java.util.List<jet.Boolean>
public final fun jet.ByteArray.filterNot(/*0*/ predicate: jet.Function1<jet.Byte, jet.Boolean>): java.util.List<jet.Byte>
public final fun jet.CharArray.filterNot(/*0*/ predicate: jet.Function1<jet.Char, jet.Boolean>): java.util.List<jet.Char>
public final fun jet.DoubleArray.filterNot(/*0*/ predicate: jet.Function1<jet.Double, jet.Boolean>): java.util.List<jet.Double>
public final fun jet.FloatArray.filterNot(/*0*/ predicate: jet.Function1<jet.Float, jet.Boolean>): java.util.List<jet.Float>
public final fun jet.IntArray.filterNot(/*0*/ predicate: jet.Function1<jet.Int, jet.Boolean>): java.util.List<jet.Int>
public final fun </*0*/ T : jet.Any?>jet.Iterable<T>.filterNot(/*0*/ predicate: jet.Function1<T, jet.Boolean>): java.util.List<T>
public final fun jet.LongArray.filterNot(/*0*/ predicate: jet.Function1<jet.Long, jet.Boolean>): java.util.List<jet.Long>
public final fun jet.ShortArray.filterNot(/*0*/ predicate: jet.Function1<jet.Short, jet.Boolean>): java.util.List<jet.Short>
public final fun </*0*/ T : jet.Any?>java.lang.Iterable<T?>?.filterNotNull(): java.util.List<T>
public final fun </*0*/ T : jet.Any?>java.util.Iterator<T?>?.filterNotNull(): java.util.Iterator<T>
public final fun </*0*/ T : jet.Any?>jet.Array<T?>?.filterNotNull(): java.util.List<T>
public final fun jet.BooleanArray?.filterNotNull(): java.util.List<jet.Boolean>
public final fun jet.ByteArray?.filterNotNull(): java.util.List<jet.Byte>
public final fun jet.CharArray?.filterNotNull(): java.util.List<jet.Char>
public final fun jet.DoubleArray?.filterNotNull(): java.util.List<jet.Double>
public final fun jet.FloatArray?.filterNotNull(): java.util.List<jet.Float>
public final fun jet.IntArray?.filterNotNull(): java.util.List<jet.Int>
public final fun </*0*/ T : jet.Any?>jet.Iterable<T?>?.filterNotNull(): java.util.List<T>
public final fun jet.LongArray?.filterNotNull(): java.util.List<jet.Long>
public final fun jet.ShortArray?.filterNotNull(): java.util.List<jet.Short>
public final fun </*0*/ T : jet.Any?, /*1*/ C : java.util.Collection<in T>>java.lang.Iterable<T?>?.filterNotNullTo(/*0*/ result: C): C
public final fun </*0*/ T : jet.Any?, /*1*/ C : java.util.Collection<in T>>java.util.Iterator<T?>?.filterNotNullTo(/*0*/ result: C): C
public final fun </*0*/ T : jet.Any?, /*1*/ C : java.util.Collection<in T>>jet.Array<T?>?.filterNotNullTo(/*0*/ result: C): C
public final fun </*0*/ C : java.util.Collection<jet.Boolean>>jet.BooleanArray?.filterNotNullTo(/*0*/ result: C): C
public final fun </*0*/ C : java.util.Collection<jet.Byte>>jet.ByteArray?.filterNotNullTo(/*0*/ result: C): C
public final fun </*0*/ C : java.util.Collection<jet.Char>>jet.CharArray?.filterNotNullTo(/*0*/ result: C): C
public final fun </*0*/ C : java.util.Collection<jet.Double>>jet.DoubleArray?.filterNotNullTo(/*0*/ result: C): C
public final fun </*0*/ C : java.util.Collection<jet.Float>>jet.FloatArray?.filterNotNullTo(/*0*/ result: C): C
public final fun </*0*/ C : java.util.Collection<jet.Int>>jet.IntArray?.filterNotNullTo(/*0*/ result: C): C
public final fun </*0*/ T : jet.Any?, /*1*/ C : java.util.Collection<in T>>jet.Iterable<T?>?.filterNotNullTo(/*0*/ result: C): C
public final fun </*0*/ C : java.util.Collection<jet.Long>>jet.LongArray?.filterNotNullTo(/*0*/ result: C): C
public final fun </*0*/ C : java.util.Collection<jet.Short>>jet.ShortArray?.filterNotNullTo(/*0*/ result: C): C
public final fun </*0*/ T : jet.Any?, /*1*/ C : java.util.Collection<in T>>java.lang.Iterable<T>.filterNotTo(/*0*/ result: C, /*1*/ predicate: jet.Function1<T, jet.Boolean>): C
public final fun </*0*/ T : jet.Any?, /*1*/ C : java.util.Collection<in T>>java.util.Iterator<T>.filterNotTo(/*0*/ result: C, /*1*/ predicate: jet.Function1<T, jet.Boolean>): C
public final fun </*0*/ T : jet.Any?, /*1*/ C : java.util.Collection<in T>>jet.Array<T>.filterNotTo(/*0*/ result: C, /*1*/ predicate: jet.Function1<T, jet.Boolean>): C
public final fun </*0*/ C : java.util.Collection<jet.Boolean>>jet.BooleanArray.filterNotTo(/*0*/ result: C, /*1*/ predicate: jet.Function1<jet.Boolean, jet.Boolean>): C
public final fun </*0*/ C : java.util.Collection<jet.Byte>>jet.ByteArray.filterNotTo(/*0*/ result: C, /*1*/ predicate: jet.Function1<jet.Byte, jet.Boolean>): C
public final fun </*0*/ C : java.util.Collection<jet.Char>>jet.CharArray.filterNotTo(/*0*/ result: C, /*1*/ predicate: jet.Function1<jet.Char, jet.Boolean>): C
public final fun </*0*/ C : java.util.Collection<jet.Double>>jet.DoubleArray.filterNotTo(/*0*/ result: C, /*1*/ predicate: jet.Function1<jet.Double, jet.Boolean>): C
public final fun </*0*/ C : java.util.Collection<jet.Float>>jet.FloatArray.filterNotTo(/*0*/ result: C, /*1*/ predicate: jet.Function1<jet.Float, jet.Boolean>): C
public final fun </*0*/ C : java.util.Collection<jet.Int>>jet.IntArray.filterNotTo(/*0*/ result: C, /*1*/ predicate: jet.Function1<jet.Int, jet.Boolean>): C
public final fun </*0*/ T : jet.Any?, /*1*/ C : java.util.Collection<in T>>jet.Iterable<T>.filterNotTo(/*0*/ result: C, /*1*/ predicate: jet.Function1<T, jet.Boolean>): C
public final fun </*0*/ C : java.util.Collection<jet.Long>>jet.LongArray.filterNotTo(/*0*/ result: C, /*1*/ predicate: jet.Function1<jet.Long, jet.Boolean>): C
public final fun </*0*/ C : java.util.Collection<jet.Short>>jet.ShortArray.filterNotTo(/*0*/ result: C, /*1*/ predicate: jet.Function1<jet.Short, jet.Boolean>): C
public final fun </*0*/ T : jet.Any?, /*1*/ C : java.util.Collection<in T>>java.lang.Iterable<T>.filterTo(/*0*/ result: C, /*1*/ predicate: jet.Function1<T, jet.Boolean>): C
public final fun </*0*/ T : jet.Any?, /*1*/ C : java.util.Collection<in T>>java.util.Iterator<T>.filterTo(/*0*/ result: C, /*1*/ predicate: jet.Function1<T, jet.Boolean>): C
public final fun </*0*/ T : jet.Any?, /*1*/ C : java.util.Collection<in T>>jet.Array<T>.filterTo(/*0*/ result: C, /*1*/ predicate: jet.Function1<T, jet.Boolean>): C
public final fun </*0*/ C : java.util.Collection<jet.Boolean>>jet.BooleanArray.filterTo(/*0*/ result: C, /*1*/ predicate: jet.Function1<jet.Boolean, jet.Boolean>): C
public final fun </*0*/ C : java.util.Collection<jet.Byte>>jet.ByteArray.filterTo(/*0*/ result: C, /*1*/ predicate: jet.Function1<jet.Byte, jet.Boolean>): C
public final fun </*0*/ C : java.util.Collection<jet.Char>>jet.CharArray.filterTo(/*0*/ result: C, /*1*/ predicate: jet.Function1<jet.Char, jet.Boolean>): C
public final fun </*0*/ C : java.util.Collection<jet.Double>>jet.DoubleArray.filterTo(/*0*/ result: C, /*1*/ predicate: jet.Function1<jet.Double, jet.Boolean>): C
public final fun </*0*/ C : java.util.Collection<jet.Float>>jet.FloatArray.filterTo(/*0*/ result: C, /*1*/ predicate: jet.Function1<jet.Float, jet.Boolean>): C
public final fun </*0*/ C : java.util.Collection<jet.Int>>jet.IntArray.filterTo(/*0*/ result: C, /*1*/ predicate: jet.Function1<jet.Int, jet.Boolean>): C
public final fun </*0*/ T : jet.Any?, /*1*/ C : java.util.Collection<in T>>jet.Iterable<T>.filterTo(/*0*/ result: C, /*1*/ predicate: jet.Function1<T, jet.Boolean>): C
public final fun </*0*/ C : java.util.Collection<jet.Long>>jet.LongArray.filterTo(/*0*/ result: C, /*1*/ predicate: jet.Function1<jet.Long, jet.Boolean>): C
public final fun </*0*/ C : java.util.Collection<jet.Short>>jet.ShortArray.filterTo(/*0*/ result: C, /*1*/ predicate: jet.Function1<jet.Short, jet.Boolean>): C
public final fun </*0*/ T : jet.Any?>java.lang.Iterable<T>.find(/*0*/ predicate: jet.Function1<T, jet.Boolean>): T?
public final fun </*0*/ T : jet.Any?>java.util.Iterator<T>.find(/*0*/ predicate: jet.Function1<T, jet.Boolean>): T?
public final fun </*0*/ T : jet.Any?>jet.Array<T>.find(/*0*/ predicate: jet.Function1<T, jet.Boolean>): T?
public final fun jet.BooleanArray.find(/*0*/ predicate: jet.Function1<jet.Boolean, jet.Boolean>): jet.Boolean?
public final fun jet.ByteArray.find(/*0*/ predicate: jet.Function1<jet.Byte, jet.Boolean>): jet.Byte?
public final fun jet.CharArray.find(/*0*/ predicate: jet.Function1<jet.Char, jet.Boolean>): jet.Char?
public final fun jet.DoubleArray.find(/*0*/ predicate: jet.Function1<jet.Double, jet.Boolean>): jet.Double?
public final fun jet.FloatArray.find(/*0*/ predicate: jet.Function1<jet.Float, jet.Boolean>): jet.Float?
public final fun jet.IntArray.find(/*0*/ predicate: jet.Function1<jet.Int, jet.Boolean>): jet.Int?
public final fun </*0*/ T : jet.Any?>jet.Iterable<T>.find(/*0*/ predicate: jet.Function1<T, jet.Boolean>): T?
public final fun jet.LongArray.find(/*0*/ predicate: jet.Function1<jet.Long, jet.Boolean>): jet.Long?
public final fun jet.ShortArray.find(/*0*/ predicate: jet.Function1<jet.Short, jet.Boolean>): jet.Short?
public final fun </*0*/ T : jet.Any?>java.lang.Iterable<T>.first(): T
public final fun </*0*/ T : jet.Any?, /*1*/ R : jet.Any?>java.lang.Iterable<T>.flatMap(/*0*/ transform: jet.Function1<T, java.util.Collection<R>>): java.util.Collection<R>
public final fun </*0*/ T : jet.Any?, /*1*/ R : jet.Any?>java.util.Iterator<T>.flatMap(/*0*/ transform: jet.Function1<T, java.util.Iterator<R>>): java.util.Iterator<R>
public final fun </*0*/ T : jet.Any?, /*1*/ R : jet.Any?>jet.Array<T>.flatMap(/*0*/ transform: jet.Function1<T, java.util.Collection<R>>): java.util.Collection<R>
public final fun </*0*/ R : jet.Any?>jet.BooleanArray.flatMap(/*0*/ transform: jet.Function1<jet.Boolean, java.util.Collection<R>>): java.util.Collection<R>
public final fun </*0*/ R : jet.Any?>jet.ByteArray.flatMap(/*0*/ transform: jet.Function1<jet.Byte, java.util.Collection<R>>): java.util.Collection<R>
public final fun </*0*/ R : jet.Any?>jet.CharArray.flatMap(/*0*/ transform: jet.Function1<jet.Char, java.util.Collection<R>>): java.util.Collection<R>
public final fun </*0*/ R : jet.Any?>jet.DoubleArray.flatMap(/*0*/ transform: jet.Function1<jet.Double, java.util.Collection<R>>): java.util.Collection<R>
public final fun </*0*/ R : jet.Any?>jet.FloatArray.flatMap(/*0*/ transform: jet.Function1<jet.Float, java.util.Collection<R>>): java.util.Collection<R>
public final fun </*0*/ R : jet.Any?>jet.IntArray.flatMap(/*0*/ transform: jet.Function1<jet.Int, java.util.Collection<R>>): java.util.Collection<R>
public final fun </*0*/ T : jet.Any?, /*1*/ R : jet.Any?>jet.Iterable<T>.flatMap(/*0*/ transform: jet.Function1<T, java.util.Collection<R>>): java.util.Collection<R>
public final fun </*0*/ R : jet.Any?>jet.LongArray.flatMap(/*0*/ transform: jet.Function1<jet.Long, java.util.Collection<R>>): java.util.Collection<R>
public final fun </*0*/ R : jet.Any?>jet.ShortArray.flatMap(/*0*/ transform: jet.Function1<jet.Short, java.util.Collection<R>>): java.util.Collection<R>
public final fun </*0*/ T : jet.Any?, /*1*/ R : jet.Any?>java.lang.Iterable<T>.flatMapTo(/*0*/ result: java.util.Collection<R>, /*1*/ transform: jet.Function1<T, java.util.Collection<R>>): java.util.Collection<R>
public final fun </*0*/ T : jet.Any?, /*1*/ R : jet.Any?>java.util.Iterator<T>.flatMapTo(/*0*/ result: java.util.Collection<R>, /*1*/ transform: jet.Function1<T, java.util.Collection<R>>): java.util.Collection<R>
public final fun </*0*/ T : jet.Any?, /*1*/ R : jet.Any?>jet.Array<T>.flatMapTo(/*0*/ result: java.util.Collection<R>, /*1*/ transform: jet.Function1<T, java.util.Collection<R>>): java.util.Collection<R>
public final fun </*0*/ R : jet.Any?>jet.BooleanArray.flatMapTo(/*0*/ result: java.util.Collection<R>, /*1*/ transform: jet.Function1<jet.Boolean, java.util.Collection<R>>): java.util.Collection<R>
public final fun </*0*/ R : jet.Any?>jet.ByteArray.flatMapTo(/*0*/ result: java.util.Collection<R>, /*1*/ transform: jet.Function1<jet.Byte, java.util.Collection<R>>): java.util.Collection<R>
public final fun </*0*/ R : jet.Any?>jet.CharArray.flatMapTo(/*0*/ result: java.util.Collection<R>, /*1*/ transform: jet.Function1<jet.Char, java.util.Collection<R>>): java.util.Collection<R>
public final fun </*0*/ R : jet.Any?>jet.DoubleArray.flatMapTo(/*0*/ result: java.util.Collection<R>, /*1*/ transform: jet.Function1<jet.Double, java.util.Collection<R>>): java.util.Collection<R>
public final fun </*0*/ R : jet.Any?>jet.FloatArray.flatMapTo(/*0*/ result: java.util.Collection<R>, /*1*/ transform: jet.Function1<jet.Float, java.util.Collection<R>>): java.util.Collection<R>
public final fun </*0*/ R : jet.Any?>jet.IntArray.flatMapTo(/*0*/ result: java.util.Collection<R>, /*1*/ transform: jet.Function1<jet.Int, java.util.Collection<R>>): java.util.Collection<R>
public final fun </*0*/ T : jet.Any?, /*1*/ R : jet.Any?>jet.Iterable<T>.flatMapTo(/*0*/ result: java.util.Collection<R>, /*1*/ transform: jet.Function1<T, java.util.Collection<R>>): java.util.Collection<R>
public final fun </*0*/ R : jet.Any?>jet.LongArray.flatMapTo(/*0*/ result: java.util.Collection<R>, /*1*/ transform: jet.Function1<jet.Long, java.util.Collection<R>>): java.util.Collection<R>
public final fun </*0*/ R : jet.Any?>jet.ShortArray.flatMapTo(/*0*/ result: java.util.Collection<R>, /*1*/ transform: jet.Function1<jet.Short, java.util.Collection<R>>): java.util.Collection<R>
public final [ERROR : <ERROR RETURN TYPE>]() fun floatArray(/*0*/ vararg content: jet.Float /*jet.FloatArray*/): jet.FloatArray
public final fun </*0*/ T : jet.Any?>java.lang.Iterable<T>.fold(/*0*/ initial: T, /*1*/ operation: jet.Function2<T, T, T>): T
public final fun </*0*/ T : jet.Any?>java.util.Iterator<T>.fold(/*0*/ initial: T, /*1*/ operation: jet.Function2<T, T, T>): T
public final fun </*0*/ T : jet.Any?>jet.Array<T>.fold(/*0*/ initial: T, /*1*/ operation: jet.Function2<T, T, T>): T
public final fun jet.BooleanArray.fold(/*0*/ initial: jet.Boolean, /*1*/ operation: jet.Function2<jet.Boolean, jet.Boolean, jet.Boolean>): jet.Boolean
public final fun jet.ByteArray.fold(/*0*/ initial: jet.Byte, /*1*/ operation: jet.Function2<jet.Byte, jet.Byte, jet.Byte>): jet.Byte
public final fun jet.CharArray.fold(/*0*/ initial: jet.Char, /*1*/ operation: jet.Function2<jet.Char, jet.Char, jet.Char>): jet.Char
public final fun jet.DoubleArray.fold(/*0*/ initial: jet.Double, /*1*/ operation: jet.Function2<jet.Double, jet.Double, jet.Double>): jet.Double
public final fun jet.FloatArray.fold(/*0*/ initial: jet.Float, /*1*/ operation: jet.Function2<jet.Float, jet.Float, jet.Float>): jet.Float
public final fun jet.IntArray.fold(/*0*/ initial: jet.Int, /*1*/ operation: jet.Function2<jet.Int, jet.Int, jet.Int>): jet.Int
public final fun </*0*/ T : jet.Any?>jet.Iterable<T>.fold(/*0*/ initial: T, /*1*/ operation: jet.Function2<T, T, T>): T
public final fun jet.LongArray.fold(/*0*/ initial: jet.Long, /*1*/ operation: jet.Function2<jet.Long, jet.Long, jet.Long>): jet.Long
public final fun jet.ShortArray.fold(/*0*/ initial: jet.Short, /*1*/ operation: jet.Function2<jet.Short, jet.Short, jet.Short>): jet.Short
public final fun </*0*/ T : jet.Any?>java.lang.Iterable<T>.foldRight(/*0*/ initial: T, /*1*/ operation: jet.Function2<T, T, T>): T
public final fun </*0*/ T : jet.Any?>java.util.Iterator<T>.foldRight(/*0*/ initial: T, /*1*/ operation: jet.Function2<T, T, T>): T
public final fun </*0*/ T : jet.Any?>jet.Array<T>.foldRight(/*0*/ initial: T, /*1*/ operation: jet.Function2<T, T, T>): T
public final fun jet.BooleanArray.foldRight(/*0*/ initial: jet.Boolean, /*1*/ operation: jet.Function2<jet.Boolean, jet.Boolean, jet.Boolean>): jet.Boolean
public final fun jet.ByteArray.foldRight(/*0*/ initial: jet.Byte, /*1*/ operation: jet.Function2<jet.Byte, jet.Byte, jet.Byte>): jet.Byte
public final fun jet.CharArray.foldRight(/*0*/ initial: jet.Char, /*1*/ operation: jet.Function2<jet.Char, jet.Char, jet.Char>): jet.Char
public final fun jet.DoubleArray.foldRight(/*0*/ initial: jet.Double, /*1*/ operation: jet.Function2<jet.Double, jet.Double, jet.Double>): jet.Double
public final fun jet.FloatArray.foldRight(/*0*/ initial: jet.Float, /*1*/ operation: jet.Function2<jet.Float, jet.Float, jet.Float>): jet.Float
public final fun jet.IntArray.foldRight(/*0*/ initial: jet.Int, /*1*/ operation: jet.Function2<jet.Int, jet.Int, jet.Int>): jet.Int
public final fun </*0*/ T : jet.Any?>jet.Iterable<T>.foldRight(/*0*/ initial: T, /*1*/ operation: jet.Function2<T, T, T>): T
public final fun jet.LongArray.foldRight(/*0*/ initial: jet.Long, /*1*/ operation: jet.Function2<jet.Long, jet.Long, jet.Long>): jet.Long
public final fun jet.ShortArray.foldRight(/*0*/ initial: jet.Short, /*1*/ operation: jet.Function2<jet.Short, jet.Short, jet.Short>): jet.Short
public final fun </*0*/ T : jet.Any?>java.lang.Iterable<T>.forEach(/*0*/ operation: jet.Function1<T, jet.Tuple0>): jet.Tuple0
public final fun </*0*/ T : jet.Any?>java.util.Iterator<T>.forEach(/*0*/ operation: jet.Function1<T, jet.Tuple0>): jet.Tuple0
public final fun </*0*/ T : jet.Any?>jet.Array<T>.forEach(/*0*/ operation: jet.Function1<T, jet.Tuple0>): jet.Tuple0
public final fun jet.BooleanArray.forEach(/*0*/ operation: jet.Function1<jet.Boolean, jet.Tuple0>): jet.Tuple0
public final fun jet.ByteArray.forEach(/*0*/ operation: jet.Function1<jet.Byte, jet.Tuple0>): jet.Tuple0
public final fun jet.CharArray.forEach(/*0*/ operation: jet.Function1<jet.Char, jet.Tuple0>): jet.Tuple0
public final fun jet.DoubleArray.forEach(/*0*/ operation: jet.Function1<jet.Double, jet.Tuple0>): jet.Tuple0
public final fun jet.FloatArray.forEach(/*0*/ operation: jet.Function1<jet.Float, jet.Tuple0>): jet.Tuple0
public final fun jet.IntArray.forEach(/*0*/ operation: jet.Function1<jet.Int, jet.Tuple0>): jet.Tuple0
public final fun </*0*/ T : jet.Any?>jet.Iterable<T>.forEach(/*0*/ operation: jet.Function1<T, jet.Tuple0>): jet.Tuple0
public final fun jet.LongArray.forEach(/*0*/ operation: jet.Function1<jet.Long, jet.Tuple0>): jet.Tuple0
public final fun jet.ShortArray.forEach(/*0*/ operation: jet.Function1<jet.Short, jet.Tuple0>): jet.Tuple0
public final fun jet.String.format(/*0*/ format: jet.String, /*1*/ vararg args: jet.Any? /*jet.Array<jet.Any?>*/): jet.String
public final fun jet.CharSequence.get(/*0*/ index: jet.Int): jet.Char
public final fun jet.CharSequence.get(/*0*/ start: jet.Int, /*1*/ end: jet.Int): jet.CharSequence?
public final fun jet.String.getBytes(): jet.ByteArray
public final fun jet.String.getBytes(/*0*/ charset: java.nio.charset.Charset): jet.ByteArray
public final fun jet.String.getBytes(/*0*/ charsetName: jet.String): jet.ByteArray
public final fun jet.String.getChars(/*0*/ srcBegin: jet.Int, /*1*/ srcEnd: jet.Int, /*2*/ dst: jet.CharArray, /*3*/ dstBegin: jet.Int): jet.Tuple0
public final fun </*0*/ K : jet.Any?, /*1*/ V : jet.Any?>java.util.Map<K, V>.getOrElse(/*0*/ key: K, /*1*/ defaultValue: jet.Function0<V>): V
public final fun </*0*/ K : jet.Any?, /*1*/ V : jet.Any?>java.util.Map<K, V>.getOrPut(/*0*/ key: K, /*1*/ defaultValue: jet.Function0<V>): V
public final fun </*0*/ T : jet.Any?, /*1*/ K : jet.Any?>java.lang.Iterable<T>.groupBy(/*0*/ toKey: jet.Function1<T, K>): java.util.Map<K, java.util.List<T>>
public final fun </*0*/ T : jet.Any?, /*1*/ K : jet.Any?>java.util.Iterator<T>.groupBy(/*0*/ toKey: jet.Function1<T, K>): java.util.Map<K, java.util.List<T>>
public final fun </*0*/ T : jet.Any?, /*1*/ K : jet.Any?>jet.Array<T>.groupBy(/*0*/ toKey: jet.Function1<T, K>): java.util.Map<K, java.util.List<T>>
public final fun </*0*/ K : jet.Any?>jet.BooleanArray.groupBy(/*0*/ toKey: jet.Function1<jet.Boolean, K>): java.util.Map<K, java.util.List<jet.Boolean>>
public final fun </*0*/ K : jet.Any?>jet.ByteArray.groupBy(/*0*/ toKey: jet.Function1<jet.Byte, K>): java.util.Map<K, java.util.List<jet.Byte>>
public final fun </*0*/ K : jet.Any?>jet.CharArray.groupBy(/*0*/ toKey: jet.Function1<jet.Char, K>): java.util.Map<K, java.util.List<jet.Char>>
public final fun </*0*/ K : jet.Any?>jet.DoubleArray.groupBy(/*0*/ toKey: jet.Function1<jet.Double, K>): java.util.Map<K, java.util.List<jet.Double>>
public final fun </*0*/ K : jet.Any?>jet.FloatArray.groupBy(/*0*/ toKey: jet.Function1<jet.Float, K>): java.util.Map<K, java.util.List<jet.Float>>
public final fun </*0*/ K : jet.Any?>jet.IntArray.groupBy(/*0*/ toKey: jet.Function1<jet.Int, K>): java.util.Map<K, java.util.List<jet.Int>>
public final fun </*0*/ T : jet.Any?, /*1*/ K : jet.Any?>jet.Iterable<T>.groupBy(/*0*/ toKey: jet.Function1<T, K>): java.util.Map<K, java.util.List<T>>
public final fun </*0*/ K : jet.Any?>jet.LongArray.groupBy(/*0*/ toKey: jet.Function1<jet.Long, K>): java.util.Map<K, java.util.List<jet.Long>>
public final fun </*0*/ K : jet.Any?>jet.ShortArray.groupBy(/*0*/ toKey: jet.Function1<jet.Short, K>): java.util.Map<K, java.util.List<jet.Short>>
public final fun </*0*/ T : jet.Any?, /*1*/ K : jet.Any?>java.lang.Iterable<T>.groupByTo(/*0*/ result: java.util.Map<K, java.util.List<T>>, /*1*/ toKey: jet.Function1<T, K>): java.util.Map<K, java.util.List<T>>
public final fun </*0*/ T : jet.Any?, /*1*/ K : jet.Any?>java.util.Iterator<T>.groupByTo(/*0*/ result: java.util.Map<K, java.util.List<T>>, /*1*/ toKey: jet.Function1<T, K>): java.util.Map<K, java.util.List<T>>
public final fun </*0*/ T : jet.Any?, /*1*/ K : jet.Any?>jet.Array<T>.groupByTo(/*0*/ result: java.util.Map<K, java.util.List<T>>, /*1*/ toKey: jet.Function1<T, K>): java.util.Map<K, java.util.List<T>>
public final fun </*0*/ K : jet.Any?>jet.BooleanArray.groupByTo(/*0*/ result: java.util.Map<K, java.util.List<jet.Boolean>>, /*1*/ toKey: jet.Function1<jet.Boolean, K>): java.util.Map<K, java.util.List<jet.Boolean>>
public final fun </*0*/ K : jet.Any?>jet.ByteArray.groupByTo(/*0*/ result: java.util.Map<K, java.util.List<jet.Byte>>, /*1*/ toKey: jet.Function1<jet.Byte, K>): java.util.Map<K, java.util.List<jet.Byte>>
public final fun </*0*/ K : jet.Any?>jet.CharArray.groupByTo(/*0*/ result: java.util.Map<K, java.util.List<jet.Char>>, /*1*/ toKey: jet.Function1<jet.Char, K>): java.util.Map<K, java.util.List<jet.Char>>
public final fun </*0*/ K : jet.Any?>jet.DoubleArray.groupByTo(/*0*/ result: java.util.Map<K, java.util.List<jet.Double>>, /*1*/ toKey: jet.Function1<jet.Double, K>): java.util.Map<K, java.util.List<jet.Double>>
public final fun </*0*/ K : jet.Any?>jet.FloatArray.groupByTo(/*0*/ result: java.util.Map<K, java.util.List<jet.Float>>, /*1*/ toKey: jet.Function1<jet.Float, K>): java.util.Map<K, java.util.List<jet.Float>>
public final fun </*0*/ K : jet.Any?>jet.IntArray.groupByTo(/*0*/ result: java.util.Map<K, java.util.List<jet.Int>>, /*1*/ toKey: jet.Function1<jet.Int, K>): java.util.Map<K, java.util.List<jet.Int>>
public final fun </*0*/ T : jet.Any?, /*1*/ K : jet.Any?>jet.Iterable<T>.groupByTo(/*0*/ result: java.util.Map<K, java.util.List<T>>, /*1*/ toKey: jet.Function1<T, K>): java.util.Map<K, java.util.List<T>>
public final fun </*0*/ K : jet.Any?>jet.LongArray.groupByTo(/*0*/ result: java.util.Map<K, java.util.List<jet.Long>>, /*1*/ toKey: jet.Function1<jet.Long, K>): java.util.Map<K, java.util.List<jet.Long>>
public final fun </*0*/ K : jet.Any?>jet.ShortArray.groupByTo(/*0*/ result: java.util.Map<K, java.util.List<jet.Short>>, /*1*/ toKey: jet.Function1<jet.Short, K>): java.util.Map<K, java.util.List<jet.Short>>
public final fun jet.String.hashCode(): jet.Int
public final fun </*0*/ K : jet.Any?, /*1*/ V : jet.Any?>hashMap(/*0*/ vararg values: jet.Tuple2<out K, out V> /*jet.Array<jet.Tuple2<out K, out V>>*/): java.util.HashMap<K, V>
public final fun </*0*/ T : jet.Any?>hashSet(/*0*/ vararg values: T /*jet.Array<T>*/): java.util.HashSet<T>
public final fun jet.String.indexOf(/*0*/ ch: jet.Char): jet.Int
public final fun jet.String.indexOf(/*0*/ ch: jet.Char, /*1*/ fromIndex: jet.Int): jet.Int
public final fun jet.String.indexOf(/*0*/ str: jet.String): jet.Int
public final fun jet.String.indexOf(/*0*/ str: jet.String, /*1*/ fromIndex: jet.Int): jet.Int
public final fun jet.ByteArray.inputStream(/*0*/ offset: jet.Int, /*1*/ length: jet.Int): java.io.ByteArrayInputStream
public final [ERROR : <ERROR RETURN TYPE>]() fun intArray(/*0*/ vararg content: jet.Int /*jet.IntArray*/): jet.IntArray
public final fun jet.String.intern(): jet.String
public final fun jet.Char.isDefined(): jet.Boolean
public final fun jet.Char.isDigit(): jet.Boolean
public final fun </*0*/ T : jet.Any?>jet.Array<T>.isEmpty(): jet.Boolean
public final fun jet.String.isEmpty(): jet.Boolean
public final fun jet.Char.isHighSurrogate(): jet.Boolean
public final fun jet.Char.isISOControl(): jet.Boolean
public final fun jet.Char.isIdentifierIgnorable(): jet.Boolean
public final fun jet.Char.isJavaIdentifierPart(): jet.Boolean
public final fun jet.Char.isJavaIdentifierStart(): jet.Boolean
public final fun jet.Char.isJavaLetter(): jet.Boolean
public final fun jet.Char.isJavaLetterOrDigit(): jet.Boolean
public final fun jet.Char.isLowerCase(): jet.Boolean
public final fun jet.Char.isUpperCase(): jet.Boolean
public final fun jet.Char.isWhitespace(): jet.Boolean
public final fun </*0*/ T : jet.Any?>iterate(/*0*/ nextFunction: jet.Function0<T?>): java.util.Iterator<T>
public final fun </*0*/ T : jet.Any?>java.util.Enumeration<T>.iterator(): jet.Iterator<T>
public final fun </*0*/ T : jet.Any?>java.util.Iterator<T>.iterator(): java.util.Iterator<T>
public final fun </*0*/ K : jet.Any?, /*1*/ V : jet.Any?>java.util.Map<K, V>.iterator(): java.util.Iterator<java.util.Map.Entry<K, V>>
public final fun jet.CharSequence.iterator(): jet.CharIterator
public final fun </*0*/ T : jet.Any?>jet.Iterator<T>.iterator(): jet.Iterator<T>
internal final [ERROR : <ERROR RETURN TYPE>]() fun </*0*/ out T : jet.Any?>javaClass(): java.lang.Class<T>
public final fun </*0*/ T : jet.Any?>java.lang.Iterable<T>.last(): T
public final fun jet.String.lastIndexOf(/*0*/ ch: jet.Char): jet.Int
public final fun jet.String.lastIndexOf(/*0*/ ch: jet.Char, /*1*/ fromIndex: jet.Int): jet.Int
public final fun jet.String.lastIndexOf(/*0*/ str: jet.String): jet.Int
public final fun jet.String.lastIndexOf(/*0*/ str: jet.String, /*1*/ fromIndex: jet.Int): jet.Int
public final fun jet.CharSequence.length(): jet.Int
public final fun jet.String.length(): jet.Int
public final fun </*0*/ T : jet.Any?>linkedList(/*0*/ vararg values: T /*jet.Array<T>*/): java.util.LinkedList<T>
public final fun </*0*/ K : jet.Any?, /*1*/ V : jet.Any?>linkedMap(/*0*/ vararg values: jet.Tuple2<out K, out V> /*jet.Array<jet.Tuple2<out K, out V>>*/): java.util.LinkedHashMap<K, V>
public final fun </*0*/ T : jet.Any?>listBuilder(): kotlin.ImmutableArrayListBuilder<T>
public final [ERROR : <ERROR RETURN TYPE>]() fun longArray(/*0*/ vararg content: jet.Long /*jet.LongArray*/): jet.LongArray
public final fun </*0*/ T : jet.Any?>java.lang.Iterable<T>.makeString(/*0*/ separator: jet.String = ?, /*1*/ prefix: jet.String = ?, /*2*/ postfix: jet.String = ?, /*3*/ limit: jet.Int = ?, /*4*/ truncated: jet.String = ?): jet.String
public final fun </*0*/ T : jet.Any?>java.util.Iterator<T>.makeString(/*0*/ separator: jet.String = ?, /*1*/ prefix: jet.String = ?, /*2*/ postfix: jet.String = ?, /*3*/ limit: jet.Int = ?, /*4*/ truncated: jet.String = ?): jet.String
public final fun </*0*/ T : jet.Any?>jet.Array<T>.makeString(/*0*/ separator: jet.String = ?, /*1*/ prefix: jet.String = ?, /*2*/ postfix: jet.String = ?, /*3*/ limit: jet.Int = ?, /*4*/ truncated: jet.String = ?): jet.String
public final fun jet.BooleanArray.makeString(/*0*/ separator: jet.String = ?, /*1*/ prefix: jet.String = ?, /*2*/ postfix: jet.String = ?, /*3*/ limit: jet.Int = ?, /*4*/ truncated: jet.String = ?): jet.String
public final fun jet.ByteArray.makeString(/*0*/ separator: jet.String = ?, /*1*/ prefix: jet.String = ?, /*2*/ postfix: jet.String = ?, /*3*/ limit: jet.Int = ?, /*4*/ truncated: jet.String = ?): jet.String
public final fun jet.CharArray.makeString(/*0*/ separator: jet.String = ?, /*1*/ prefix: jet.String = ?, /*2*/ postfix: jet.String = ?, /*3*/ limit: jet.Int = ?, /*4*/ truncated: jet.String = ?): jet.String
public final fun jet.DoubleArray.makeString(/*0*/ separator: jet.String = ?, /*1*/ prefix: jet.String = ?, /*2*/ postfix: jet.String = ?, /*3*/ limit: jet.Int = ?, /*4*/ truncated: jet.String = ?): jet.String
public final fun jet.FloatArray.makeString(/*0*/ separator: jet.String = ?, /*1*/ prefix: jet.String = ?, /*2*/ postfix: jet.String = ?, /*3*/ limit: jet.Int = ?, /*4*/ truncated: jet.String = ?): jet.String
public final fun jet.IntArray.makeString(/*0*/ separator: jet.String = ?, /*1*/ prefix: jet.String = ?, /*2*/ postfix: jet.String = ?, /*3*/ limit: jet.Int = ?, /*4*/ truncated: jet.String = ?): jet.String
public final fun </*0*/ T : jet.Any?>jet.Iterable<T>.makeString(/*0*/ separator: jet.String = ?, /*1*/ prefix: jet.String = ?, /*2*/ postfix: jet.String = ?, /*3*/ limit: jet.Int = ?, /*4*/ truncated: jet.String = ?): jet.String
public final fun jet.LongArray.makeString(/*0*/ separator: jet.String = ?, /*1*/ prefix: jet.String = ?, /*2*/ postfix: jet.String = ?, /*3*/ limit: jet.Int = ?, /*4*/ truncated: jet.String = ?): jet.String
public final fun jet.ShortArray.makeString(/*0*/ separator: jet.String = ?, /*1*/ prefix: jet.String = ?, /*2*/ postfix: jet.String = ?, /*3*/ limit: jet.Int = ?, /*4*/ truncated: jet.String = ?): jet.String
public final fun </*0*/ T : jet.Any?, /*1*/ R : jet.Any?>java.lang.Iterable<T>.map(/*0*/ transform: jet.Function1<T, R>): java.util.List<R>
public final fun </*0*/ T : jet.Any?, /*1*/ R : jet.Any?>java.util.Collection<T>.map(/*0*/ transform: jet.Function1<T, R>): java.util.List<R>
public final fun </*0*/ T : jet.Any?, /*1*/ R : jet.Any?>java.util.Iterator<T>.map(/*0*/ transform: jet.Function1<T, R>): java.util.Iterator<R>
public final fun </*0*/ K : jet.Any?, /*1*/ V : jet.Any?, /*2*/ R : jet.Any?>java.util.Map<K, V>.map(/*0*/ transform: jet.Function1<java.util.Map.Entry<K, V>, R>): java.util.List<R>
public final fun </*0*/ T : jet.Any?, /*1*/ R : jet.Any?>jet.Array<T>.map(/*0*/ transform: jet.Function1<T, R>): java.util.List<R>
public final fun </*0*/ R : jet.Any?>jet.BooleanArray.map(/*0*/ transform: jet.Function1<jet.Boolean, R>): java.util.List<R>
public final fun </*0*/ R : jet.Any?>jet.ByteArray.map(/*0*/ transform: jet.Function1<jet.Byte, R>): java.util.List<R>
public final fun </*0*/ R : jet.Any?>jet.CharArray.map(/*0*/ transform: jet.Function1<jet.Char, R>): java.util.List<R>
public final fun </*0*/ R : jet.Any?>jet.DoubleArray.map(/*0*/ transform: jet.Function1<jet.Double, R>): java.util.List<R>
public final fun </*0*/ R : jet.Any?>jet.FloatArray.map(/*0*/ transform: jet.Function1<jet.Float, R>): java.util.List<R>
public final fun </*0*/ R : jet.Any?>jet.IntArray.map(/*0*/ transform: jet.Function1<jet.Int, R>): java.util.List<R>
public final fun </*0*/ T : jet.Any?, /*1*/ R : jet.Any?>jet.Iterable<T>.map(/*0*/ transform: jet.Function1<T, R>): java.util.List<R>
public final fun </*0*/ R : jet.Any?>jet.LongArray.map(/*0*/ transform: jet.Function1<jet.Long, R>): java.util.List<R>
public final fun </*0*/ R : jet.Any?>jet.ShortArray.map(/*0*/ transform: jet.Function1<jet.Short, R>): java.util.List<R>
public final fun </*0*/ T : jet.Any?, /*1*/ R : jet.Any?, /*2*/ C : java.util.Collection<in R>>java.lang.Iterable<T>.mapTo(/*0*/ result: C, /*1*/ transform: jet.Function1<T, R>): C
public final fun </*0*/ T : jet.Any?, /*1*/ R : jet.Any?, /*2*/ C : java.util.Collection<in R>>java.util.Collection<T>.mapTo(/*0*/ result: C, /*1*/ transform: jet.Function1<T, R>): C
public final fun </*0*/ K : jet.Any?, /*1*/ V : jet.Any?, /*2*/ R : jet.Any?, /*3*/ C : java.util.Collection<in R>>java.util.Map<K, V>.mapTo(/*0*/ result: C, /*1*/ transform: jet.Function1<java.util.Map.Entry<K, V>, R>): C
public final fun </*0*/ T : jet.Any?, /*1*/ R : jet.Any?, /*2*/ C : java.util.Collection<in R>>jet.Array<T>.mapTo(/*0*/ result: C, /*1*/ transform: jet.Function1<T, R>): C
public final fun </*0*/ R : jet.Any?, /*1*/ C : java.util.Collection<in R>>jet.BooleanArray.mapTo(/*0*/ result: C, /*1*/ transform: jet.Function1<jet.Boolean, R>): C
public final fun </*0*/ R : jet.Any?, /*1*/ C : java.util.Collection<in R>>jet.ByteArray.mapTo(/*0*/ result: C, /*1*/ transform: jet.Function1<jet.Byte, R>): C
public final fun </*0*/ R : jet.Any?, /*1*/ C : java.util.Collection<in R>>jet.CharArray.mapTo(/*0*/ result: C, /*1*/ transform: jet.Function1<jet.Char, R>): C
public final fun </*0*/ R : jet.Any?, /*1*/ C : java.util.Collection<in R>>jet.DoubleArray.mapTo(/*0*/ result: C, /*1*/ transform: jet.Function1<jet.Double, R>): C
public final fun </*0*/ R : jet.Any?, /*1*/ C : java.util.Collection<in R>>jet.FloatArray.mapTo(/*0*/ result: C, /*1*/ transform: jet.Function1<jet.Float, R>): C
public final fun </*0*/ R : jet.Any?, /*1*/ C : java.util.Collection<in R>>jet.IntArray.mapTo(/*0*/ result: C, /*1*/ transform: jet.Function1<jet.Int, R>): C
public final fun </*0*/ T : jet.Any?, /*1*/ R : jet.Any?, /*2*/ C : java.util.Collection<in R>>jet.Iterable<T>.mapTo(/*0*/ result: C, /*1*/ transform: jet.Function1<T, R>): C
public final fun </*0*/ R : jet.Any?, /*1*/ C : java.util.Collection<in R>>jet.LongArray.mapTo(/*0*/ result: C, /*1*/ transform: jet.Function1<jet.Long, R>): C
public final fun </*0*/ R : jet.Any?, /*1*/ C : java.util.Collection<in R>>jet.ShortArray.mapTo(/*0*/ result: C, /*1*/ transform: jet.Function1<jet.Short, R>): C
public final fun </*0*/ K : jet.Any?, /*1*/ V : jet.Any?, /*2*/ R : jet.Any?>java.util.Map<K, V>.mapValues(/*0*/ transform: jet.Function1<java.util.Map.Entry<K, V>, R>): java.util.Map<K, R>
public final fun </*0*/ K : jet.Any?, /*1*/ V : jet.Any?, /*2*/ R : jet.Any?, /*3*/ C : java.util.Map<K, R>>java.util.Map<K, V>.mapValuesTo(/*0*/ result: C, /*1*/ transform: jet.Function1<java.util.Map.Entry<K, V>, R>): C
public final fun jet.String.matches(/*0*/ regex: jet.String): jet.Boolean
public final fun </*0*/ T : jet.Any?>java.util.Collection<T>.notEmpty(): jet.Boolean
public final fun </*0*/ T : jet.Any?>jet.Array<T>.notEmpty(): jet.Boolean
public final fun jet.String?.notEmpty(): jet.Boolean
public final fun jet.String.offsetByCodePoints(/*0*/ index: jet.Int, /*1*/ codePointOffset: jet.Int): jet.Int
public final fun </*0*/ T : jet.Any?>java.util.Collection<T>?.orEmpty(): java.util.Collection<T>
public final fun </*0*/ T : jet.Any?>java.util.List<T>?.orEmpty(): java.util.List<T>
public final fun </*0*/ K : jet.Any?, /*1*/ V : jet.Any?>java.util.Map<K, V>?.orEmpty(): java.util.Map<K, V>
public final fun </*0*/ T : jet.Any?>java.util.Set<T>?.orEmpty(): java.util.Set<T>
public final fun </*0*/ T : jet.Any?>jet.Array<T>?.orEmpty(): jet.Array<T>
public final fun jet.String?.orEmpty(): jet.String
public final fun </*0*/ in T : jet.Any?>java.lang.Iterable<T>.plus(/*0*/ element: T): java.util.List<in T>
public final fun </*0*/ in T : jet.Any?>java.lang.Iterable<T>.plus(/*0*/ elements: java.lang.Iterable<T>): java.util.List<T>
public final fun </*0*/ in T : jet.Any?>java.util.Iterator<T>.plus(/*0*/ collection: java.lang.Iterable<T>): java.util.Iterator<T>
public final fun </*0*/ in T : jet.Any?>java.util.Iterator<T>.plus(/*0*/ element: T): java.util.Iterator<T>
public final fun </*0*/ in T : jet.Any?>java.util.Iterator<T>.plus(/*0*/ iterator: java.util.Iterator<T>): java.util.Iterator<T>
public final fun </*0*/ in T : jet.Any?>jet.Array<T>.plus(/*0*/ element: T): java.util.List<in T>
public final fun </*0*/ in T : jet.Any?>jet.Array<T>.plus(/*0*/ elements: jet.Array<T>): java.util.List<T>
public final fun jet.BooleanArray.plus(/*0*/ element: jet.Boolean): java.util.List<jet.Boolean>
public final fun jet.BooleanArray.plus(/*0*/ elements: jet.BooleanArray): java.util.List<jet.Boolean>
public final fun jet.ByteArray.plus(/*0*/ element: jet.Byte): java.util.List<jet.Byte>
public final fun jet.ByteArray.plus(/*0*/ elements: jet.ByteArray): java.util.List<jet.Byte>
public final fun jet.CharArray.plus(/*0*/ element: jet.Char): java.util.List<jet.Char>
public final fun jet.CharArray.plus(/*0*/ elements: jet.CharArray): java.util.List<jet.Char>
public final fun jet.DoubleArray.plus(/*0*/ element: jet.Double): java.util.List<jet.Double>
public final fun jet.DoubleArray.plus(/*0*/ elements: jet.DoubleArray): java.util.List<jet.Double>
public final fun jet.FloatArray.plus(/*0*/ element: jet.Float): java.util.List<jet.Float>
public final fun jet.FloatArray.plus(/*0*/ elements: jet.FloatArray): java.util.List<jet.Float>
public final fun jet.IntArray.plus(/*0*/ element: jet.Int): java.util.List<jet.Int>
public final fun jet.IntArray.plus(/*0*/ elements: jet.IntArray): java.util.List<jet.Int>
public final fun </*0*/ in T : jet.Any?>jet.Iterable<T>.plus(/*0*/ element: T): java.util.List<in T>
public final fun </*0*/ in T : jet.Any?>jet.Iterable<T>.plus(/*0*/ elements: jet.Iterable<T>): java.util.List<T>
public final fun jet.LongArray.plus(/*0*/ element: jet.Long): java.util.List<jet.Long>
public final fun jet.LongArray.plus(/*0*/ elements: jet.LongArray): java.util.List<jet.Long>
public final fun jet.ShortArray.plus(/*0*/ element: jet.Short): java.util.List<jet.Short>
public final fun jet.ShortArray.plus(/*0*/ elements: jet.ShortArray): java.util.List<jet.Short>
public final fun jet.Throwable.printStackTrace(/*0*/ stream: java.io.PrintStream): jet.Tuple0
public final fun jet.Throwable.printStackTrace(/*0*/ writer: java.io.PrintWriter): jet.Tuple0
public final fun </*0*/ K : jet.Any?, /*1*/ V : jet.Any?>java.util.Map<K, V>.putAll(/*0*/ vararg values: jet.Tuple2<out K, out V> /*jet.Array<jet.Tuple2<out K, out V>>*/): jet.Tuple0
public final fun </*0*/ T : jet.Any?>java.lang.Iterable<T>.reduce(/*0*/ operation: jet.Function2<T, T, T>): T
public final fun </*0*/ T : jet.Any?>java.util.Iterator<T>.reduce(/*0*/ operation: jet.Function2<T, T, T>): T
public final fun </*0*/ T : jet.Any?>jet.Array<T>.reduce(/*0*/ operation: jet.Function2<T, T, T>): T
public final fun jet.BooleanArray.reduce(/*0*/ operation: jet.Function2<jet.Boolean, jet.Boolean, jet.Boolean>): jet.Boolean
public final fun jet.ByteArray.reduce(/*0*/ operation: jet.Function2<jet.Byte, jet.Byte, jet.Byte>): jet.Byte
public final fun jet.CharArray.reduce(/*0*/ operation: jet.Function2<jet.Char, jet.Char, jet.Char>): jet.Char
public final fun jet.DoubleArray.reduce(/*0*/ operation: jet.Function2<jet.Double, jet.Double, jet.Double>): jet.Double
public final fun jet.FloatArray.reduce(/*0*/ operation: jet.Function2<jet.Float, jet.Float, jet.Float>): jet.Float
public final fun jet.IntArray.reduce(/*0*/ operation: jet.Function2<jet.Int, jet.Int, jet.Int>): jet.Int
public final fun </*0*/ T : jet.Any?>jet.Iterable<T>.reduce(/*0*/ operation: jet.Function2<T, T, T>): T
public final fun jet.LongArray.reduce(/*0*/ operation: jet.Function2<jet.Long, jet.Long, jet.Long>): jet.Long
public final fun jet.ShortArray.reduce(/*0*/ operation: jet.Function2<jet.Short, jet.Short, jet.Short>): jet.Short
public final fun </*0*/ T : jet.Any?>java.lang.Iterable<T>.reduceRight(/*0*/ operation: jet.Function2<T, T, T>): T
public final fun </*0*/ T : jet.Any?>java.util.Iterator<T>.reduceRight(/*0*/ operation: jet.Function2<T, T, T>): T
public final fun </*0*/ T : jet.Any?>jet.Array<T>.reduceRight(/*0*/ operation: jet.Function2<T, T, T>): T
public final fun jet.BooleanArray.reduceRight(/*0*/ operation: jet.Function2<jet.Boolean, jet.Boolean, jet.Boolean>): jet.Boolean
public final fun jet.ByteArray.reduceRight(/*0*/ operation: jet.Function2<jet.Byte, jet.Byte, jet.Byte>): jet.Byte
public final fun jet.CharArray.reduceRight(/*0*/ operation: jet.Function2<jet.Char, jet.Char, jet.Char>): jet.Char
public final fun jet.DoubleArray.reduceRight(/*0*/ operation: jet.Function2<jet.Double, jet.Double, jet.Double>): jet.Double
public final fun jet.FloatArray.reduceRight(/*0*/ operation: jet.Function2<jet.Float, jet.Float, jet.Float>): jet.Float
public final fun jet.IntArray.reduceRight(/*0*/ operation: jet.Function2<jet.Int, jet.Int, jet.Int>): jet.Int
public final fun </*0*/ T : jet.Any?>jet.Iterable<T>.reduceRight(/*0*/ operation: jet.Function2<T, T, T>): T
public final fun jet.LongArray.reduceRight(/*0*/ operation: jet.Function2<jet.Long, jet.Long, jet.Long>): jet.Long
public final fun jet.ShortArray.reduceRight(/*0*/ operation: jet.Function2<jet.Short, jet.Short, jet.Short>): jet.Short
public final fun jet.String.regionMatches(/*0*/ ignoreCase: jet.Boolean, /*1*/ toffset: jet.Int, /*2*/ other: jet.String, /*3*/ ooffset: jet.Int, /*4*/ len: jet.Int): jet.Boolean
public final fun jet.String.regionMatches(/*0*/ toffset: jet.Int, /*1*/ other: jet.String, /*2*/ ooffset: jet.Int, /*3*/ len: jet.Int): jet.Boolean
public final fun jet.String.replace(/*0*/ oldChar: jet.Char, /*1*/ newChar: jet.Char): jet.String
public final fun jet.String.replace(/*0*/ target: jet.CharSequence, /*1*/ replacement: jet.CharSequence): jet.String
public final fun jet.String.replaceAll(/*0*/ regex: jet.String, /*1*/ replacement: jet.String): jet.String
public final fun jet.String.replaceFirst(/*0*/ regex: jet.String, /*1*/ replacement: jet.String): jet.String
public final fun require(/*0*/ value: jet.Boolean, /*1*/ lazyMessage: jet.Function0<jet.String>): jet.Tuple0
public final fun require(/*0*/ value: jet.Boolean, /*1*/ message: jet.Any = ?): jet.Tuple0
public final fun </*0*/ in T : jet.Any?>java.lang.Iterable<T?>?.requireNoNulls(): java.util.List<T>
public final fun </*0*/ in T : jet.Any?>java.util.Iterator<T?>.requireNoNulls(): java.util.Iterator<T>
public final fun </*0*/ in T : jet.Any?>jet.Array<T?>?.requireNoNulls(): java.util.List<T>
public final fun jet.BooleanArray?.requireNoNulls(): java.util.List<jet.Boolean>
public final fun jet.ByteArray?.requireNoNulls(): java.util.List<jet.Byte>
public final fun jet.CharArray?.requireNoNulls(): java.util.List<jet.Char>
public final fun jet.DoubleArray?.requireNoNulls(): java.util.List<jet.Double>
public final fun jet.FloatArray?.requireNoNulls(): java.util.List<jet.Float>
public final fun jet.IntArray?.requireNoNulls(): java.util.List<jet.Int>
public final fun </*0*/ in T : jet.Any?>jet.Iterable<T?>?.requireNoNulls(): java.util.List<T>
public final fun jet.LongArray?.requireNoNulls(): java.util.List<jet.Long>
public final fun jet.ShortArray?.requireNoNulls(): java.util.List<jet.Short>
public final fun </*0*/ T : jet.Any?>requireNotNull(/*0*/ value: T?, /*1*/ message: jet.Any = ?): T
public final fun </*0*/ T : jet.Any?>java.lang.Iterable<T>.reverse(): java.util.List<T>
public final fun </*0*/ T : jet.Any?>java.util.Iterator<T>.reverse(): java.util.List<T>
public final fun </*0*/ T : jet.Any?>jet.Array<T>.reverse(): java.util.List<T>
public final fun jet.BooleanArray.reverse(): java.util.List<jet.Boolean>
public final fun jet.ByteArray.reverse(): java.util.List<jet.Byte>
public final fun jet.CharArray.reverse(): java.util.List<jet.Char>
public final fun jet.DoubleArray.reverse(): java.util.List<jet.Double>
public final fun jet.FloatArray.reverse(): java.util.List<jet.Float>
public final fun jet.IntArray.reverse(): java.util.List<jet.Int>
public final fun </*0*/ T : jet.Any?>jet.Iterable<T>.reverse(): java.util.List<T>
public final fun jet.LongArray.reverse(): java.util.List<jet.Long>
public final fun jet.ShortArray.reverse(): java.util.List<jet.Short>
public final fun </*0*/ T : jet.Any?>run(/*0*/ f: jet.Function0<T>): T
public final fun runnable(/*0*/ action: jet.Function0<jet.Tuple0>): java.lang.Runnable
public final fun </*0*/ K : jet.Any?, /*1*/ V : jet.Any?>java.util.Map<K, V>.set(/*0*/ key: K, /*1*/ value: V): V?
public final [ERROR : <ERROR RETURN TYPE>]() fun shortArray(/*0*/ vararg content: jet.Short /*jet.ShortArray*/): jet.ShortArray
public final fun </*0*/ in T : java.lang.Comparable<T>>java.lang.Iterable<T>.sort(): java.util.List<T>
public final fun </*0*/ in T : jet.Any?>java.lang.Iterable<T>.sort(/*0*/ comparator: java.util.Comparator<T>): java.util.List<T>
public final fun jet.ByteArray.sort(): jet.Tuple0
public final fun jet.ByteArray.sort(/*0*/ fromIndex: jet.Int, /*1*/ toIndex: jet.Int): jet.Tuple0
public final fun jet.CharArray.sort(): jet.Tuple0
public final fun jet.CharArray.sort(/*0*/ fromIndex: jet.Int, /*1*/ toIndex: jet.Int): jet.Tuple0
public final fun jet.DoubleArray.sort(): jet.Tuple0
public final fun jet.DoubleArray.sort(/*0*/ fromIndex: jet.Int, /*1*/ toIndex: jet.Int): jet.Tuple0
public final fun jet.FloatArray.sort(): jet.Tuple0
public final fun jet.FloatArray.sort(/*0*/ fromIndex: jet.Int, /*1*/ toIndex: jet.Int): jet.Tuple0
public final fun jet.IntArray.sort(): jet.Tuple0
public final fun jet.IntArray.sort(/*0*/ fromIndex: jet.Int, /*1*/ toIndex: jet.Int): jet.Tuple0
public final fun jet.LongArray.sort(): jet.Tuple0
public final fun jet.LongArray.sort(/*0*/ fromIndex: jet.Int, /*1*/ toIndex: jet.Int): jet.Tuple0
public final fun jet.ShortArray.sort(): jet.Tuple0
public final fun jet.ShortArray.sort(/*0*/ fromIndex: jet.Int, /*1*/ toIndex: jet.Int): jet.Tuple0
public final fun </*0*/ in T : jet.Any?, /*1*/ R : jet.Comparable<in R>>java.lang.Iterable<T>.sortBy(/*0*/ f: jet.Function1<T, R>): java.util.List<T>
public final fun </*0*/ K : jet.Any?, /*1*/ V : jet.Any?>sortedMap(/*0*/ vararg values: jet.Tuple2<out K, out V> /*jet.Array<jet.Tuple2<out K, out V>>*/): java.util.SortedMap<K, V>
public final fun </*0*/ T : jet.Any?>sortedSet(/*0*/ comparator: java.util.Comparator<T>, /*1*/ vararg values: T /*jet.Array<T>*/): java.util.TreeSet<T>
public final fun </*0*/ T : jet.Any?>sortedSet(/*0*/ vararg values: T /*jet.Array<T>*/): java.util.TreeSet<T>
public final fun jet.String.split(/*0*/ ch: jet.Char): jet.Array<jet.String>
public final fun jet.String.split(/*0*/ regex: jet.String): jet.Array<jet.String>
public final fun jet.String.split(/*0*/ regex: jet.String, /*1*/ limit: jet.Int): jet.Array<jet.String?>
public final fun jet.String.startsWith(/*0*/ ch: jet.Char): jet.Boolean
public final fun jet.String.startsWith(/*0*/ prefix: jet.String): jet.Boolean
public final fun jet.String.startsWith(/*0*/ prefix: jet.String, /*1*/ toffset: jet.Int): jet.Boolean
public final fun jet.CharSequence.subSequence(/*0*/ start: jet.Int, /*1*/ end: jet.Int): jet.CharSequence?
public final fun jet.String.subSequence(/*0*/ beginIndex: jet.Int, /*1*/ endIndex: jet.Int): jet.CharSequence
public final fun jet.String.substring(/*0*/ beginIndex: jet.Int): jet.String
public final fun jet.String.substring(/*0*/ beginIndex: jet.Int, /*1*/ endIndex: jet.Int): jet.String
public final fun </*0*/ T : jet.Any?>java.lang.Iterable<T>.take(/*0*/ n: jet.Int): java.util.List<T>
public final fun </*0*/ T : jet.Any?>java.util.Iterator<T>.take(/*0*/ n: jet.Int): java.util.Iterator<T>
public final fun </*0*/ T : jet.Any?>jet.Array<T>.take(/*0*/ n: jet.Int): java.util.List<T>
public final fun jet.BooleanArray.take(/*0*/ n: jet.Int): java.util.List<jet.Boolean>
public final fun jet.ByteArray.take(/*0*/ n: jet.Int): java.util.List<jet.Byte>
public final fun jet.CharArray.take(/*0*/ n: jet.Int): java.util.List<jet.Char>
public final fun jet.DoubleArray.take(/*0*/ n: jet.Int): java.util.List<jet.Double>
public final fun jet.FloatArray.take(/*0*/ n: jet.Int): java.util.List<jet.Float>
public final fun jet.IntArray.take(/*0*/ n: jet.Int): java.util.List<jet.Int>
public final fun </*0*/ T : jet.Any?>jet.Iterable<T>.take(/*0*/ n: jet.Int): java.util.List<T>
public final fun jet.LongArray.take(/*0*/ n: jet.Int): java.util.List<jet.Long>
public final fun jet.ShortArray.take(/*0*/ n: jet.Int): java.util.List<jet.Short>
public final fun </*0*/ T : jet.Any?>java.lang.Iterable<T>.takeWhile(/*0*/ predicate: jet.Function1<T, jet.Boolean>): java.util.List<T>
public final fun </*0*/ T : jet.Any?>java.util.Iterator<T>.takeWhile(/*0*/ predicate: jet.Function1<T, jet.Boolean>): java.util.Iterator<T>
public final fun </*0*/ T : jet.Any?>jet.Array<T>.takeWhile(/*0*/ predicate: jet.Function1<T, jet.Boolean>): java.util.List<T>
public final fun jet.BooleanArray.takeWhile(/*0*/ predicate: jet.Function1<jet.Boolean, jet.Boolean>): java.util.List<jet.Boolean>
public final fun jet.ByteArray.takeWhile(/*0*/ predicate: jet.Function1<jet.Byte, jet.Boolean>): java.util.List<jet.Byte>
public final fun jet.CharArray.takeWhile(/*0*/ predicate: jet.Function1<jet.Char, jet.Boolean>): java.util.List<jet.Char>
public final fun jet.DoubleArray.takeWhile(/*0*/ predicate: jet.Function1<jet.Double, jet.Boolean>): java.util.List<jet.Double>
public final fun jet.FloatArray.takeWhile(/*0*/ predicate: jet.Function1<jet.Float, jet.Boolean>): java.util.List<jet.Float>
public final fun jet.IntArray.takeWhile(/*0*/ predicate: jet.Function1<jet.Int, jet.Boolean>): java.util.List<jet.Int>
public final fun </*0*/ T : jet.Any?>jet.Iterable<T>.takeWhile(/*0*/ predicate: jet.Function1<T, jet.Boolean>): java.util.List<T>
public final fun jet.LongArray.takeWhile(/*0*/ predicate: jet.Function1<jet.Long, jet.Boolean>): java.util.List<jet.Long>
public final fun jet.ShortArray.takeWhile(/*0*/ predicate: jet.Function1<jet.Short, jet.Boolean>): java.util.List<jet.Short>
public final fun </*0*/ T : jet.Any?, /*1*/ C : java.util.Collection<in T>>java.lang.Iterable<T>.takeWhileTo(/*0*/ result: C, /*1*/ predicate: jet.Function1<T, jet.Boolean>): C
public final fun </*0*/ T : jet.Any?, /*1*/ C : java.util.Collection<in T>>java.util.Iterator<T>.takeWhileTo(/*0*/ result: C, /*1*/ predicate: jet.Function1<T, jet.Boolean>): C
public final fun </*0*/ T : jet.Any?, /*1*/ C : java.util.Collection<in T>>jet.Array<T>.takeWhileTo(/*0*/ result: C, /*1*/ predicate: jet.Function1<T, jet.Boolean>): C
public final fun </*0*/ C : java.util.Collection<jet.Boolean>>jet.BooleanArray.takeWhileTo(/*0*/ result: C, /*1*/ predicate: jet.Function1<jet.Boolean, jet.Boolean>): C
public final fun </*0*/ C : java.util.Collection<jet.Byte>>jet.ByteArray.takeWhileTo(/*0*/ result: C, /*1*/ predicate: jet.Function1<jet.Byte, jet.Boolean>): C
public final fun </*0*/ C : java.util.Collection<jet.Char>>jet.CharArray.takeWhileTo(/*0*/ result: C, /*1*/ predicate: jet.Function1<jet.Char, jet.Boolean>): C
public final fun </*0*/ C : java.util.Collection<jet.Double>>jet.DoubleArray.takeWhileTo(/*0*/ result: C, /*1*/ predicate: jet.Function1<jet.Double, jet.Boolean>): C
public final fun </*0*/ C : java.util.Collection<jet.Float>>jet.FloatArray.takeWhileTo(/*0*/ result: C, /*1*/ predicate: jet.Function1<jet.Float, jet.Boolean>): C
public final fun </*0*/ C : java.util.Collection<jet.Int>>jet.IntArray.takeWhileTo(/*0*/ result: C, /*1*/ predicate: jet.Function1<jet.Int, jet.Boolean>): C
public final fun </*0*/ T : jet.Any?, /*1*/ C : java.util.Collection<in T>>jet.Iterable<T>.takeWhileTo(/*0*/ result: C, /*1*/ predicate: jet.Function1<T, jet.Boolean>): C
public final fun </*0*/ C : java.util.Collection<jet.Long>>jet.LongArray.takeWhileTo(/*0*/ result: C, /*1*/ predicate: jet.Function1<jet.Long, jet.Boolean>): C
public final fun </*0*/ C : java.util.Collection<jet.Short>>jet.ShortArray.takeWhileTo(/*0*/ result: C, /*1*/ predicate: jet.Function1<jet.Short, jet.Boolean>): C
public final fun jet.Int.times(/*0*/ body: jet.Function0<jet.Tuple0>): jet.Tuple0
public final fun </*0*/ A : jet.Any?, /*1*/ B : jet.Any?>A.to(/*0*/ that: B): jet.Tuple2<out A, out B>
public final fun </*0*/ T : jet.Any?>java.util.Collection<T>.toArray(): jet.Array<T>
public final fun </*0*/ T : jet.Any?>jet.Iterator<T>.toArrayList(): java.util.ArrayList<T>
public final fun jet.String.toBoolean(): jet.Boolean
public final fun jet.String.toByteArray(/*0*/ encoding: java.nio.charset.Charset): jet.ByteArray
public final fun jet.String.toByteArray(/*0*/ encoding: jet.String? = ?): jet.ByteArray
public final fun jet.String.toCharArray(): jet.CharArray
public final fun jet.String.toCharList(): java.util.List<jet.Char>
public final fun </*0*/ in T : jet.Any?, /*1*/ C : java.util.Collection<in T>>java.lang.Iterable<T>.toCollection(/*0*/ result: C): C
public final fun </*0*/ in T : jet.Any?, /*1*/ C : java.util.Collection<in T>>java.util.Iterator<T>.toCollection(/*0*/ result: C): C
public final fun </*0*/ in T : jet.Any?, /*1*/ C : java.util.Collection<in T>>jet.Array<T>.toCollection(/*0*/ result: C): C
public final fun </*0*/ C : java.util.Collection<jet.Boolean>>jet.BooleanArray.toCollection(/*0*/ result: C): C
public final fun </*0*/ C : java.util.Collection<jet.Byte>>jet.ByteArray.toCollection(/*0*/ result: C): C
public final fun </*0*/ C : java.util.Collection<jet.Char>>jet.CharArray.toCollection(/*0*/ result: C): C
public final fun </*0*/ C : java.util.Collection<jet.Double>>jet.DoubleArray.toCollection(/*0*/ result: C): C
public final fun </*0*/ C : java.util.Collection<jet.Float>>jet.FloatArray.toCollection(/*0*/ result: C): C
public final fun </*0*/ C : java.util.Collection<jet.Int>>jet.IntArray.toCollection(/*0*/ result: C): C
public final fun </*0*/ in T : jet.Any?, /*1*/ C : java.util.Collection<in T>>jet.Iterable<T>.toCollection(/*0*/ result: C): C
public final fun </*0*/ T : jet.Any?, /*1*/ U : java.util.Collection<in T>>jet.Iterator<T>.toCollection(/*0*/ container: U): U
public final fun </*0*/ C : java.util.Collection<jet.Long>>jet.LongArray.toCollection(/*0*/ result: C): C
public final fun </*0*/ C : java.util.Collection<jet.Short>>jet.ShortArray.toCollection(/*0*/ result: C): C
public final fun </*0*/ in T : jet.Any?>java.lang.Iterable<T>.toCollection(): java.util.Collection<T>
public final fun </*0*/ in T : jet.Any?>java.util.Iterator<T>.toCollection(): java.util.Collection<T>
public final fun </*0*/ in T : jet.Any?>jet.Array<T>.toCollection(): java.util.Collection<T>
public final fun jet.BooleanArray.toCollection(): java.util.Collection<jet.Boolean>
public final fun jet.ByteArray.toCollection(): java.util.Collection<jet.Byte>
public final fun jet.CharArray.toCollection(): java.util.Collection<jet.Char>
public final fun jet.DoubleArray.toCollection(): java.util.Collection<jet.Double>
public final fun jet.FloatArray.toCollection(): java.util.Collection<jet.Float>
public final fun jet.IntArray.toCollection(): java.util.Collection<jet.Int>
public final fun </*0*/ in T : jet.Any?>jet.Iterable<T>.toCollection(): java.util.Collection<T>
public final fun jet.LongArray.toCollection(): java.util.Collection<jet.Long>
public final fun jet.ShortArray.toCollection(): java.util.Collection<jet.Short>
public final fun jet.String.toDouble(): jet.Double
public final fun jet.String.toFloat(): jet.Float
public final fun </*0*/ T : jet.Any?>jet.Iterator<T>.toHashSet(): java.util.HashSet<T>
public final fun jet.String.toInt(): jet.Int
public final fun </*0*/ in T : jet.Any?>java.lang.Iterable<T>.toLinkedList(): java.util.LinkedList<T>
public final fun </*0*/ in T : jet.Any?>java.util.Iterator<T>.toLinkedList(): java.util.LinkedList<T>
public final fun </*0*/ in T : jet.Any?>jet.Array<T>.toLinkedList(): java.util.LinkedList<T>
public final fun jet.BooleanArray.toLinkedList(): java.util.LinkedList<jet.Boolean>
public final fun jet.ByteArray.toLinkedList(): java.util.LinkedList<jet.Byte>
public final fun jet.CharArray.toLinkedList(): java.util.LinkedList<jet.Char>
public final fun jet.DoubleArray.toLinkedList(): java.util.LinkedList<jet.Double>
public final fun jet.FloatArray.toLinkedList(): java.util.LinkedList<jet.Float>
public final fun jet.IntArray.toLinkedList(): java.util.LinkedList<jet.Int>
public final fun </*0*/ in T : jet.Any?>jet.Iterable<T>.toLinkedList(): java.util.LinkedList<T>
public final fun </*0*/ T : jet.Any?>jet.Iterator<T>.toLinkedList(): java.util.LinkedList<T>
public final fun jet.LongArray.toLinkedList(): java.util.LinkedList<jet.Long>
public final fun jet.ShortArray.toLinkedList(): java.util.LinkedList<jet.Short>
public final fun </*0*/ K : jet.Any?, /*1*/ V : jet.Any?>java.util.Map<K, V>.toLinkedMap(): java.util.LinkedHashMap<K, V>
public final fun </*0*/ T : jet.Any?>jet.Iterator<T>.toLinkedSet(): java.util.LinkedHashSet<T>
public final fun </*0*/ in T : jet.Any?>java.lang.Iterable<T>.toList(): java.util.List<T>
public final fun </*0*/ in T : jet.Any?>java.util.Iterator<T>.toList(): java.util.List<T>
public final fun </*0*/ in T : jet.Any?>jet.Array<T>.toList(): java.util.List<T>
public final fun jet.BooleanArray.toList(): java.util.List<jet.Boolean>
public final fun jet.ByteArray.toList(): java.util.List<jet.Byte>
public final fun jet.CharArray.toList(): java.util.List<jet.Char>
public final fun jet.DoubleArray.toList(): java.util.List<jet.Double>
public final fun jet.FloatArray.toList(): java.util.List<jet.Float>
public final fun jet.IntArray.toList(): java.util.List<jet.Int>
public final fun </*0*/ in T : jet.Any?>jet.Iterable<T>.toList(): java.util.List<T>
public final fun jet.LongArray.toList(): java.util.List<jet.Long>
public final fun jet.ShortArray.toList(): java.util.List<jet.Short>
public final fun jet.String.toLong(): jet.Long
public final fun jet.String.toLowerCase(): jet.String
public final fun jet.String.toLowerCase(/*0*/ locale: java.util.Locale): jet.String
public final fun </*0*/ K : jet.Any?, /*1*/ V : jet.Any?>java.util.Map<K, V>.toMap(/*0*/ map: java.util.Map<K, V>): java.util.Map<K, V>
public final fun jet.String.toRegex(/*0*/ flags: jet.Int = ?): java.util.regex.Pattern
public final fun </*0*/ in T : jet.Any?>java.lang.Iterable<T>.toSet(): java.util.Set<T>
public final fun </*0*/ in T : jet.Any?>java.util.Iterator<T>.toSet(): java.util.Set<T>
public final fun </*0*/ in T : jet.Any?>jet.Array<T>.toSet(): java.util.Set<T>
public final fun jet.BooleanArray.toSet(): java.util.Set<jet.Boolean>
public final fun jet.ByteArray.toSet(): java.util.Set<jet.Byte>
public final fun jet.CharArray.toSet(): java.util.Set<jet.Char>
public final fun jet.DoubleArray.toSet(): java.util.Set<jet.Double>
public final fun jet.FloatArray.toSet(): java.util.Set<jet.Float>
public final fun jet.IntArray.toSet(): java.util.Set<jet.Int>
public final fun </*0*/ in T : jet.Any?>jet.Iterable<T>.toSet(): java.util.Set<T>
public final fun jet.LongArray.toSet(): java.util.Set<jet.Long>
public final fun jet.ShortArray.toSet(): java.util.Set<jet.Short>
public final fun jet.String.toShort(): jet.Short
public final fun </*0*/ in T : java.lang.Comparable<T>>java.lang.Iterable<T>.toSortedList(): java.util.List<T>
public final fun </*0*/ in T : java.lang.Comparable<T>>java.lang.Iterable<T>.toSortedList(/*0*/ comparator: java.util.Comparator<T>): java.util.List<T>
public final fun </*0*/ K : jet.Any?, /*1*/ V : jet.Any?>java.util.Map<K, V>.toSortedMap(): java.util.SortedMap<K, V>
public final fun </*0*/ K : jet.Any?, /*1*/ V : jet.Any?>java.util.Map<K, V>.toSortedMap(/*0*/ comparator: java.util.Comparator<K>): java.util.SortedMap<K, V>
public final fun </*0*/ in T : jet.Any?>java.lang.Iterable<T>.toSortedSet(): java.util.SortedSet<T>
public final fun </*0*/ in T : jet.Any?>java.util.Iterator<T>.toSortedSet(): java.util.SortedSet<T>
public final fun </*0*/ in T : jet.Any?>jet.Array<T>.toSortedSet(): java.util.SortedSet<T>
public final fun jet.BooleanArray.toSortedSet(): java.util.SortedSet<jet.Boolean>
public final fun jet.ByteArray.toSortedSet(): java.util.SortedSet<jet.Byte>
public final fun jet.CharArray.toSortedSet(): java.util.SortedSet<jet.Char>
public final fun jet.DoubleArray.toSortedSet(): java.util.SortedSet<jet.Double>
public final fun jet.FloatArray.toSortedSet(): java.util.SortedSet<jet.Float>
public final fun jet.IntArray.toSortedSet(): java.util.SortedSet<jet.Int>
public final fun </*0*/ in T : jet.Any?>jet.Iterable<T>.toSortedSet(): java.util.SortedSet<T>
public final fun </*0*/ T : jet.Any?>jet.Iterator<T>.toSortedSet(): java.util.SortedSet<T>
public final fun </*0*/ T : jet.Any?>jet.Iterator<T>.toSortedSet(/*0*/ comparator: java.util.Comparator<T>): java.util.SortedSet<T>
public final fun jet.LongArray.toSortedSet(): java.util.SortedSet<jet.Long>
public final fun jet.ShortArray.toSortedSet(): java.util.SortedSet<jet.Short>
public final fun jet.ByteArray.toString(/*0*/ encoding: java.nio.charset.Charset): jet.String
public final fun jet.ByteArray.toString(/*0*/ encoding: jet.String?): jet.String
public final fun jet.CharSequence.toString(): jet.String?
public final fun jet.String.toUpperCase(): jet.String
public final fun jet.String.toUpperCase(/*0*/ locale: java.util.Locale): jet.String
public final fun jet.String.trim(): jet.String
public final fun jet.String.trim(/*0*/ prefix: jet.String, /*1*/ postfix: jet.String): jet.String
public final fun jet.String.trim(/*0*/ text: jet.String): jet.String
public final fun jet.String.trimLeading(/*0*/ prefix: jet.String): jet.String
public final fun jet.String.trimTrailing(/*0*/ postfix: jet.String): jet.String
public final fun </*0*/ T : jet.Any?>java.lang.Iterable<T>.withIndices(): java.lang.Iterable<jet.Tuple2<out jet.Int, out T>>
// </namespace name="kotlin">
// <namespace name="js">
namespace js

js.native() internal final annotation class js.library : jet.Any {
    public final /*constructor*/ fun <init>(/*0*/ name: jet.String = ?): js.library
}
js.native() internal final annotation class js.native : jet.Any {
    public final /*constructor*/ fun <init>(/*0*/ name: jet.String = ?): js.native
}
// </namespace name="js">
// <namespace name="org">
namespace org

// <namespace name="jetbrains">
namespace jetbrains

// <namespace name="kotlin">
namespace kotlin

// <namespace name="support">
namespace support

internal final fun loadAsserter(): jet.Tuple0
// </namespace name="support">
// </namespace name="kotlin">
// </namespace name="jetbrains">
// </namespace name="org">