package jet

public fun </*0*/ T> arrayOfNulls(/*0*/ size : jet.Int) : jet.Array<T?>
public fun </*0*/ R> synchronized(/*0*/ lock : jet.Any, /*1*/ block : () -> R) : R
public fun jet.Any?.equals(/*0*/ other : jet.Any?) : jet.Boolean
public fun jet.Any?.identityEquals(/*0*/ other : jet.Any?) : jet.Boolean
public fun jet.BooleanIterator.iterator() : jet.BooleanIterator
public fun jet.ByteIterator.iterator() : jet.ByteIterator
public fun jet.CharIterator.iterator() : jet.CharIterator
public fun jet.DoubleIterator.iterator() : jet.DoubleIterator
public fun jet.FloatIterator.iterator() : jet.FloatIterator
public fun jet.IntIterator.iterator() : jet.IntIterator
public fun </*0*/ T> jet.Iterator<T>.iterator() : jet.Iterator<T>
public fun jet.LongIterator.iterator() : jet.LongIterator
public fun jet.ShortIterator.iterator() : jet.ShortIterator
public fun jet.String?.plus(/*0*/ other : jet.Any?) : jet.String
public fun jet.Any?.toString() : jet.String

public trait Annotation {
}

public open class Any {
    public constructor Any()
}

public final class Array</*0*/ reified T> {
    public constructor Array</*0*/ reified T>(/*0*/ size : jet.Int, /*1*/ init : (jet.Int) -> T)
    public final val indices : jet.IntRange
    public final val size : jet.Int
    public final fun get(/*0*/ index : jet.Int) : T
    public final fun iterator() : jet.Iterator<T>
    public final fun set(/*0*/ index : jet.Int, /*1*/ value : T) : Unit
}

public final class Boolean {
    public constructor Boolean()
    public final fun and(/*0*/ other : jet.Boolean) : jet.Boolean
    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 BooleanArray {
    public constructor BooleanArray(/*0*/ size : jet.Int)
    public final val indices : jet.IntRange
    public final val size : jet.Int
    public final fun get(/*0*/ index : jet.Int) : jet.Boolean
    public final fun iterator() : jet.BooleanIterator
    public final fun set(/*0*/ index : jet.Int, /*1*/ value : jet.Boolean) : Unit
}

public trait BooleanIterable : jet.Iterable<jet.Boolean> {
    public abstract override /*1*/ fun iterator() : jet.BooleanIterator
}

public abstract class BooleanIterator : jet.Iterator<jet.Boolean> {
    public constructor BooleanIterator()
    public abstract override /*1*/ /*fake_override*/ fun hasNext() : jet.Boolean
    public open override /*1*/ fun next() : jet.Boolean
    public abstract fun nextBoolean() : jet.Boolean
}

public final class Byte : jet.Number, jet.Comparable<jet.Byte> {
    public constructor 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 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 class ByteArray {
    public constructor ByteArray(/*0*/ size : jet.Int)
    public final val indices : jet.IntRange
    public final val size : jet.Int
    public final fun get(/*0*/ index : jet.Int) : jet.Byte
    public final fun iterator() : jet.ByteIterator
    public final fun set(/*0*/ index : jet.Int, /*1*/ value : jet.Byte) : Unit
}

public trait ByteIterable : jet.Iterable<jet.Byte> {
    public abstract override /*1*/ fun iterator() : jet.ByteIterator
}

public abstract class ByteIterator : jet.Iterator<jet.Byte> {
    public constructor ByteIterator()
    public abstract override /*1*/ /*fake_override*/ fun hasNext() : jet.Boolean
    public open override /*1*/ fun next() : jet.Byte
    public abstract fun nextByte() : jet.Byte
}

public final class ByteRange : jet.Range<jet.Byte>, jet.ByteIterable {
    public constructor ByteRange(/*0*/ start : jet.Byte, /*1*/ size : jet.Int)
    public final val end : jet.Byte
    public final val size : jet.Int
    public final val start : jet.Byte
    public open override /*1*/ fun contains(/*0*/ elem : jet.Byte) : jet.Boolean
    public open override /*1*/ fun iterator() : jet.ByteIterator
    public final fun step(/*0*/ step : jet.Int) : jet.ByteIterator
    
    public class object <class-object-for-ByteRange> {
        private constructor <class-object-for-ByteRange>()
        public final val EMPTY : jet.ByteRange
    }
}

public final class Char : jet.Number, jet.Comparable<jet.Char> {
    public constructor 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 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.Char) : jet.CharRange
    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 class CharArray {
    public constructor CharArray(/*0*/ size : jet.Int)
    public final val indices : jet.IntRange
    public final val size : jet.Int
    public final fun get(/*0*/ index : jet.Int) : jet.Char
    public final fun iterator() : jet.CharIterator
    public final fun set(/*0*/ index : jet.Int, /*1*/ value : jet.Char) : Unit
}

public trait CharIterable : jet.Iterable<jet.Char> {
    public abstract override /*1*/ fun iterator() : jet.CharIterator
}

public abstract class CharIterator : jet.Iterator<jet.Char> {
    public constructor CharIterator()
    public abstract override /*1*/ /*fake_override*/ fun hasNext() : jet.Boolean
    public open override /*1*/ fun next() : jet.Char
    public abstract fun nextChar() : jet.Char
}

public final class CharRange : jet.Range<jet.Char>, jet.CharIterable {
    public constructor CharRange(/*0*/ start : jet.Char, /*1*/ size : jet.Int)
    public final val end : jet.Char
    public final val size : jet.Int
    public final val start : jet.Char
    public open override /*1*/ fun contains(/*0*/ elem : jet.Char) : jet.Boolean
    public open override /*1*/ fun iterator() : jet.CharIterator
    public final fun step(/*0*/ step : jet.Int) : jet.CharIterator
    
    public class object <class-object-for-CharRange> {
        private constructor <class-object-for-CharRange>()
        public final val EMPTY : jet.CharRange
    }
}

public trait CharSequence {
    public abstract val length : jet.Int
    public abstract fun get(/*0*/ index : jet.Int) : jet.Char
    public abstract fun toString() : jet.String
}

public trait Collection</*0*/ out E> : jet.Iterable<E>, jet.Hashable {
    public abstract fun contains(/*0*/ o : jet.Any?) : jet.Boolean
    public abstract fun containsAll(/*0*/ c : jet.Collection<jet.Any?>) : jet.Boolean
    public abstract override /*1*/ /*fake_override*/ fun equals(/*0*/ other : jet.Any?) : jet.Boolean
    public abstract override /*1*/ /*fake_override*/ fun hashCode() : jet.Int
    public abstract fun isEmpty() : jet.Boolean
    public abstract override /*1*/ fun iterator() : jet.Iterator<E>
    public abstract fun size() : jet.Int
    public abstract fun toArray() : jet.Array<jet.Any?>
    public abstract fun </*0*/ T> toArray(/*0*/ a : jet.Array<out T>) : jet.Array<T>
}

public trait Comparable</*0*/ in T> {
    public abstract fun compareTo(/*0*/ other : T) : jet.Int
}

public final class Double : jet.Number, jet.Comparable<jet.Double> {
    public constructor 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 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 class DoubleArray {
    public constructor DoubleArray(/*0*/ size : jet.Int)
    public final val indices : jet.IntRange
    public final val size : jet.Int
    public final fun get(/*0*/ index : jet.Int) : jet.Double
    public final fun iterator() : jet.DoubleIterator
    public final fun set(/*0*/ index : jet.Int, /*1*/ value : jet.Double) : Unit
}

public trait DoubleIterable : jet.Iterable<jet.Double> {
    public abstract override /*1*/ fun iterator() : jet.DoubleIterator
}

public abstract class DoubleIterator : jet.Iterator<jet.Double> {
    public constructor DoubleIterator()
    public abstract override /*1*/ /*fake_override*/ fun hasNext() : jet.Boolean
    public open override /*1*/ fun next() : jet.Double
    public abstract fun nextDouble() : jet.Double
}

public final class DoubleRange : jet.Range<jet.Double> {
    public constructor DoubleRange(/*0*/ start : jet.Double, /*1*/ size : jet.Double)
    public final val end : jet.Double
    public final val size : jet.Double
    public final val start : jet.Double
    public open override /*1*/ fun contains(/*0*/ elem : jet.Double) : jet.Boolean
    public final fun step(/*0*/ step : jet.Double) : jet.DoubleIterator
    
    public class object <class-object-for-DoubleRange> {
        private constructor <class-object-for-DoubleRange>()
        public final val EMPTY : jet.DoubleRange
    }
}

public abstract class Enum</*0*/ E : jet.Enum<E>> {
    public constructor Enum</*0*/ E : jet.Enum<E>>(/*0*/ name : jet.String, /*1*/ ordinal : jet.Int)
    public final fun name() : jet.String
    public final fun ordinal() : jet.Int
}

public abstract class ExtensionFunction0</*0*/ in T, /*1*/ out R> {
    public constructor ExtensionFunction0</*0*/ in T, /*1*/ out R>()
    public abstract fun T.invoke() : R
}

public abstract class ExtensionFunction1</*0*/ in T, /*1*/ in P1, /*2*/ out R> {
    public constructor ExtensionFunction1</*0*/ in T, /*1*/ in P1, /*2*/ out R>()
    public abstract fun T.invoke(/*0*/ p1 : P1) : R
}

public abstract class ExtensionFunction10</*0*/ in T, /*1*/ in P1, /*2*/ in P2, /*3*/ in P3, /*4*/ in P4, /*5*/ in P5, /*6*/ in P6, /*7*/ in P7, /*8*/ in P8, /*9*/ in P9, /*10*/ in P10, /*11*/ out R> {
    public constructor ExtensionFunction10</*0*/ in T, /*1*/ in P1, /*2*/ in P2, /*3*/ in P3, /*4*/ in P4, /*5*/ in P5, /*6*/ in P6, /*7*/ in P7, /*8*/ in P8, /*9*/ in P9, /*10*/ in P10, /*11*/ out 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 ExtensionFunction11</*0*/ in T, /*1*/ in P1, /*2*/ in P2, /*3*/ in P3, /*4*/ in P4, /*5*/ in P5, /*6*/ in P6, /*7*/ in P7, /*8*/ in P8, /*9*/ in P9, /*10*/ in P10, /*11*/ in P11, /*12*/ out R> {
    public constructor ExtensionFunction11</*0*/ in T, /*1*/ in P1, /*2*/ in P2, /*3*/ in P3, /*4*/ in P4, /*5*/ in P5, /*6*/ in P6, /*7*/ in P7, /*8*/ in P8, /*9*/ in P9, /*10*/ in P10, /*11*/ in P11, /*12*/ out 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 ExtensionFunction12</*0*/ in T, /*1*/ in P1, /*2*/ in P2, /*3*/ in P3, /*4*/ in P4, /*5*/ in P5, /*6*/ in P6, /*7*/ in P7, /*8*/ in P8, /*9*/ in P9, /*10*/ in P10, /*11*/ in P11, /*12*/ in P12, /*13*/ out R> {
    public constructor ExtensionFunction12</*0*/ in T, /*1*/ in P1, /*2*/ in P2, /*3*/ in P3, /*4*/ in P4, /*5*/ in P5, /*6*/ in P6, /*7*/ in P7, /*8*/ in P8, /*9*/ in P9, /*10*/ in P10, /*11*/ in P11, /*12*/ in P12, /*13*/ out 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 ExtensionFunction13</*0*/ in T, /*1*/ in P1, /*2*/ in P2, /*3*/ in P3, /*4*/ in P4, /*5*/ in P5, /*6*/ in P6, /*7*/ in P7, /*8*/ in P8, /*9*/ in P9, /*10*/ in P10, /*11*/ in P11, /*12*/ in P12, /*13*/ in P13, /*14*/ out R> {
    public constructor ExtensionFunction13</*0*/ in T, /*1*/ in P1, /*2*/ in P2, /*3*/ in P3, /*4*/ in P4, /*5*/ in P5, /*6*/ in P6, /*7*/ in P7, /*8*/ in P8, /*9*/ in P9, /*10*/ in P10, /*11*/ in P11, /*12*/ in P12, /*13*/ in P13, /*14*/ out 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 ExtensionFunction14</*0*/ in T, /*1*/ in P1, /*2*/ in P2, /*3*/ in P3, /*4*/ in P4, /*5*/ in P5, /*6*/ in P6, /*7*/ in P7, /*8*/ in P8, /*9*/ in P9, /*10*/ in P10, /*11*/ in P11, /*12*/ in P12, /*13*/ in P13, /*14*/ in P14, /*15*/ out R> {
    public constructor ExtensionFunction14</*0*/ in T, /*1*/ in P1, /*2*/ in P2, /*3*/ in P3, /*4*/ in P4, /*5*/ in P5, /*6*/ in P6, /*7*/ in P7, /*8*/ in P8, /*9*/ in P9, /*10*/ in P10, /*11*/ in P11, /*12*/ in P12, /*13*/ in P13, /*14*/ in P14, /*15*/ out 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 ExtensionFunction15</*0*/ in T, /*1*/ in P1, /*2*/ in P2, /*3*/ in P3, /*4*/ in P4, /*5*/ in P5, /*6*/ in P6, /*7*/ in P7, /*8*/ in P8, /*9*/ in P9, /*10*/ in P10, /*11*/ in P11, /*12*/ in P12, /*13*/ in P13, /*14*/ in P14, /*15*/ in P15, /*16*/ out R> {
    public constructor ExtensionFunction15</*0*/ in T, /*1*/ in P1, /*2*/ in P2, /*3*/ in P3, /*4*/ in P4, /*5*/ in P5, /*6*/ in P6, /*7*/ in P7, /*8*/ in P8, /*9*/ in P9, /*10*/ in P10, /*11*/ in P11, /*12*/ in P12, /*13*/ in P13, /*14*/ in P14, /*15*/ in P15, /*16*/ out 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 ExtensionFunction16</*0*/ in T, /*1*/ in P1, /*2*/ in P2, /*3*/ in P3, /*4*/ in P4, /*5*/ in P5, /*6*/ in P6, /*7*/ in P7, /*8*/ in P8, /*9*/ in P9, /*10*/ in P10, /*11*/ in P11, /*12*/ in P12, /*13*/ in P13, /*14*/ in P14, /*15*/ in P15, /*16*/ in P16, /*17*/ out R> {
    public constructor ExtensionFunction16</*0*/ in T, /*1*/ in P1, /*2*/ in P2, /*3*/ in P3, /*4*/ in P4, /*5*/ in P5, /*6*/ in P6, /*7*/ in P7, /*8*/ in P8, /*9*/ in P9, /*10*/ in P10, /*11*/ in P11, /*12*/ in P12, /*13*/ in P13, /*14*/ in P14, /*15*/ in P15, /*16*/ in P16, /*17*/ out 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 ExtensionFunction17</*0*/ in T, /*1*/ in P1, /*2*/ in P2, /*3*/ in P3, /*4*/ in P4, /*5*/ in P5, /*6*/ in P6, /*7*/ in P7, /*8*/ in P8, /*9*/ in P9, /*10*/ in P10, /*11*/ in P11, /*12*/ in P12, /*13*/ in P13, /*14*/ in P14, /*15*/ in P15, /*16*/ in P16, /*17*/ in P17, /*18*/ out R> {
    public constructor ExtensionFunction17</*0*/ in T, /*1*/ in P1, /*2*/ in P2, /*3*/ in P3, /*4*/ in P4, /*5*/ in P5, /*6*/ in P6, /*7*/ in P7, /*8*/ in P8, /*9*/ in P9, /*10*/ in P10, /*11*/ in P11, /*12*/ in P12, /*13*/ in P13, /*14*/ in P14, /*15*/ in P15, /*16*/ in P16, /*17*/ in P17, /*18*/ out 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 ExtensionFunction18</*0*/ in T, /*1*/ in P1, /*2*/ in P2, /*3*/ in P3, /*4*/ in P4, /*5*/ in P5, /*6*/ in P6, /*7*/ in P7, /*8*/ in P8, /*9*/ in P9, /*10*/ in P10, /*11*/ in P11, /*12*/ in P12, /*13*/ in P13, /*14*/ in P14, /*15*/ in P15, /*16*/ in P16, /*17*/ in P17, /*18*/ in P18, /*19*/ out R> {
    public constructor ExtensionFunction18</*0*/ in T, /*1*/ in P1, /*2*/ in P2, /*3*/ in P3, /*4*/ in P4, /*5*/ in P5, /*6*/ in P6, /*7*/ in P7, /*8*/ in P8, /*9*/ in P9, /*10*/ in P10, /*11*/ in P11, /*12*/ in P12, /*13*/ in P13, /*14*/ in P14, /*15*/ in P15, /*16*/ in P16, /*17*/ in P17, /*18*/ in P18, /*19*/ out 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 ExtensionFunction19</*0*/ in T, /*1*/ in P1, /*2*/ in P2, /*3*/ in P3, /*4*/ in P4, /*5*/ in P5, /*6*/ in P6, /*7*/ in P7, /*8*/ in P8, /*9*/ in P9, /*10*/ in P10, /*11*/ in P11, /*12*/ in P12, /*13*/ in P13, /*14*/ in P14, /*15*/ in P15, /*16*/ in P16, /*17*/ in P17, /*18*/ in P18, /*19*/ in P19, /*20*/ out R> {
    public constructor ExtensionFunction19</*0*/ in T, /*1*/ in P1, /*2*/ in P2, /*3*/ in P3, /*4*/ in P4, /*5*/ in P5, /*6*/ in P6, /*7*/ in P7, /*8*/ in P8, /*9*/ in P9, /*10*/ in P10, /*11*/ in P11, /*12*/ in P12, /*13*/ in P13, /*14*/ in P14, /*15*/ in P15, /*16*/ in P16, /*17*/ in P17, /*18*/ in P18, /*19*/ in P19, /*20*/ out 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 ExtensionFunction2</*0*/ in T, /*1*/ in P1, /*2*/ in P2, /*3*/ out R> {
    public constructor ExtensionFunction2</*0*/ in T, /*1*/ in P1, /*2*/ in P2, /*3*/ out R>()
    public abstract fun T.invoke(/*0*/ p1 : P1, /*1*/ p2 : P2) : R
}

public abstract class ExtensionFunction20</*0*/ in T, /*1*/ in P1, /*2*/ in P2, /*3*/ in P3, /*4*/ in P4, /*5*/ in P5, /*6*/ in P6, /*7*/ in P7, /*8*/ in P8, /*9*/ in P9, /*10*/ in P10, /*11*/ in P11, /*12*/ in P12, /*13*/ in P13, /*14*/ in P14, /*15*/ in P15, /*16*/ in P16, /*17*/ in P17, /*18*/ in P18, /*19*/ in P19, /*20*/ in P20, /*21*/ out R> {
    public constructor ExtensionFunction20</*0*/ in T, /*1*/ in P1, /*2*/ in P2, /*3*/ in P3, /*4*/ in P4, /*5*/ in P5, /*6*/ in P6, /*7*/ in P7, /*8*/ in P8, /*9*/ in P9, /*10*/ in P10, /*11*/ in P11, /*12*/ in P12, /*13*/ in P13, /*14*/ in P14, /*15*/ in P15, /*16*/ in P16, /*17*/ in P17, /*18*/ in P18, /*19*/ in P19, /*20*/ in P20, /*21*/ out 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 ExtensionFunction21</*0*/ in T, /*1*/ in P1, /*2*/ in P2, /*3*/ in P3, /*4*/ in P4, /*5*/ in P5, /*6*/ in P6, /*7*/ in P7, /*8*/ in P8, /*9*/ in P9, /*10*/ in P10, /*11*/ in P11, /*12*/ in P12, /*13*/ in P13, /*14*/ in P14, /*15*/ in P15, /*16*/ in P16, /*17*/ in P17, /*18*/ in P18, /*19*/ in P19, /*20*/ in P20, /*21*/ in P21, /*22*/ out R> {
    public constructor ExtensionFunction21</*0*/ in T, /*1*/ in P1, /*2*/ in P2, /*3*/ in P3, /*4*/ in P4, /*5*/ in P5, /*6*/ in P6, /*7*/ in P7, /*8*/ in P8, /*9*/ in P9, /*10*/ in P10, /*11*/ in P11, /*12*/ in P12, /*13*/ in P13, /*14*/ in P14, /*15*/ in P15, /*16*/ in P16, /*17*/ in P17, /*18*/ in P18, /*19*/ in P19, /*20*/ in P20, /*21*/ in P21, /*22*/ out 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 ExtensionFunction22</*0*/ in T, /*1*/ in P1, /*2*/ in P2, /*3*/ in P3, /*4*/ in P4, /*5*/ in P5, /*6*/ in P6, /*7*/ in P7, /*8*/ in P8, /*9*/ in P9, /*10*/ in P10, /*11*/ in P11, /*12*/ in P12, /*13*/ in P13, /*14*/ in P14, /*15*/ in P15, /*16*/ in P16, /*17*/ in P17, /*18*/ in P18, /*19*/ in P19, /*20*/ in P20, /*21*/ in P21, /*22*/ in P22, /*23*/ out R> {
    public constructor ExtensionFunction22</*0*/ in T, /*1*/ in P1, /*2*/ in P2, /*3*/ in P3, /*4*/ in P4, /*5*/ in P5, /*6*/ in P6, /*7*/ in P7, /*8*/ in P8, /*9*/ in P9, /*10*/ in P10, /*11*/ in P11, /*12*/ in P12, /*13*/ in P13, /*14*/ in P14, /*15*/ in P15, /*16*/ in P16, /*17*/ in P17, /*18*/ in P18, /*19*/ in P19, /*20*/ in P20, /*21*/ in P21, /*22*/ in P22, /*23*/ out 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 ExtensionFunction3</*0*/ in T, /*1*/ in P1, /*2*/ in P2, /*3*/ in P3, /*4*/ out R> {
    public constructor ExtensionFunction3</*0*/ in T, /*1*/ in P1, /*2*/ in P2, /*3*/ in P3, /*4*/ out R>()
    public abstract fun T.invoke(/*0*/ p1 : P1, /*1*/ p2 : P2, /*2*/ p3 : P3) : R
}

public abstract class ExtensionFunction4</*0*/ in T, /*1*/ in P1, /*2*/ in P2, /*3*/ in P3, /*4*/ in P4, /*5*/ out R> {
    public constructor ExtensionFunction4</*0*/ in T, /*1*/ in P1, /*2*/ in P2, /*3*/ in P3, /*4*/ in P4, /*5*/ out R>()
    public abstract fun T.invoke(/*0*/ p1 : P1, /*1*/ p2 : P2, /*2*/ p3 : P3, /*3*/ p4 : P4) : R
}

public abstract class ExtensionFunction5</*0*/ in T, /*1*/ in P1, /*2*/ in P2, /*3*/ in P3, /*4*/ in P4, /*5*/ in P5, /*6*/ out R> {
    public constructor ExtensionFunction5</*0*/ in T, /*1*/ in P1, /*2*/ in P2, /*3*/ in P3, /*4*/ in P4, /*5*/ in P5, /*6*/ out 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 ExtensionFunction6</*0*/ in T, /*1*/ in P1, /*2*/ in P2, /*3*/ in P3, /*4*/ in P4, /*5*/ in P5, /*6*/ in P6, /*7*/ out R> {
    public constructor ExtensionFunction6</*0*/ in T, /*1*/ in P1, /*2*/ in P2, /*3*/ in P3, /*4*/ in P4, /*5*/ in P5, /*6*/ in P6, /*7*/ out 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 ExtensionFunction7</*0*/ in T, /*1*/ in P1, /*2*/ in P2, /*3*/ in P3, /*4*/ in P4, /*5*/ in P5, /*6*/ in P6, /*7*/ in P7, /*8*/ out R> {
    public constructor ExtensionFunction7</*0*/ in T, /*1*/ in P1, /*2*/ in P2, /*3*/ in P3, /*4*/ in P4, /*5*/ in P5, /*6*/ in P6, /*7*/ in P7, /*8*/ out 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 ExtensionFunction8</*0*/ in T, /*1*/ in P1, /*2*/ in P2, /*3*/ in P3, /*4*/ in P4, /*5*/ in P5, /*6*/ in P6, /*7*/ in P7, /*8*/ in P8, /*9*/ out R> {
    public constructor ExtensionFunction8</*0*/ in T, /*1*/ in P1, /*2*/ in P2, /*3*/ in P3, /*4*/ in P4, /*5*/ in P5, /*6*/ in P6, /*7*/ in P7, /*8*/ in P8, /*9*/ out 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 ExtensionFunction9</*0*/ in T, /*1*/ in P1, /*2*/ in P2, /*3*/ in P3, /*4*/ in P4, /*5*/ in P5, /*6*/ in P6, /*7*/ in P7, /*8*/ in P8, /*9*/ in P9, /*10*/ out R> {
    public constructor ExtensionFunction9</*0*/ in T, /*1*/ in P1, /*2*/ in P2, /*3*/ in P3, /*4*/ in P4, /*5*/ in P5, /*6*/ in P6, /*7*/ in P7, /*8*/ in P8, /*9*/ in P9, /*10*/ out 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 Float : jet.Number, jet.Comparable<jet.Float> {
    public constructor 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 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 class FloatArray {
    public constructor FloatArray(/*0*/ size : jet.Int)
    public final val indices : jet.IntRange
    public final val size : jet.Int
    public final fun get(/*0*/ index : jet.Int) : jet.Float
    public final fun iterator() : jet.FloatIterator
    public final fun set(/*0*/ index : jet.Int, /*1*/ value : jet.Float) : Unit
}

public trait FloatIterable : jet.Iterable<jet.Float> {
    public abstract override /*1*/ fun iterator() : jet.FloatIterator
}

public abstract class FloatIterator : jet.Iterator<jet.Float> {
    public constructor FloatIterator()
    public abstract override /*1*/ /*fake_override*/ fun hasNext() : jet.Boolean
    public open override /*1*/ fun next() : jet.Float
    public abstract fun nextFloat() : jet.Float
}

public final class FloatRange : jet.Range<jet.Float> {
    public constructor FloatRange(/*0*/ start : jet.Float, /*1*/ size : jet.Float)
    public final val end : jet.Float
    public final val size : jet.Float
    public final val start : jet.Float
    public open override /*1*/ fun contains(/*0*/ elem : jet.Float) : jet.Boolean
    public final fun step(/*0*/ step : jet.Float) : jet.FloatIterator
    
    public class object <class-object-for-FloatRange> {
        private constructor <class-object-for-FloatRange>()
        public final val EMPTY : jet.FloatRange
    }
}

public abstract class Function0</*0*/ out R> {
    public constructor Function0</*0*/ out R>()
    public abstract fun invoke() : R
}

public abstract class Function1</*0*/ in P1, /*1*/ out R> {
    public constructor Function1</*0*/ in P1, /*1*/ out R>()
    public abstract fun invoke(/*0*/ p1 : P1) : R
}

public abstract class Function10</*0*/ in P1, /*1*/ in P2, /*2*/ in P3, /*3*/ in P4, /*4*/ in P5, /*5*/ in P6, /*6*/ in P7, /*7*/ in P8, /*8*/ in P9, /*9*/ in P10, /*10*/ out R> {
    public constructor Function10</*0*/ in P1, /*1*/ in P2, /*2*/ in P3, /*3*/ in P4, /*4*/ in P5, /*5*/ in P6, /*6*/ in P7, /*7*/ in P8, /*8*/ in P9, /*9*/ in P10, /*10*/ out 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 Function11</*0*/ in P1, /*1*/ in P2, /*2*/ in P3, /*3*/ in P4, /*4*/ in P5, /*5*/ in P6, /*6*/ in P7, /*7*/ in P8, /*8*/ in P9, /*9*/ in P10, /*10*/ in P11, /*11*/ out R> {
    public constructor Function11</*0*/ in P1, /*1*/ in P2, /*2*/ in P3, /*3*/ in P4, /*4*/ in P5, /*5*/ in P6, /*6*/ in P7, /*7*/ in P8, /*8*/ in P9, /*9*/ in P10, /*10*/ in P11, /*11*/ out 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 Function12</*0*/ in P1, /*1*/ in P2, /*2*/ in P3, /*3*/ in P4, /*4*/ in P5, /*5*/ in P6, /*6*/ in P7, /*7*/ in P8, /*8*/ in P9, /*9*/ in P10, /*10*/ in P11, /*11*/ in P12, /*12*/ out R> {
    public constructor Function12</*0*/ in P1, /*1*/ in P2, /*2*/ in P3, /*3*/ in P4, /*4*/ in P5, /*5*/ in P6, /*6*/ in P7, /*7*/ in P8, /*8*/ in P9, /*9*/ in P10, /*10*/ in P11, /*11*/ in P12, /*12*/ out 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 Function13</*0*/ in P1, /*1*/ in P2, /*2*/ in P3, /*3*/ in P4, /*4*/ in P5, /*5*/ in P6, /*6*/ in P7, /*7*/ in P8, /*8*/ in P9, /*9*/ in P10, /*10*/ in P11, /*11*/ in P12, /*12*/ in P13, /*13*/ out R> {
    public constructor Function13</*0*/ in P1, /*1*/ in P2, /*2*/ in P3, /*3*/ in P4, /*4*/ in P5, /*5*/ in P6, /*6*/ in P7, /*7*/ in P8, /*8*/ in P9, /*9*/ in P10, /*10*/ in P11, /*11*/ in P12, /*12*/ in P13, /*13*/ out 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 Function14</*0*/ in P1, /*1*/ in P2, /*2*/ in P3, /*3*/ in P4, /*4*/ in P5, /*5*/ in P6, /*6*/ in P7, /*7*/ in P8, /*8*/ in P9, /*9*/ in P10, /*10*/ in P11, /*11*/ in P12, /*12*/ in P13, /*13*/ in P14, /*14*/ out R> {
    public constructor Function14</*0*/ in P1, /*1*/ in P2, /*2*/ in P3, /*3*/ in P4, /*4*/ in P5, /*5*/ in P6, /*6*/ in P7, /*7*/ in P8, /*8*/ in P9, /*9*/ in P10, /*10*/ in P11, /*11*/ in P12, /*12*/ in P13, /*13*/ in P14, /*14*/ out 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 Function15</*0*/ in P1, /*1*/ in P2, /*2*/ in P3, /*3*/ in P4, /*4*/ in P5, /*5*/ in P6, /*6*/ in P7, /*7*/ in P8, /*8*/ in P9, /*9*/ in P10, /*10*/ in P11, /*11*/ in P12, /*12*/ in P13, /*13*/ in P14, /*14*/ in P15, /*15*/ out R> {
    public constructor Function15</*0*/ in P1, /*1*/ in P2, /*2*/ in P3, /*3*/ in P4, /*4*/ in P5, /*5*/ in P6, /*6*/ in P7, /*7*/ in P8, /*8*/ in P9, /*9*/ in P10, /*10*/ in P11, /*11*/ in P12, /*12*/ in P13, /*13*/ in P14, /*14*/ in P15, /*15*/ out 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 Function16</*0*/ in P1, /*1*/ in P2, /*2*/ in P3, /*3*/ in P4, /*4*/ in P5, /*5*/ in P6, /*6*/ in P7, /*7*/ in P8, /*8*/ in P9, /*9*/ in P10, /*10*/ in P11, /*11*/ in P12, /*12*/ in P13, /*13*/ in P14, /*14*/ in P15, /*15*/ in P16, /*16*/ out R> {
    public constructor Function16</*0*/ in P1, /*1*/ in P2, /*2*/ in P3, /*3*/ in P4, /*4*/ in P5, /*5*/ in P6, /*6*/ in P7, /*7*/ in P8, /*8*/ in P9, /*9*/ in P10, /*10*/ in P11, /*11*/ in P12, /*12*/ in P13, /*13*/ in P14, /*14*/ in P15, /*15*/ in P16, /*16*/ out 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 Function17</*0*/ in P1, /*1*/ in P2, /*2*/ in P3, /*3*/ in P4, /*4*/ in P5, /*5*/ in P6, /*6*/ in P7, /*7*/ in P8, /*8*/ in P9, /*9*/ in P10, /*10*/ in P11, /*11*/ in P12, /*12*/ in P13, /*13*/ in P14, /*14*/ in P15, /*15*/ in P16, /*16*/ in P17, /*17*/ out R> {
    public constructor Function17</*0*/ in P1, /*1*/ in P2, /*2*/ in P3, /*3*/ in P4, /*4*/ in P5, /*5*/ in P6, /*6*/ in P7, /*7*/ in P8, /*8*/ in P9, /*9*/ in P10, /*10*/ in P11, /*11*/ in P12, /*12*/ in P13, /*13*/ in P14, /*14*/ in P15, /*15*/ in P16, /*16*/ in P17, /*17*/ out 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 Function18</*0*/ in P1, /*1*/ in P2, /*2*/ in P3, /*3*/ in P4, /*4*/ in P5, /*5*/ in P6, /*6*/ in P7, /*7*/ in P8, /*8*/ in P9, /*9*/ in P10, /*10*/ in P11, /*11*/ in P12, /*12*/ in P13, /*13*/ in P14, /*14*/ in P15, /*15*/ in P16, /*16*/ in P17, /*17*/ in P18, /*18*/ out R> {
    public constructor Function18</*0*/ in P1, /*1*/ in P2, /*2*/ in P3, /*3*/ in P4, /*4*/ in P5, /*5*/ in P6, /*6*/ in P7, /*7*/ in P8, /*8*/ in P9, /*9*/ in P10, /*10*/ in P11, /*11*/ in P12, /*12*/ in P13, /*13*/ in P14, /*14*/ in P15, /*15*/ in P16, /*16*/ in P17, /*17*/ in P18, /*18*/ out 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 Function19</*0*/ in P1, /*1*/ in P2, /*2*/ in P3, /*3*/ in P4, /*4*/ in P5, /*5*/ in P6, /*6*/ in P7, /*7*/ in P8, /*8*/ in P9, /*9*/ in P10, /*10*/ in P11, /*11*/ in P12, /*12*/ in P13, /*13*/ in P14, /*14*/ in P15, /*15*/ in P16, /*16*/ in P17, /*17*/ in P18, /*18*/ in P19, /*19*/ out R> {
    public constructor Function19</*0*/ in P1, /*1*/ in P2, /*2*/ in P3, /*3*/ in P4, /*4*/ in P5, /*5*/ in P6, /*6*/ in P7, /*7*/ in P8, /*8*/ in P9, /*9*/ in P10, /*10*/ in P11, /*11*/ in P12, /*12*/ in P13, /*13*/ in P14, /*14*/ in P15, /*15*/ in P16, /*16*/ in P17, /*17*/ in P18, /*18*/ in P19, /*19*/ out 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 Function2</*0*/ in P1, /*1*/ in P2, /*2*/ out R> {
    public constructor Function2</*0*/ in P1, /*1*/ in P2, /*2*/ out R>()
    public abstract fun invoke(/*0*/ p1 : P1, /*1*/ p2 : P2) : R
}

public abstract class Function20</*0*/ in P1, /*1*/ in P2, /*2*/ in P3, /*3*/ in P4, /*4*/ in P5, /*5*/ in P6, /*6*/ in P7, /*7*/ in P8, /*8*/ in P9, /*9*/ in P10, /*10*/ in P11, /*11*/ in P12, /*12*/ in P13, /*13*/ in P14, /*14*/ in P15, /*15*/ in P16, /*16*/ in P17, /*17*/ in P18, /*18*/ in P19, /*19*/ in P20, /*20*/ out R> {
    public constructor Function20</*0*/ in P1, /*1*/ in P2, /*2*/ in P3, /*3*/ in P4, /*4*/ in P5, /*5*/ in P6, /*6*/ in P7, /*7*/ in P8, /*8*/ in P9, /*9*/ in P10, /*10*/ in P11, /*11*/ in P12, /*12*/ in P13, /*13*/ in P14, /*14*/ in P15, /*15*/ in P16, /*16*/ in P17, /*17*/ in P18, /*18*/ in P19, /*19*/ in P20, /*20*/ out 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 Function21</*0*/ in P1, /*1*/ in P2, /*2*/ in P3, /*3*/ in P4, /*4*/ in P5, /*5*/ in P6, /*6*/ in P7, /*7*/ in P8, /*8*/ in P9, /*9*/ in P10, /*10*/ in P11, /*11*/ in P12, /*12*/ in P13, /*13*/ in P14, /*14*/ in P15, /*15*/ in P16, /*16*/ in P17, /*17*/ in P18, /*18*/ in P19, /*19*/ in P20, /*20*/ in P21, /*21*/ out R> {
    public constructor Function21</*0*/ in P1, /*1*/ in P2, /*2*/ in P3, /*3*/ in P4, /*4*/ in P5, /*5*/ in P6, /*6*/ in P7, /*7*/ in P8, /*8*/ in P9, /*9*/ in P10, /*10*/ in P11, /*11*/ in P12, /*12*/ in P13, /*13*/ in P14, /*14*/ in P15, /*15*/ in P16, /*16*/ in P17, /*17*/ in P18, /*18*/ in P19, /*19*/ in P20, /*20*/ in P21, /*21*/ out 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 Function22</*0*/ in P1, /*1*/ in P2, /*2*/ in P3, /*3*/ in P4, /*4*/ in P5, /*5*/ in P6, /*6*/ in P7, /*7*/ in P8, /*8*/ in P9, /*9*/ in P10, /*10*/ in P11, /*11*/ in P12, /*12*/ in P13, /*13*/ in P14, /*14*/ in P15, /*15*/ in P16, /*16*/ in P17, /*17*/ in P18, /*18*/ in P19, /*19*/ in P20, /*20*/ in P21, /*21*/ in P22, /*22*/ out R> {
    public constructor Function22</*0*/ in P1, /*1*/ in P2, /*2*/ in P3, /*3*/ in P4, /*4*/ in P5, /*5*/ in P6, /*6*/ in P7, /*7*/ in P8, /*8*/ in P9, /*9*/ in P10, /*10*/ in P11, /*11*/ in P12, /*12*/ in P13, /*13*/ in P14, /*14*/ in P15, /*15*/ in P16, /*16*/ in P17, /*17*/ in P18, /*18*/ in P19, /*19*/ in P20, /*20*/ in P21, /*21*/ in P22, /*22*/ out 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 Function3</*0*/ in P1, /*1*/ in P2, /*2*/ in P3, /*3*/ out R> {
    public constructor Function3</*0*/ in P1, /*1*/ in P2, /*2*/ in P3, /*3*/ out R>()
    public abstract fun invoke(/*0*/ p1 : P1, /*1*/ p2 : P2, /*2*/ p3 : P3) : R
}

public abstract class Function4</*0*/ in P1, /*1*/ in P2, /*2*/ in P3, /*3*/ in P4, /*4*/ out R> {
    public constructor Function4</*0*/ in P1, /*1*/ in P2, /*2*/ in P3, /*3*/ in P4, /*4*/ out R>()
    public abstract fun invoke(/*0*/ p1 : P1, /*1*/ p2 : P2, /*2*/ p3 : P3, /*3*/ p4 : P4) : R
}

public abstract class Function5</*0*/ in P1, /*1*/ in P2, /*2*/ in P3, /*3*/ in P4, /*4*/ in P5, /*5*/ out R> {
    public constructor Function5</*0*/ in P1, /*1*/ in P2, /*2*/ in P3, /*3*/ in P4, /*4*/ in P5, /*5*/ out R>()
    public abstract fun invoke(/*0*/ p1 : P1, /*1*/ p2 : P2, /*2*/ p3 : P3, /*3*/ p4 : P4, /*4*/ p5 : P5) : R
}

public abstract class Function6</*0*/ in P1, /*1*/ in P2, /*2*/ in P3, /*3*/ in P4, /*4*/ in P5, /*5*/ in P6, /*6*/ out R> {
    public constructor Function6</*0*/ in P1, /*1*/ in P2, /*2*/ in P3, /*3*/ in P4, /*4*/ in P5, /*5*/ in P6, /*6*/ out 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 Function7</*0*/ in P1, /*1*/ in P2, /*2*/ in P3, /*3*/ in P4, /*4*/ in P5, /*5*/ in P6, /*6*/ in P7, /*7*/ out R> {
    public constructor Function7</*0*/ in P1, /*1*/ in P2, /*2*/ in P3, /*3*/ in P4, /*4*/ in P5, /*5*/ in P6, /*6*/ in P7, /*7*/ out 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 Function8</*0*/ in P1, /*1*/ in P2, /*2*/ in P3, /*3*/ in P4, /*4*/ in P5, /*5*/ in P6, /*6*/ in P7, /*7*/ in P8, /*8*/ out R> {
    public constructor Function8</*0*/ in P1, /*1*/ in P2, /*2*/ in P3, /*3*/ in P4, /*4*/ in P5, /*5*/ in P6, /*6*/ in P7, /*7*/ in P8, /*8*/ out 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 Function9</*0*/ in P1, /*1*/ in P2, /*2*/ in P3, /*3*/ in P4, /*4*/ in P5, /*5*/ in P6, /*6*/ in P7, /*7*/ in P8, /*8*/ in P9, /*9*/ out R> {
    public constructor Function9</*0*/ in P1, /*1*/ in P2, /*2*/ in P3, /*3*/ in P4, /*4*/ in P5, /*5*/ in P6, /*6*/ in P7, /*7*/ in P8, /*8*/ in P9, /*9*/ out 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 trait Hashable {
    public abstract fun equals(/*0*/ other : jet.Any?) : jet.Boolean
    public abstract fun hashCode() : jet.Int
}

public final class Int : jet.Number, jet.Comparable<jet.Int> {
    public constructor 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 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 ushr(/*0*/ bits : jet.Int) : jet.Int
    public final fun xor(/*0*/ other : jet.Int) : jet.Int
}

public final class IntArray {
    public constructor IntArray(/*0*/ size : jet.Int)
    public final val indices : jet.IntRange
    public final val size : jet.Int
    public final fun get(/*0*/ index : jet.Int) : jet.Int
    public final fun iterator() : jet.IntIterator
    public final fun set(/*0*/ index : jet.Int, /*1*/ value : jet.Int) : Unit
}

public trait IntIterable : jet.Iterable<jet.Int> {
    public abstract override /*1*/ fun iterator() : jet.IntIterator
}

public abstract class IntIterator : jet.Iterator<jet.Int> {
    public constructor IntIterator()
    public abstract override /*1*/ /*fake_override*/ fun hasNext() : jet.Boolean
    public open override /*1*/ fun next() : jet.Int
    public abstract fun nextInt() : jet.Int
}

public final class IntRange : jet.Range<jet.Int>, jet.IntIterable {
    public constructor IntRange(/*0*/ start : jet.Int, /*1*/ size : jet.Int)
    public final val end : jet.Int
    public final val size : jet.Int
    public final val start : jet.Int
    public open override /*1*/ fun contains(/*0*/ elem : jet.Int) : jet.Boolean
    public open override /*1*/ fun iterator() : jet.IntIterator
    public final fun step(/*0*/ step : jet.Int) : jet.IntIterator
    
    public class object <class-object-for-IntRange> {
        private constructor <class-object-for-IntRange>()
        public final val EMPTY : jet.IntRange
    }
}

public trait Iterable</*0*/ out T> {
    public abstract fun iterator() : jet.Iterator<T>
}

public trait Iterator</*0*/ out T> {
    public abstract fun hasNext() : jet.Boolean
    public abstract fun next() : T
}

public trait List</*0*/ out E> : jet.Collection<E> {
    public abstract override /*1*/ fun contains(/*0*/ o : jet.Any?) : jet.Boolean
    public abstract override /*1*/ fun containsAll(/*0*/ c : jet.Collection<jet.Any?>) : jet.Boolean
    public abstract override /*1*/ /*fake_override*/ fun equals(/*0*/ other : jet.Any?) : jet.Boolean
    public abstract fun get(/*0*/ index : jet.Int) : E
    public abstract override /*1*/ /*fake_override*/ fun hashCode() : jet.Int
    public abstract fun indexOf(/*0*/ o : jet.Any?) : jet.Int
    public abstract override /*1*/ fun isEmpty() : jet.Boolean
    public abstract override /*1*/ fun iterator() : jet.Iterator<E>
    public abstract fun lastIndexOf(/*0*/ o : jet.Any?) : jet.Int
    public abstract fun listIterator() : jet.ListIterator<E>
    public abstract fun listIterator(/*0*/ index : jet.Int) : jet.ListIterator<E>
    public abstract override /*1*/ fun size() : jet.Int
    public abstract fun subList(/*0*/ fromIndex : jet.Int, /*1*/ toIndex : jet.Int) : jet.List<E>
    public abstract override /*1*/ fun toArray() : jet.Array<jet.Any?>
    public abstract override /*1*/ fun </*0*/ T> toArray(/*0*/ a : jet.Array<out T>) : jet.Array<T>
}

public trait ListIterator</*0*/ out T> : jet.Iterator<T> {
    public abstract override /*1*/ fun hasNext() : jet.Boolean
    public abstract fun hasPrevious() : jet.Boolean
    public abstract override /*1*/ fun next() : T
    public abstract fun nextIndex() : jet.Int
    public abstract fun previous() : T
    public abstract fun previousIndex() : jet.Int
}

public final class Long : jet.Number, jet.Comparable<jet.Long> {
    public constructor 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 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 ushr(/*0*/ bits : jet.Int) : jet.Long
    public final fun xor(/*0*/ other : jet.Long) : jet.Long
}

public final class LongArray {
    public constructor LongArray(/*0*/ size : jet.Int)
    public final val indices : jet.IntRange
    public final val size : jet.Int
    public final fun get(/*0*/ index : jet.Int) : jet.Long
    public final fun iterator() : jet.LongIterator
    public final fun set(/*0*/ index : jet.Int, /*1*/ value : jet.Long) : Unit
}

public trait LongIterable : jet.Iterable<jet.Long> {
    public abstract override /*1*/ fun iterator() : jet.LongIterator
}

public abstract class LongIterator : jet.Iterator<jet.Long> {
    public constructor LongIterator()
    public abstract override /*1*/ /*fake_override*/ fun hasNext() : jet.Boolean
    public open override /*1*/ fun next() : jet.Long
    public abstract fun nextLong() : jet.Long
}

public final class LongRange : jet.Range<jet.Long>, jet.LongIterable {
    public constructor LongRange(/*0*/ start : jet.Long, /*1*/ size : jet.Long)
    public final val end : jet.Long
    public final val size : jet.Long
    public final val start : jet.Long
    public open override /*1*/ fun contains(/*0*/ elem : jet.Long) : jet.Boolean
    public open override /*1*/ fun iterator() : jet.LongIterator
    public final fun step(/*0*/ step : jet.Long) : jet.LongIterator
    
    public class object <class-object-for-LongRange> {
        private constructor <class-object-for-LongRange>()
        public final val EMPTY : jet.LongRange
    }
}

public trait Map</*0*/ K, /*1*/ out V> {
    public abstract fun containsKey(/*0*/ key : jet.Any?) : jet.Boolean
    public abstract fun containsValue(/*0*/ value : jet.Any?) : jet.Boolean
    public abstract fun entrySet() : jet.Set<jet.Map.Entry<K, V>>
    public abstract fun get(/*0*/ key : jet.Any?) : V?
    public abstract fun isEmpty() : jet.Boolean
    public abstract fun keySet() : jet.Set<K>
    public abstract fun size() : jet.Int
    public abstract fun values() : jet.Collection<V>
    
    public trait Entry</*0*/ out K, /*1*/ out V> : jet.Hashable {
        public abstract override /*1*/ /*fake_override*/ fun equals(/*0*/ other : jet.Any?) : jet.Boolean
        public abstract fun getKey() : K
        public abstract fun getValue() : V
        public abstract override /*1*/ /*fake_override*/ fun hashCode() : jet.Int
    }
}

public trait MutableCollection</*0*/ E> : jet.Collection<E>, jet.MutableIterable<E> {
    public abstract fun add(/*0*/ e : E) : jet.Boolean
    public abstract fun addAll(/*0*/ c : jet.Collection<E>) : jet.Boolean
    public abstract fun clear() : Unit
    public abstract override /*1*/ /*fake_override*/ fun contains(/*0*/ o : jet.Any?) : jet.Boolean
    public abstract override /*1*/ /*fake_override*/ fun containsAll(/*0*/ c : jet.Collection<jet.Any?>) : jet.Boolean
    public abstract override /*1*/ /*fake_override*/ fun equals(/*0*/ other : jet.Any?) : jet.Boolean
    public abstract override /*1*/ /*fake_override*/ fun hashCode() : jet.Int
    public abstract override /*1*/ /*fake_override*/ fun isEmpty() : jet.Boolean
    public abstract override /*2*/ fun iterator() : jet.MutableIterator<E>
    public abstract fun remove(/*0*/ o : jet.Any?) : jet.Boolean
    public abstract fun removeAll(/*0*/ c : jet.Collection<jet.Any?>) : jet.Boolean
    public abstract fun retainAll(/*0*/ c : jet.Collection<jet.Any?>) : jet.Boolean
    public abstract override /*1*/ /*fake_override*/ fun size() : jet.Int
    public abstract override /*1*/ /*fake_override*/ fun toArray() : jet.Array<jet.Any?>
    public abstract override /*1*/ /*fake_override*/ fun </*0*/ T> toArray(/*0*/ a : jet.Array<out T>) : jet.Array<T>
}

public trait MutableIterable</*0*/ out T> : jet.Iterable<T> {
    public abstract override /*1*/ fun iterator() : jet.MutableIterator<T>
}

public trait MutableIterator</*0*/ out T> : jet.Iterator<T> {
    public abstract override /*1*/ /*fake_override*/ fun hasNext() : jet.Boolean
    public abstract override /*1*/ /*fake_override*/ fun next() : T
    public abstract fun remove() : Unit
}

public trait MutableList</*0*/ E> : jet.List<E>, jet.MutableCollection<E> {
    public abstract override /*1*/ fun add(/*0*/ e : E) : jet.Boolean
    public abstract fun add(/*0*/ index : jet.Int, /*1*/ element : E) : Unit
    public abstract override /*1*/ fun addAll(/*0*/ c : jet.Collection<E>) : jet.Boolean
    public abstract fun addAll(/*0*/ index : jet.Int, /*1*/ c : jet.Collection<E>) : jet.Boolean
    public abstract override /*1*/ fun clear() : Unit
    public abstract override /*2*/ /*fake_override*/ fun contains(/*0*/ o : jet.Any?) : jet.Boolean
    public abstract override /*2*/ /*fake_override*/ fun containsAll(/*0*/ c : jet.Collection<jet.Any?>) : jet.Boolean
    public abstract override /*2*/ /*fake_override*/ fun equals(/*0*/ other : jet.Any?) : jet.Boolean
    public abstract override /*1*/ /*fake_override*/ fun get(/*0*/ index : jet.Int) : E
    public abstract override /*2*/ /*fake_override*/ fun hashCode() : jet.Int
    public abstract override /*1*/ /*fake_override*/ fun indexOf(/*0*/ o : jet.Any?) : jet.Int
    public abstract override /*2*/ /*fake_override*/ fun isEmpty() : jet.Boolean
    public abstract override /*2*/ /*fake_override*/ fun iterator() : jet.Iterator<E>
    public abstract override /*1*/ /*fake_override*/ fun lastIndexOf(/*0*/ o : jet.Any?) : jet.Int
    public abstract override /*1*/ fun listIterator() : jet.MutableListIterator<E>
    public abstract override /*1*/ fun listIterator(/*0*/ index : jet.Int) : jet.MutableListIterator<E>
    public abstract override /*1*/ fun remove(/*0*/ o : jet.Any?) : jet.Boolean
    public abstract fun remove(/*0*/ index : jet.Int) : E
    public abstract override /*1*/ fun removeAll(/*0*/ c : jet.Collection<jet.Any?>) : jet.Boolean
    public abstract override /*1*/ fun retainAll(/*0*/ c : jet.Collection<jet.Any?>) : jet.Boolean
    public abstract fun set(/*0*/ index : jet.Int, /*1*/ element : E) : E
    public abstract override /*2*/ /*fake_override*/ fun size() : jet.Int
    public abstract override /*1*/ fun subList(/*0*/ fromIndex : jet.Int, /*1*/ toIndex : jet.Int) : jet.MutableList<E>
    public abstract override /*2*/ /*fake_override*/ fun toArray() : jet.Array<jet.Any?>
    public abstract override /*2*/ /*fake_override*/ fun </*0*/ T> toArray(/*0*/ a : jet.Array<out T>) : jet.Array<T>
}

public trait MutableListIterator</*0*/ T> : jet.ListIterator<T>, jet.MutableIterator<T> {
    public abstract fun add(/*0*/ e : T) : Unit
    public abstract override /*2*/ fun hasNext() : jet.Boolean
    public abstract override /*1*/ /*fake_override*/ fun hasPrevious() : jet.Boolean
    public abstract override /*2*/ fun next() : T
    public abstract override /*1*/ /*fake_override*/ fun nextIndex() : jet.Int
    public abstract override /*1*/ /*fake_override*/ fun previous() : T
    public abstract override /*1*/ /*fake_override*/ fun previousIndex() : jet.Int
    public abstract override /*1*/ fun remove() : Unit
    public abstract fun set(/*0*/ e : T) : Unit
}

public trait MutableMap</*0*/ K, /*1*/ V> : jet.Map<K, V> {
    public abstract fun clear() : Unit
    public abstract override /*1*/ /*fake_override*/ fun containsKey(/*0*/ key : jet.Any?) : jet.Boolean
    public abstract override /*1*/ /*fake_override*/ fun containsValue(/*0*/ value : jet.Any?) : jet.Boolean
    public abstract override /*1*/ fun entrySet() : jet.MutableSet<jet.MutableMap.MutableEntry<K, V>>
    public abstract override /*1*/ /*fake_override*/ fun get(/*0*/ key : jet.Any?) : V?
    public abstract override /*1*/ /*fake_override*/ fun isEmpty() : jet.Boolean
    public abstract override /*1*/ fun keySet() : jet.MutableSet<K>
    public abstract fun put(/*0*/ key : K, /*1*/ value : V) : V?
    public abstract fun putAll(/*0*/ m : jet.Map<out K, out V>) : Unit
    public abstract fun remove(/*0*/ key : jet.Any?) : V?
    public abstract override /*1*/ /*fake_override*/ fun size() : jet.Int
    public abstract override /*1*/ fun values() : jet.MutableCollection<V>
    
    public trait MutableEntry</*0*/ K, /*1*/ V> : jet.Map.Entry<K, V>, jet.Hashable {
        public abstract override /*2*/ /*fake_override*/ fun equals(/*0*/ other : jet.Any?) : jet.Boolean
        public abstract override /*1*/ /*fake_override*/ fun getKey() : K
        public abstract override /*1*/ /*fake_override*/ fun getValue() : V
        public abstract override /*2*/ /*fake_override*/ fun hashCode() : jet.Int
        public abstract fun setValue(/*0*/ value : V) : V
    }
}

public trait MutableSet</*0*/ E> : jet.Set<E>, jet.MutableCollection<E> {
    public abstract override /*1*/ fun add(/*0*/ e : E) : jet.Boolean
    public abstract override /*1*/ fun addAll(/*0*/ c : jet.Collection<E>) : jet.Boolean
    public abstract override /*1*/ fun clear() : Unit
    public abstract override /*2*/ /*fake_override*/ fun contains(/*0*/ o : jet.Any?) : jet.Boolean
    public abstract override /*2*/ /*fake_override*/ fun containsAll(/*0*/ c : jet.Collection<jet.Any?>) : jet.Boolean
    public abstract override /*2*/ /*fake_override*/ fun equals(/*0*/ other : jet.Any?) : jet.Boolean
    public abstract override /*2*/ /*fake_override*/ fun hashCode() : jet.Int
    public abstract override /*2*/ /*fake_override*/ fun isEmpty() : jet.Boolean
    public abstract override /*2*/ fun iterator() : jet.MutableIterator<E>
    public abstract override /*1*/ fun remove(/*0*/ o : jet.Any?) : jet.Boolean
    public abstract override /*1*/ fun removeAll(/*0*/ c : jet.Collection<jet.Any?>) : jet.Boolean
    public abstract override /*1*/ fun retainAll(/*0*/ c : jet.Collection<jet.Any?>) : jet.Boolean
    public abstract override /*2*/ /*fake_override*/ fun size() : jet.Int
    public abstract override /*2*/ /*fake_override*/ fun toArray() : jet.Array<jet.Any?>
    public abstract override /*2*/ /*fake_override*/ fun </*0*/ T> toArray(/*0*/ a : jet.Array<out T>) : jet.Array<T>
}

public final class Nothing {
    private constructor Nothing()
}

public abstract class Number : jet.Hashable {
    public constructor Number()
    public abstract override /*1*/ /*fake_override*/ fun equals(/*0*/ other : jet.Any?) : jet.Boolean
    public abstract override /*1*/ /*fake_override*/ 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 trait Range</*0*/ in T : jet.Comparable<T>> {
    public abstract fun contains(/*0*/ item : T) : jet.Boolean
}

public trait Set</*0*/ out E> : jet.Collection<E> {
    public abstract override /*1*/ fun contains(/*0*/ o : jet.Any?) : jet.Boolean
    public abstract override /*1*/ fun containsAll(/*0*/ c : jet.Collection<jet.Any?>) : jet.Boolean
    public abstract override /*1*/ /*fake_override*/ fun equals(/*0*/ other : jet.Any?) : jet.Boolean
    public abstract override /*1*/ /*fake_override*/ fun hashCode() : jet.Int
    public abstract override /*1*/ fun isEmpty() : jet.Boolean
    public abstract override /*1*/ fun iterator() : jet.Iterator<E>
    public abstract override /*1*/ fun size() : jet.Int
    public abstract override /*1*/ fun toArray() : jet.Array<jet.Any?>
    public abstract override /*1*/ fun </*0*/ T> toArray(/*0*/ a : jet.Array<out T>) : jet.Array<T>
}

public final class Short : jet.Number, jet.Comparable<jet.Short> {
    public constructor 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 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 class ShortArray {
    public constructor ShortArray(/*0*/ size : jet.Int)
    public final val indices : jet.IntRange
    public final val size : jet.Int
    public final fun get(/*0*/ index : jet.Int) : jet.Short
    public final fun iterator() : jet.ShortIterator
    public final fun set(/*0*/ index : jet.Int, /*1*/ value : jet.Short) : Unit
}

public trait ShortIterable : jet.Iterable<jet.Short> {
    public abstract override /*1*/ fun iterator() : jet.ShortIterator
}

public abstract class ShortIterator : jet.Iterator<jet.Short> {
    public constructor ShortIterator()
    public abstract override /*1*/ /*fake_override*/ fun hasNext() : jet.Boolean
    public open override /*1*/ fun next() : jet.Short
    public abstract fun nextShort() : jet.Short
}

public final class ShortRange : jet.Range<jet.Short>, jet.ShortIterable {
    public constructor ShortRange(/*0*/ start : jet.Short, /*1*/ size : jet.Int)
    public final val end : jet.Short
    public final val size : jet.Int
    public final val start : jet.Short
    public open override /*1*/ fun contains(/*0*/ elem : jet.Short) : jet.Boolean
    public open override /*1*/ fun iterator() : jet.ShortIterator
    public final fun step(/*0*/ step : jet.Int) : jet.ShortIterator
    
    public class object <class-object-for-ShortRange> {
        private constructor <class-object-for-ShortRange>()
        public final val EMPTY : jet.ShortRange
    }
}

public final class String : jet.Comparable<jet.String>, jet.CharSequence {
    public constructor String()
    public open override /*1*/ val length : jet.Int
    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 final fun plus(/*0*/ other : jet.Any?) : jet.String
    public open override /*1*/ fun toString() : jet.String
}

public open class Throwable {
    public constructor Throwable(/*0*/ message : jet.String? = ..., /*1*/ cause : jet.Throwable? = ...)
    public final fun getCause() : jet.Throwable?
    public final fun getMessage() : jet.String?
    public final fun printStackTrace() : Unit
}

public final class Tuple0 {
    private constructor Tuple0()
    
    public class object <class-object-for-Tuple0> {
        private constructor <class-object-for-Tuple0>()
        public final val VALUE : Unit
    }
}

public final class Tuple1</*0*/ out T1> {
    public constructor Tuple1</*0*/ out T1>(/*0*/ _1 : T1)
    public final val _1 : T1
}

public final class Tuple10</*0*/ out T1, /*1*/ out T2, /*2*/ out T3, /*3*/ out T4, /*4*/ out T5, /*5*/ out T6, /*6*/ out T7, /*7*/ out T8, /*8*/ out T9, /*9*/ out T10> {
    public constructor Tuple10</*0*/ out T1, /*1*/ out T2, /*2*/ out T3, /*3*/ out T4, /*4*/ out T5, /*5*/ out T6, /*6*/ out T7, /*7*/ out T8, /*8*/ out T9, /*9*/ out T10>(/*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)
    public final val _1 : T1
    public final val _10 : T10
    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 Tuple11</*0*/ out T1, /*1*/ out T2, /*2*/ out T3, /*3*/ out T4, /*4*/ out T5, /*5*/ out T6, /*6*/ out T7, /*7*/ out T8, /*8*/ out T9, /*9*/ out T10, /*10*/ out T11> {
    public constructor Tuple11</*0*/ out T1, /*1*/ out T2, /*2*/ out T3, /*3*/ out T4, /*4*/ out T5, /*5*/ out T6, /*6*/ out T7, /*7*/ out T8, /*8*/ out T9, /*9*/ out T10, /*10*/ out T11>(/*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)
    public final val _1 : T1
    public final val _10 : T10
    public final val _11 : T11
    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 Tuple12</*0*/ out T1, /*1*/ out T2, /*2*/ out T3, /*3*/ out T4, /*4*/ out T5, /*5*/ out T6, /*6*/ out T7, /*7*/ out T8, /*8*/ out T9, /*9*/ out T10, /*10*/ out T11, /*11*/ out T12> {
    public constructor Tuple12</*0*/ out T1, /*1*/ out T2, /*2*/ out T3, /*3*/ out T4, /*4*/ out T5, /*5*/ out T6, /*6*/ out T7, /*7*/ out T8, /*8*/ out T9, /*9*/ out T10, /*10*/ out T11, /*11*/ out T12>(/*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)
    public final val _1 : T1
    public final val _10 : T10
    public final val _11 : T11
    public final val _12 : T12
    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 Tuple13</*0*/ out T1, /*1*/ out T2, /*2*/ out T3, /*3*/ out T4, /*4*/ out T5, /*5*/ out T6, /*6*/ out T7, /*7*/ out T8, /*8*/ out T9, /*9*/ out T10, /*10*/ out T11, /*11*/ out T12, /*12*/ out T13> {
    public constructor Tuple13</*0*/ out T1, /*1*/ out T2, /*2*/ out T3, /*3*/ out T4, /*4*/ out T5, /*5*/ out T6, /*6*/ out T7, /*7*/ out T8, /*8*/ out T9, /*9*/ out T10, /*10*/ out T11, /*11*/ out T12, /*12*/ out T13>(/*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)
    public final val _1 : T1
    public final val _10 : T10
    public final val _11 : T11
    public final val _12 : T12
    public final val _13 : T13
    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 Tuple14</*0*/ out T1, /*1*/ out T2, /*2*/ out T3, /*3*/ out T4, /*4*/ out T5, /*5*/ out T6, /*6*/ out T7, /*7*/ out T8, /*8*/ out T9, /*9*/ out T10, /*10*/ out T11, /*11*/ out T12, /*12*/ out T13, /*13*/ out T14> {
    public constructor Tuple14</*0*/ out T1, /*1*/ out T2, /*2*/ out T3, /*3*/ out T4, /*4*/ out T5, /*5*/ out T6, /*6*/ out T7, /*7*/ out T8, /*8*/ out T9, /*9*/ out T10, /*10*/ out T11, /*11*/ out T12, /*12*/ out T13, /*13*/ out T14>(/*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)
    public final val _1 : T1
    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 _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 Tuple15</*0*/ out T1, /*1*/ out T2, /*2*/ out T3, /*3*/ out T4, /*4*/ out T5, /*5*/ out T6, /*6*/ out T7, /*7*/ out T8, /*8*/ out T9, /*9*/ out T10, /*10*/ out T11, /*11*/ out T12, /*12*/ out T13, /*13*/ out T14, /*14*/ out T15> {
    public constructor Tuple15</*0*/ out T1, /*1*/ out T2, /*2*/ out T3, /*3*/ out T4, /*4*/ out T5, /*5*/ out T6, /*6*/ out T7, /*7*/ out T8, /*8*/ out T9, /*9*/ out T10, /*10*/ out T11, /*11*/ out T12, /*12*/ out T13, /*13*/ out T14, /*14*/ out T15>(/*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)
    public final val _1 : T1
    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 _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 Tuple16</*0*/ out T1, /*1*/ out T2, /*2*/ out T3, /*3*/ out T4, /*4*/ out T5, /*5*/ out T6, /*6*/ out T7, /*7*/ out T8, /*8*/ out T9, /*9*/ out T10, /*10*/ out T11, /*11*/ out T12, /*12*/ out T13, /*13*/ out T14, /*14*/ out T15, /*15*/ out T16> {
    public constructor Tuple16</*0*/ out T1, /*1*/ out T2, /*2*/ out T3, /*3*/ out T4, /*4*/ out T5, /*5*/ out T6, /*6*/ out T7, /*7*/ out T8, /*8*/ out T9, /*9*/ out T10, /*10*/ out T11, /*11*/ out T12, /*12*/ out T13, /*13*/ out T14, /*14*/ out T15, /*15*/ out T16>(/*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)
    public final val _1 : T1
    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 _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 Tuple17</*0*/ out T1, /*1*/ out T2, /*2*/ out T3, /*3*/ out T4, /*4*/ out T5, /*5*/ out T6, /*6*/ out T7, /*7*/ out T8, /*8*/ out T9, /*9*/ out T10, /*10*/ out T11, /*11*/ out T12, /*12*/ out T13, /*13*/ out T14, /*14*/ out T15, /*15*/ out T16, /*16*/ out T17> {
    public constructor Tuple17</*0*/ out T1, /*1*/ out T2, /*2*/ out T3, /*3*/ out T4, /*4*/ out T5, /*5*/ out T6, /*6*/ out T7, /*7*/ out T8, /*8*/ out T9, /*9*/ out T10, /*10*/ out T11, /*11*/ out T12, /*12*/ out T13, /*13*/ out T14, /*14*/ out T15, /*15*/ out T16, /*16*/ out T17>(/*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)
    public final val _1 : T1
    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 _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 Tuple18</*0*/ out T1, /*1*/ out T2, /*2*/ out T3, /*3*/ out T4, /*4*/ out T5, /*5*/ out T6, /*6*/ out T7, /*7*/ out T8, /*8*/ out T9, /*9*/ out T10, /*10*/ out T11, /*11*/ out T12, /*12*/ out T13, /*13*/ out T14, /*14*/ out T15, /*15*/ out T16, /*16*/ out T17, /*17*/ out T18> {
    public constructor Tuple18</*0*/ out T1, /*1*/ out T2, /*2*/ out T3, /*3*/ out T4, /*4*/ out T5, /*5*/ out T6, /*6*/ out T7, /*7*/ out T8, /*8*/ out T9, /*9*/ out T10, /*10*/ out T11, /*11*/ out T12, /*12*/ out T13, /*13*/ out T14, /*14*/ out T15, /*15*/ out T16, /*16*/ out T17, /*17*/ out T18>(/*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)
    public final val _1 : T1
    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 _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 Tuple19</*0*/ out T1, /*1*/ out T2, /*2*/ out T3, /*3*/ out T4, /*4*/ out T5, /*5*/ out T6, /*6*/ out T7, /*7*/ out T8, /*8*/ out T9, /*9*/ out T10, /*10*/ out T11, /*11*/ out T12, /*12*/ out T13, /*13*/ out T14, /*14*/ out T15, /*15*/ out T16, /*16*/ out T17, /*17*/ out T18, /*18*/ out T19> {
    public constructor Tuple19</*0*/ out T1, /*1*/ out T2, /*2*/ out T3, /*3*/ out T4, /*4*/ out T5, /*5*/ out T6, /*6*/ out T7, /*7*/ out T8, /*8*/ out T9, /*9*/ out T10, /*10*/ out T11, /*11*/ out T12, /*12*/ out T13, /*13*/ out T14, /*14*/ out T15, /*15*/ out T16, /*16*/ out T17, /*17*/ out T18, /*18*/ out T19>(/*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)
    public final val _1 : T1
    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 _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 Tuple2</*0*/ out T1, /*1*/ out T2> {
    public constructor Tuple2</*0*/ out T1, /*1*/ out T2>(/*0*/ _1 : T1, /*1*/ _2 : T2)
    public final val _1 : T1
    public final val _2 : T2
}

public final class Tuple20</*0*/ out T1, /*1*/ out T2, /*2*/ out T3, /*3*/ out T4, /*4*/ out T5, /*5*/ out T6, /*6*/ out T7, /*7*/ out T8, /*8*/ out T9, /*9*/ out T10, /*10*/ out T11, /*11*/ out T12, /*12*/ out T13, /*13*/ out T14, /*14*/ out T15, /*15*/ out T16, /*16*/ out T17, /*17*/ out T18, /*18*/ out T19, /*19*/ out T20> {
    public constructor Tuple20</*0*/ out T1, /*1*/ out T2, /*2*/ out T3, /*3*/ out T4, /*4*/ out T5, /*5*/ out T6, /*6*/ out T7, /*7*/ out T8, /*8*/ out T9, /*9*/ out T10, /*10*/ out T11, /*11*/ out T12, /*12*/ out T13, /*13*/ out T14, /*14*/ out T15, /*15*/ out T16, /*16*/ out T17, /*17*/ out T18, /*18*/ out T19, /*19*/ out T20>(/*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)
    public final val _1 : T1
    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 _2 : T2
    public final val _20 : T20
    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 Tuple21</*0*/ out T1, /*1*/ out T2, /*2*/ out T3, /*3*/ out T4, /*4*/ out T5, /*5*/ out T6, /*6*/ out T7, /*7*/ out T8, /*8*/ out T9, /*9*/ out T10, /*10*/ out T11, /*11*/ out T12, /*12*/ out T13, /*13*/ out T14, /*14*/ out T15, /*15*/ out T16, /*16*/ out T17, /*17*/ out T18, /*18*/ out T19, /*19*/ out T20, /*20*/ out T21> {
    public constructor Tuple21</*0*/ out T1, /*1*/ out T2, /*2*/ out T3, /*3*/ out T4, /*4*/ out T5, /*5*/ out T6, /*6*/ out T7, /*7*/ out T8, /*8*/ out T9, /*9*/ out T10, /*10*/ out T11, /*11*/ out T12, /*12*/ out T13, /*13*/ out T14, /*14*/ out T15, /*15*/ out T16, /*16*/ out T17, /*17*/ out T18, /*18*/ out T19, /*19*/ out T20, /*20*/ out T21>(/*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)
    public final val _1 : T1
    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 _2 : T2
    public final val _20 : T20
    public final val _21 : T21
    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 Tuple22</*0*/ out T1, /*1*/ out T2, /*2*/ out T3, /*3*/ out T4, /*4*/ out T5, /*5*/ out T6, /*6*/ out T7, /*7*/ out T8, /*8*/ out T9, /*9*/ out T10, /*10*/ out T11, /*11*/ out T12, /*12*/ out T13, /*13*/ out T14, /*14*/ out T15, /*15*/ out T16, /*16*/ out T17, /*17*/ out T18, /*18*/ out T19, /*19*/ out T20, /*20*/ out T21, /*21*/ out T22> {
    public constructor Tuple22</*0*/ out T1, /*1*/ out T2, /*2*/ out T3, /*3*/ out T4, /*4*/ out T5, /*5*/ out T6, /*6*/ out T7, /*7*/ out T8, /*8*/ out T9, /*9*/ out T10, /*10*/ out T11, /*11*/ out T12, /*12*/ out T13, /*13*/ out T14, /*14*/ out T15, /*15*/ out T16, /*16*/ out T17, /*17*/ out T18, /*18*/ out T19, /*19*/ out T20, /*20*/ out T21, /*21*/ out T22>(/*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)
    public final val _1 : T1
    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 _2 : T2
    public final val _20 : T20
    public final val _21 : T21
    public final val _22 : T22
    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 Tuple3</*0*/ out T1, /*1*/ out T2, /*2*/ out T3> {
    public constructor Tuple3</*0*/ out T1, /*1*/ out T2, /*2*/ out T3>(/*0*/ _1 : T1, /*1*/ _2 : T2, /*2*/ _3 : T3)
    public final val _1 : T1
    public final val _2 : T2
    public final val _3 : T3
}

public final class Tuple4</*0*/ out T1, /*1*/ out T2, /*2*/ out T3, /*3*/ out T4> {
    public constructor Tuple4</*0*/ out T1, /*1*/ out T2, /*2*/ out T3, /*3*/ out T4>(/*0*/ _1 : T1, /*1*/ _2 : T2, /*2*/ _3 : T3, /*3*/ _4 : T4)
    public final val _1 : T1
    public final val _2 : T2
    public final val _3 : T3
    public final val _4 : T4
}

public final class Tuple5</*0*/ out T1, /*1*/ out T2, /*2*/ out T3, /*3*/ out T4, /*4*/ out T5> {
    public constructor Tuple5</*0*/ out T1, /*1*/ out T2, /*2*/ out T3, /*3*/ out T4, /*4*/ out T5>(/*0*/ _1 : T1, /*1*/ _2 : T2, /*2*/ _3 : T3, /*3*/ _4 : T4, /*4*/ _5 : 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 Tuple6</*0*/ out T1, /*1*/ out T2, /*2*/ out T3, /*3*/ out T4, /*4*/ out T5, /*5*/ out T6> {
    public constructor Tuple6</*0*/ out T1, /*1*/ out T2, /*2*/ out T3, /*3*/ out T4, /*4*/ out T5, /*5*/ out T6>(/*0*/ _1 : T1, /*1*/ _2 : T2, /*2*/ _3 : T3, /*3*/ _4 : T4, /*4*/ _5 : T5, /*5*/ _6 : 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 Tuple7</*0*/ out T1, /*1*/ out T2, /*2*/ out T3, /*3*/ out T4, /*4*/ out T5, /*5*/ out T6, /*6*/ out T7> {
    public constructor Tuple7</*0*/ out T1, /*1*/ out T2, /*2*/ out T3, /*3*/ out T4, /*4*/ out T5, /*5*/ out T6, /*6*/ out T7>(/*0*/ _1 : T1, /*1*/ _2 : T2, /*2*/ _3 : T3, /*3*/ _4 : T4, /*4*/ _5 : T5, /*5*/ _6 : T6, /*6*/ _7 : 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 Tuple8</*0*/ out T1, /*1*/ out T2, /*2*/ out T3, /*3*/ out T4, /*4*/ out T5, /*5*/ out T6, /*6*/ out T7, /*7*/ out T8> {
    public constructor Tuple8</*0*/ out T1, /*1*/ out T2, /*2*/ out T3, /*3*/ out T4, /*4*/ out T5, /*5*/ out T6, /*6*/ out T7, /*7*/ out T8>(/*0*/ _1 : T1, /*1*/ _2 : T2, /*2*/ _3 : T3, /*3*/ _4 : T4, /*4*/ _5 : T5, /*5*/ _6 : T6, /*6*/ _7 : T7, /*7*/ _8 : 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 Tuple9</*0*/ out T1, /*1*/ out T2, /*2*/ out T3, /*3*/ out T4, /*4*/ out T5, /*5*/ out T6, /*6*/ out T7, /*7*/ out T8, /*8*/ out T9> {
    public constructor Tuple9</*0*/ out T1, /*1*/ out T2, /*2*/ out T3, /*3*/ out T4, /*4*/ out T5, /*5*/ out T6, /*6*/ out T7, /*7*/ out T8, /*8*/ out T9>(/*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)
    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 atomic : jet.Annotation {
    public constructor atomic()
}

public final annotation class data : jet.Annotation {
    public constructor data()
}

public final annotation class deprecated : jet.Annotation {
    public constructor deprecated(/*0*/ value : jet.String)
}

public final annotation class volatile : jet.Annotation {
    public constructor volatile()
}