Пакет kotlin.collections

abstract class AbstractCollection<out E> : Collection<E>

abstract class AbstractIterator<T> : Iterator<T>

abstract class AbstractList<out E> : 
    AbstractCollection<E>, 
    List<E>

abstract class AbstractMap<K, out V> : Map<K, V>

abstract class AbstractMutableCollection<E> : 
    MutableCollection<E>

abstract class AbstractMutableCollection<E> : 
    MutableCollection<E>, 
    AbstractCollection<E>

abstract class AbstractMutableCollection<E> : 
    AbstractCollection<E>, 
    MutableCollection<E>

abstract class AbstractMutableList<E> : MutableList<E>

abstract class AbstractMutableList<E> : 
    MutableList<E>, 
    AbstractList<E>

abstract class AbstractMutableList<E> : 
    AbstractMutableCollection<E>, 
    MutableList<E>

abstract class AbstractMutableMap<K, V> : MutableMap<K, V>

abstract class AbstractMutableMap<K, V> : 
    MutableMap<K, V>, 
    AbstractMap<K, V>

abstract class AbstractMutableMap<K, V> : 
    AbstractMap<K, V>, 
    MutableMap<K, V>

abstract class AbstractMutableSet<E> : MutableSet<E>

abstract class AbstractMutableSet<E> : 
    MutableSet<E>, 
    AbstractSet<E>

abstract class AbstractMutableSet<E> : 
    AbstractMutableCollection<E>, 
    MutableSet<E>

abstract class AbstractSet<out E> : 
    AbstractCollection<E>, 
    Set<E>

class ArrayDeque<E> : AbstractMutableList<E>

class ArrayList<E> : MutableList<E>, RandomAccess

typealias ArrayList<E> = ArrayList<E>

open class ArrayList<E> : 
    AbstractMutableList<E>, 
    MutableList<E>, 
    RandomAccess

abstract class BooleanIterator : Iterator<Boolean>

abstract class ByteIterator : Iterator<Byte>

abstract class CharIterator : Iterator<Char>

interface Collection<out E> : Iterable<E>

abstract class DoubleIterator : Iterator<Double>

abstract class FloatIterator : Iterator<Float>

interface Grouping<T, out K>

class HashMap<K, V> : MutableMap<K, V>

typealias HashMap<K, V> = HashMap<K, V>

open class HashMap<K, V> : 
    AbstractMutableMap<K, V>, 
    MutableMap<K, V>

class HashSet<E> : MutableSet<E>

typealias HashSet<E> = HashSet<E>

open class HashSet<E> : AbstractMutableSet<E>, MutableSet<E>

data class IndexedValue<out T>

abstract class IntIterator : Iterator<Int>

interface Iterable<out T>

interface Iterator<out T>

class LinkedHashMap<K, V> : MutableMap<K, V>

typealias LinkedHashMap<K, V> = LinkedHashMap<K, V>

open class LinkedHashMap<K, V> : 
    HashMap<K, V>, 
    MutableMap<K, V>

class LinkedHashSet<E> : MutableSet<E>

typealias LinkedHashSet<E> = LinkedHashSet<E>

open class LinkedHashSet<E> : HashSet<E>, MutableSet<E>

interface List<out E> : Collection<E>

interface ListIterator<out T> : Iterator<T>

abstract class LongIterator : Iterator<Long>

interface Map<K, out V>

interface MutableCollection<E> : 
    Collection<E>, 
    MutableIterable<E>

interface MutableIterable<out T> : Iterable<T>

interface MutableIterator<out T> : Iterator<T>

interface MutableList<E> : List<E>, MutableCollection<E>

interface MutableListIterator<T> : 
    ListIterator<T>, 
    MutableIterator<T>

interface MutableMap<K, V> : Map<K, V>

interface MutableSet<E> : Set<E>, MutableCollection<E>

interface RandomAccess

typealias RandomAccess = RandomAccess

interface Set<out E> : Collection<E>

abstract class ShortIterator : Iterator<Short>

fun <T> MutableCollection<in T>.addAll(
    elements: Iterable<T>
): Boolean

fun <T> MutableCollection<in T>.addAll(
    elements: Sequence<T>
): Boolean

fun <T> MutableCollection<in T>.addAll(
    elements: Array<out T>
): Boolean

fun <T, K, R> Grouping<T, K>.aggregate(
    operation: (key: K, accumulator: R?, element: T, first: Boolean) -> R
): Map<K, R>

fun <T, K, R, M : MutableMap<in K, R>> Grouping<T, K>.aggregateTo(
    destination: M, 
    operation: (key: K, accumulator: R?, element: T, first: Boolean) -> R
): M

fun <T> Array<out T>.all(predicate: (T) -> Boolean): Boolean

fun ByteArray.all(predicate: (Byte) -> Boolean): Boolean

fun ShortArray.all(predicate: (Short) -> Boolean): Boolean

fun IntArray.all(predicate: (Int) -> Boolean): Boolean

fun LongArray.all(predicate: (Long) -> Boolean): Boolean

fun FloatArray.all(predicate: (Float) -> Boolean): Boolean

fun DoubleArray.all(predicate: (Double) -> Boolean): Boolean

fun BooleanArray.all(
    predicate: (Boolean) -> Boolean
): Boolean

fun CharArray.all(predicate: (Char) -> Boolean): Boolean

fun <T> Iterable<T>.all(predicate: (T) -> Boolean): Boolean

fun UIntArray.all(predicate: (UInt) -> Boolean): Boolean

fun ULongArray.all(predicate: (ULong) -> Boolean): Boolean

fun UByteArray.all(predicate: (UByte) -> Boolean): Boolean

fun UShortArray.all(predicate: (UShort) -> Boolean): Boolean

fun <K, V> Map<out K, V>.all(
    predicate: (Entry<K, V>) -> Boolean
): Boolean

fun <T> Array<out T>.any(): Boolean

fun ByteArray.any(): Boolean

fun ShortArray.any(): Boolean

fun IntArray.any(): Boolean

fun LongArray.any(): Boolean

fun FloatArray.any(): Boolean

fun DoubleArray.any(): Boolean

fun BooleanArray.any(): Boolean

fun CharArray.any(): Boolean

fun UIntArray.any(): Boolean

fun ULongArray.any(): Boolean

fun UByteArray.any(): Boolean

fun UShortArray.any(): Boolean

fun <T> Array<out T>.any(predicate: (T) -> Boolean): Boolean

fun ByteArray.any(predicate: (Byte) -> Boolean): Boolean

fun ShortArray.any(predicate: (Short) -> Boolean): Boolean

fun IntArray.any(predicate: (Int) -> Boolean): Boolean

fun LongArray.any(predicate: (Long) -> Boolean): Boolean

fun FloatArray.any(predicate: (Float) -> Boolean): Boolean

fun DoubleArray.any(predicate: (Double) -> Boolean): Boolean

fun BooleanArray.any(
    predicate: (Boolean) -> Boolean
): Boolean

fun CharArray.any(predicate: (Char) -> Boolean): Boolean

fun <T> Iterable<T>.any(predicate: (T) -> Boolean): Boolean

fun UIntArray.any(predicate: (UInt) -> Boolean): Boolean

fun ULongArray.any(predicate: (ULong) -> Boolean): Boolean

fun UByteArray.any(predicate: (UByte) -> Boolean): Boolean

fun UShortArray.any(predicate: (UShort) -> Boolean): Boolean

fun <T> Iterable<T>.any(): Boolean

fun <K, V> Map<out K, V>.any(): Boolean

fun <K, V> Map<out K, V>.any(
    predicate: (Entry<K, V>) -> Boolean
): Boolean

fun <T> arrayListOf(): ArrayList<T>

fun <T> arrayListOf(vararg elements: T): ArrayList<T>

fun UByteArray.asByteArray(): ByteArray

fun UIntArray.asIntArray(): IntArray

fun <T> any_array<T>.asIterable(): Iterable<T>

fun <T> Iterable<T>.asIterable(): Iterable<T>

fun <K, V> Map<out K, V>.asIterable(): Iterable<Entry<K, V>>

fun <T> List<T>.asReversed(): List<T>

fun <T> MutableList<T>.asReversed(): MutableList<T>

fun <T> any_array<T>.asSequence(): Sequence<T>

fun <T> Iterable<T>.asSequence(): Sequence<T>

fun <K, V> Map<out K, V>.asSequence(): Sequence<Entry<K, V>>

fun UShortArray.asShortArray(): ShortArray

fun <T, K, V> any_array<T>.associate(
    transform: (T) -> Pair<K, V>
): Map<K, V>

fun <T, K, V> Iterable<T>.associate(
    transform: (T) -> Pair<K, V>
): Map<K, V>

fun <T, K> any_array<T>.associateBy(
    keySelector: (T) -> K
): Map<K, T>

fun <T, K, V> any_array<T>.associateBy(
    keySelector: (T) -> K, 
    valueTransform: (T) -> V
): Map<K, V>

fun <T, K> Iterable<T>.associateBy(
    keySelector: (T) -> K
): Map<K, T>

fun <T, K, V> Iterable<T>.associateBy(
    keySelector: (T) -> K, 
    valueTransform: (T) -> V
): Map<K, V>

fun <T, K, M : MutableMap<in K, in T>> any_array<T>.associateByTo(
    destination: M, 
    keySelector: (T) -> K
): M

fun <T, K, V, M : MutableMap<in K, in V>> any_array<T>.associateByTo(
    destination: M, 
    keySelector: (T) -> K, 
    valueTransform: (T) -> V
): M

fun <T, K, M : MutableMap<in K, in T>> Iterable<T>.associateByTo(
    destination: M, 
    keySelector: (T) -> K
): M

fun <T, K, V, M : MutableMap<in K, in V>> Iterable<T>.associateByTo(
    destination: M, 
    keySelector: (T) -> K, 
    valueTransform: (T) -> V
): M

fun <T, K, V, M : MutableMap<in K, in V>> any_array<T>.associateTo(
    destination: M, 
    transform: (T) -> Pair<K, V>
): M

fun <T, K, V, M : MutableMap<in K, in V>> Iterable<T>.associateTo(
    destination: M, 
    transform: (T) -> Pair<K, V>
): M

fun <K, V> Array<out K>.associateWith(
    valueSelector: (K) -> V
): Map<K, V>

fun <V> ByteArray.associateWith(
    valueSelector: (Byte) -> V
): Map<Byte, V>

fun <V> ShortArray.associateWith(
    valueSelector: (Short) -> V
): Map<Short, V>

fun <V> IntArray.associateWith(
    valueSelector: (Int) -> V
): Map<Int, V>

fun <V> LongArray.associateWith(
    valueSelector: (Long) -> V
): Map<Long, V>

fun <V> FloatArray.associateWith(
    valueSelector: (Float) -> V
): Map<Float, V>

fun <V> DoubleArray.associateWith(
    valueSelector: (Double) -> V
): Map<Double, V>

fun <V> BooleanArray.associateWith(
    valueSelector: (Boolean) -> V
): Map<Boolean, V>

fun <V> CharArray.associateWith(
    valueSelector: (Char) -> V
): Map<Char, V>

fun <V> UIntArray.associateWith(
    valueSelector: (UInt) -> V
): Map<UInt, V>

fun <V> ULongArray.associateWith(
    valueSelector: (ULong) -> V
): Map<ULong, V>

fun <V> UByteArray.associateWith(
    valueSelector: (UByte) -> V
): Map<UByte, V>

fun <V> UShortArray.associateWith(
    valueSelector: (UShort) -> V
): Map<UShort, V>

fun <K, V> Iterable<K>.associateWith(
    valueSelector: (K) -> V
): Map<K, V>

fun <K, V, M : MutableMap<in K, in V>> Array<out K>.associateWithTo(
    destination: M, 
    valueSelector: (K) -> V
): M

fun <V, M : MutableMap<in Byte, in V>> ByteArray.associateWithTo(
    destination: M, 
    valueSelector: (Byte) -> V
): M

fun <V, M : MutableMap<in Short, in V>> ShortArray.associateWithTo(
    destination: M, 
    valueSelector: (Short) -> V
): M

fun <V, M : MutableMap<in Int, in V>> IntArray.associateWithTo(
    destination: M, 
    valueSelector: (Int) -> V
): M

fun <V, M : MutableMap<in Long, in V>> LongArray.associateWithTo(
    destination: M, 
    valueSelector: (Long) -> V
): M

fun <V, M : MutableMap<in Float, in V>> FloatArray.associateWithTo(
    destination: M, 
    valueSelector: (Float) -> V
): M

fun <V, M : MutableMap<in Double, in V>> DoubleArray.associateWithTo(
    destination: M, 
    valueSelector: (Double) -> V
): M

fun <V, M : MutableMap<in Boolean, in V>> BooleanArray.associateWithTo(
    destination: M, 
    valueSelector: (Boolean) -> V
): M

fun <V, M : MutableMap<in Char, in V>> CharArray.associateWithTo(
    destination: M, 
    valueSelector: (Char) -> V
): M

fun <V, M : MutableMap<in UInt, in V>> UIntArray.associateWithTo(
    destination: M, 
    valueSelector: (UInt) -> V
): M

fun <V, M : MutableMap<in ULong, in V>> ULongArray.associateWithTo(
    destination: M, 
    valueSelector: (ULong) -> V
): M

fun <V, M : MutableMap<in UByte, in V>> UByteArray.associateWithTo(
    destination: M, 
    valueSelector: (UByte) -> V
): M

fun <V, M : MutableMap<in UShort, in V>> UShortArray.associateWithTo(
    destination: M, 
    valueSelector: (UShort) -> V
): M

fun <K, V, M : MutableMap<in K, in V>> Iterable<K>.associateWithTo(
    destination: M, 
    valueSelector: (K) -> V
): M

fun ByteArray.asUByteArray(): UByteArray

fun IntArray.asUIntArray(): UIntArray

fun LongArray.asULongArray(): ULongArray

fun ShortArray.asUShortArray(): UShortArray

fun Array<out Byte>.average(): Double

fun Array<out Short>.average(): Double

fun Array<out Int>.average(): Double

fun Array<out Long>.average(): Double

fun Array<out Float>.average(): Double

fun Array<out Double>.average(): Double

fun ByteArray.average(): Double

fun ShortArray.average(): Double

fun IntArray.average(): Double

fun LongArray.average(): Double

fun FloatArray.average(): Double

fun DoubleArray.average(): Double

fun Iterable<Byte>.average(): Double

fun Iterable<Short>.average(): Double

fun Iterable<Int>.average(): Double

fun Iterable<Long>.average(): Double

fun Iterable<Float>.average(): Double

fun Iterable<Double>.average(): Double

fun <T : Comparable<T>> List<T?>.binarySearch(
    element: T?, 
    fromIndex: Int = 0, 
    toIndex: Int = size
): Int

fun <T> List<T>.binarySearch(
    element: T, 
    comparator: Comparator<in T>, 
    fromIndex: Int = 0, 
    toIndex: Int = size
): Int

fun <T> List<T>.binarySearch(
    fromIndex: Int = 0, 
    toIndex: Int = size, 
    comparison: (T) -> Int
): Int

fun <T> Array<out T>.binarySearch(
    element: T, 
    comparator: Comparator<in T>, 
    fromIndex: Int = 0, 
    toIndex: Int = size
): Int

fun <T> Array<out T>.binarySearch(
    element: T, 
    fromIndex: Int = 0, 
    toIndex: Int = size
): Int

fun ByteArray.binarySearch(
    element: Byte, 
    fromIndex: Int = 0, 
    toIndex: Int = size
): Int

fun ShortArray.binarySearch(
    element: Short, 
    fromIndex: Int = 0, 
    toIndex: Int = size
): Int

fun IntArray.binarySearch(
    element: Int, 
    fromIndex: Int = 0, 
    toIndex: Int = size
): Int

fun LongArray.binarySearch(
    element: Long, 
    fromIndex: Int = 0, 
    toIndex: Int = size
): Int

fun FloatArray.binarySearch(
    element: Float, 
    fromIndex: Int = 0, 
    toIndex: Int = size
): Int

fun DoubleArray.binarySearch(
    element: Double, 
    fromIndex: Int = 0, 
    toIndex: Int = size
): Int

fun CharArray.binarySearch(
    element: Char, 
    fromIndex: Int = 0, 
    toIndex: Int = size
): Int

fun UIntArray.binarySearch(
    element: UInt, 
    fromIndex: Int = 0, 
    toIndex: Int = size
): Int

fun ULongArray.binarySearch(
    element: ULong, 
    fromIndex: Int = 0, 
    toIndex: Int = size
): Int

fun UByteArray.binarySearch(
    element: UByte, 
    fromIndex: Int = 0, 
    toIndex: Int = size
): Int

fun UShortArray.binarySearch(
    element: UShort, 
    fromIndex: Int = 0, 
    toIndex: Int = size
): Int

fun <T, K : Comparable<K>> List<T>.binarySearchBy(
    key: K?, 
    fromIndex: Int = 0, 
    toIndex: Int = size, 
    selector: (T) -> K?
): Int

fun <E> buildList(
    builderAction: MutableList<E>.() -> Unit
): List<E>

fun <E> buildList(
    capacity: Int, 
    builderAction: MutableList<E>.() -> Unit
): List<E>

fun <K, V> buildMap(
    builderAction: MutableMap<K, V>.() -> Unit
): Map<K, V>

fun <K, V> buildMap(
    capacity: Int, 
    builderAction: MutableMap<K, V>.() -> Unit
): Map<K, V>

fun <E> buildSet(
    builderAction: MutableSet<E>.() -> Unit
): Set<E>

fun <E> buildSet(
    capacity: Int, 
    builderAction: MutableSet<E>.() -> Unit
): Set<E>

fun <T> Iterable<T>.chunked(size: Int): List<List<T>>

fun <T, R> Iterable<T>.chunked(
    size: Int, 
    transform: (List<T>) -> R
): List<R>

operator fun <T> Array<out T>.component1(): T

operator fun ByteArray.component1(): Byte

operator fun ShortArray.component1(): Short

operator fun IntArray.component1(): Int

operator fun LongArray.component1(): Long

operator fun FloatArray.component1(): Float

operator fun DoubleArray.component1(): Double

operator fun BooleanArray.component1(): Boolean

operator fun CharArray.component1(): Char

operator fun UIntArray.component1(): UInt

operator fun ULongArray.component1(): ULong

operator fun UByteArray.component1(): UByte

operator fun UShortArray.component1(): UShort

operator fun <T> List<T>.component1(): T

operator fun <K, V> Entry<K, V>.component1(): K

operator fun <T> Array<out T>.component2(): T

operator fun ByteArray.component2(): Byte

operator fun ShortArray.component2(): Short

operator fun IntArray.component2(): Int

operator fun LongArray.component2(): Long

operator fun FloatArray.component2(): Float

operator fun DoubleArray.component2(): Double

operator fun BooleanArray.component2(): Boolean

operator fun CharArray.component2(): Char

operator fun UIntArray.component2(): UInt

operator fun ULongArray.component2(): ULong

operator fun UByteArray.component2(): UByte

operator fun UShortArray.component2(): UShort

operator fun <T> List<T>.component2(): T

operator fun <K, V> Entry<K, V>.component2(): V

operator fun <T> Array<out T>.component3(): T

operator fun ByteArray.component3(): Byte

operator fun ShortArray.component3(): Short

operator fun IntArray.component3(): Int

operator fun LongArray.component3(): Long

operator fun FloatArray.component3(): Float

operator fun DoubleArray.component3(): Double

operator fun BooleanArray.component3(): Boolean

operator fun CharArray.component3(): Char

operator fun UIntArray.component3(): UInt

operator fun ULongArray.component3(): ULong

operator fun UByteArray.component3(): UByte

operator fun UShortArray.component3(): UShort

operator fun <T> List<T>.component3(): T

operator fun <T> Array<out T>.component4(): T

operator fun ByteArray.component4(): Byte

operator fun ShortArray.component4(): Short

operator fun IntArray.component4(): Int

operator fun LongArray.component4(): Long

operator fun FloatArray.component4(): Float

operator fun DoubleArray.component4(): Double

operator fun BooleanArray.component4(): Boolean

operator fun CharArray.component4(): Char

operator fun UIntArray.component4(): UInt

operator fun ULongArray.component4(): ULong

operator fun UByteArray.component4(): UByte

operator fun UShortArray.component4(): UShort

operator fun <T> List<T>.component4(): T

operator fun <T> Array<out T>.component5(): T

operator fun ByteArray.component5(): Byte

operator fun ShortArray.component5(): Short

operator fun IntArray.component5(): Int

operator fun LongArray.component5(): Long

operator fun FloatArray.component5(): Float

operator fun DoubleArray.component5(): Double

operator fun BooleanArray.component5(): Boolean

operator fun CharArray.component5(): Char

operator fun UIntArray.component5(): UInt

operator fun ULongArray.component5(): ULong

operator fun UByteArray.component5(): UByte

operator fun UShortArray.component5(): UShort

operator fun <T> List<T>.component5(): T

operator fun <T> any_array<T>.contains(element: T): Boolean

operator fun <T> Iterable<T>.contains(element: T): Boolean

operator fun <K, V> Map<out K, V>.contains(key: K): Boolean

fun <T> Collection<T>.containsAll(
    elements: Collection<T>
): Boolean

fun <K> Map<out K, *>.containsKey(key: K): Boolean

fun <K, V> Map<K, V>.containsValue(value: V): Boolean

infix fun <T> any_array<T>.contentDeepEquals(
    other: Array<out T>
): Boolean

fun <T> any_array<T>.contentDeepHashCode(): Int

fun <T> any_array<T>.contentDeepToString(): String

infix fun UIntArray.contentEquals(other: UIntArray): Boolean

infix fun ULongArray.contentEquals(
    other: ULongArray
): Boolean

infix fun UByteArray.contentEquals(
    other: UByteArray
): Boolean

infix fun UShortArray.contentEquals(
    other: UShortArray
): Boolean

infix fun UIntArray?.contentEquals(
    other: UIntArray?
): Boolean

infix fun ULongArray?.contentEquals(
    other: ULongArray?
): Boolean

infix fun UByteArray?.contentEquals(
    other: UByteArray?
): Boolean

infix fun UShortArray?.contentEquals(
    other: UShortArray?
): Boolean

infix fun <T> Array<out T>.contentEquals(
    other: Array<out T>
): Boolean

infix fun ByteArray.contentEquals(other: ByteArray): Boolean

infix fun ShortArray.contentEquals(
    other: ShortArray
): Boolean

infix fun IntArray.contentEquals(other: IntArray): Boolean

infix fun LongArray.contentEquals(other: LongArray): Boolean

infix fun FloatArray.contentEquals(
    other: FloatArray
): Boolean

infix fun DoubleArray.contentEquals(
    other: DoubleArray
): Boolean

infix fun BooleanArray.contentEquals(
    other: BooleanArray
): Boolean

infix fun CharArray.contentEquals(other: CharArray): Boolean

infix fun <T> Array<out T>?.contentEquals(
    other: Array<out T>?
): Boolean

infix fun ByteArray?.contentEquals(
    other: ByteArray?
): Boolean

infix fun ShortArray?.contentEquals(
    other: ShortArray?
): Boolean

infix fun IntArray?.contentEquals(other: IntArray?): Boolean

infix fun LongArray?.contentEquals(
    other: LongArray?
): Boolean

infix fun FloatArray?.contentEquals(
    other: FloatArray?
): Boolean

infix fun DoubleArray?.contentEquals(
    other: DoubleArray?
): Boolean

infix fun BooleanArray?.contentEquals(
    other: BooleanArray?
): Boolean

infix fun CharArray?.contentEquals(
    other: CharArray?
): Boolean

fun UIntArray.contentHashCode(): Int

fun ULongArray.contentHashCode(): Int

fun UByteArray.contentHashCode(): Int

fun UShortArray.contentHashCode(): Int

fun UIntArray?.contentHashCode(): Int

fun ULongArray?.contentHashCode(): Int

fun UByteArray?.contentHashCode(): Int

fun UShortArray?.contentHashCode(): Int

fun <T> Array<out T>.contentHashCode(): Int

fun ByteArray.contentHashCode(): Int

fun ShortArray.contentHashCode(): Int

fun IntArray.contentHashCode(): Int

fun LongArray.contentHashCode(): Int

fun FloatArray.contentHashCode(): Int

fun DoubleArray.contentHashCode(): Int

fun BooleanArray.contentHashCode(): Int

fun CharArray.contentHashCode(): Int

fun <T> Array<out T>?.contentHashCode(): Int

fun ByteArray?.contentHashCode(): Int

fun ShortArray?.contentHashCode(): Int

fun IntArray?.contentHashCode(): Int

fun LongArray?.contentHashCode(): Int

fun FloatArray?.contentHashCode(): Int

fun DoubleArray?.contentHashCode(): Int

fun BooleanArray?.contentHashCode(): Int

fun CharArray?.contentHashCode(): Int

fun UIntArray.contentToString(): String

fun ULongArray.contentToString(): String

fun UByteArray.contentToString(): String

fun UShortArray.contentToString(): String

fun UIntArray?.contentToString(): String

fun ULongArray?.contentToString(): String

fun UByteArray?.contentToString(): String

fun UShortArray?.contentToString(): String

fun <T> Array<out T>.contentToString(): String

fun ByteArray.contentToString(): String

fun ShortArray.contentToString(): String

fun IntArray.contentToString(): String

fun LongArray.contentToString(): String

fun FloatArray.contentToString(): String

fun DoubleArray.contentToString(): String

fun BooleanArray.contentToString(): String

fun CharArray.contentToString(): String

fun <T> Array<out T>?.contentToString(): String

fun ByteArray?.contentToString(): String

fun ShortArray?.contentToString(): String

fun IntArray?.contentToString(): String

fun LongArray?.contentToString(): String

fun FloatArray?.contentToString(): String

fun DoubleArray?.contentToString(): String

fun BooleanArray?.contentToString(): String

fun CharArray?.contentToString(): String

fun UIntArray.copyInto(
    destination: UIntArray, 
    destinationOffset: Int = 0, 
    startIndex: Int = 0, 
    endIndex: Int = size
): UIntArray

fun ULongArray.copyInto(
    destination: ULongArray, 
    destinationOffset: Int = 0, 
    startIndex: Int = 0, 
    endIndex: Int = size
): ULongArray

fun UByteArray.copyInto(
    destination: UByteArray, 
    destinationOffset: Int = 0, 
    startIndex: Int = 0, 
    endIndex: Int = size
): UByteArray

fun UShortArray.copyInto(
    destination: UShortArray, 
    destinationOffset: Int = 0, 
    startIndex: Int = 0, 
    endIndex: Int = size
): UShortArray

fun <T> Array<out T>.copyInto(
    destination: Array<T>, 
    destinationOffset: Int = 0, 
    startIndex: Int = 0, 
    endIndex: Int = size
): Array<T>

fun ByteArray.copyInto(
    destination: ByteArray, 
    destinationOffset: Int = 0, 
    startIndex: Int = 0, 
    endIndex: Int = size
): ByteArray

fun ShortArray.copyInto(
    destination: ShortArray, 
    destinationOffset: Int = 0, 
    startIndex: Int = 0, 
    endIndex: Int = size
): ShortArray

fun IntArray.copyInto(
    destination: IntArray, 
    destinationOffset: Int = 0, 
    startIndex: Int = 0, 
    endIndex: Int = size
): IntArray

fun LongArray.copyInto(
    destination: LongArray, 
    destinationOffset: Int = 0, 
    startIndex: Int = 0, 
    endIndex: Int = size
): LongArray

fun FloatArray.copyInto(
    destination: FloatArray, 
    destinationOffset: Int = 0, 
    startIndex: Int = 0, 
    endIndex: Int = size
): FloatArray

fun DoubleArray.copyInto(
    destination: DoubleArray, 
    destinationOffset: Int = 0, 
    startIndex: Int = 0, 
    endIndex: Int = size
): DoubleArray

fun BooleanArray.copyInto(
    destination: BooleanArray, 
    destinationOffset: Int = 0, 
    startIndex: Int = 0, 
    endIndex: Int = size
): BooleanArray

fun CharArray.copyInto(
    destination: CharArray, 
    destinationOffset: Int = 0, 
    startIndex: Int = 0, 
    endIndex: Int = size
): CharArray

fun UIntArray.copyOf(): UIntArray

fun ULongArray.copyOf(): ULongArray

fun UByteArray.copyOf(): UByteArray

fun UShortArray.copyOf(): UShortArray

fun <T> Array<T>.copyOf(): Array<T>

fun <T> Array<out T>.copyOf(): Array<T>

fun ByteArray.copyOf(): ByteArray

fun ShortArray.copyOf(): ShortArray

fun IntArray.copyOf(): IntArray

fun LongArray.copyOf(): LongArray

fun FloatArray.copyOf(): FloatArray

fun DoubleArray.copyOf(): DoubleArray

fun BooleanArray.copyOf(): BooleanArray

fun CharArray.copyOf(): CharArray

fun UIntArray.copyOf(newSize: Int): UIntArray

fun ULongArray.copyOf(newSize: Int): ULongArray

fun UByteArray.copyOf(newSize: Int): UByteArray

fun UShortArray.copyOf(newSize: Int): UShortArray

fun ByteArray.copyOf(newSize: Int): ByteArray

fun ShortArray.copyOf(newSize: Int): ShortArray

fun IntArray.copyOf(newSize: Int): IntArray

fun LongArray.copyOf(newSize: Int): LongArray

fun FloatArray.copyOf(newSize: Int): FloatArray

fun DoubleArray.copyOf(newSize: Int): DoubleArray

fun BooleanArray.copyOf(newSize: Int): BooleanArray

fun CharArray.copyOf(newSize: Int): CharArray

fun <T> any_array<T>.copyOf(newSize: Int): Array<T?>

fun UIntArray.copyOfRange(
    fromIndex: Int, 
    toIndex: Int
): UIntArray

fun ULongArray.copyOfRange(
    fromIndex: Int, 
    toIndex: Int
): ULongArray

fun UByteArray.copyOfRange(
    fromIndex: Int, 
    toIndex: Int
): UByteArray

fun UShortArray.copyOfRange(
    fromIndex: Int, 
    toIndex: Int
): UShortArray

fun <T> Array<T>.copyOfRange(
    fromIndex: Int, 
    toIndex: Int
): Array<T>

fun <T> Array<out T>.copyOfRange(
    fromIndex: Int, 
    toIndex: Int
): Array<T>

fun ByteArray.copyOfRange(
    fromIndex: Int, 
    toIndex: Int
): ByteArray

fun ShortArray.copyOfRange(
    fromIndex: Int, 
    toIndex: Int
): ShortArray

fun IntArray.copyOfRange(
    fromIndex: Int, 
    toIndex: Int
): IntArray

fun LongArray.copyOfRange(
    fromIndex: Int, 
    toIndex: Int
): LongArray

fun FloatArray.copyOfRange(
    fromIndex: Int, 
    toIndex: Int
): FloatArray

fun DoubleArray.copyOfRange(
    fromIndex: Int, 
    toIndex: Int
): DoubleArray

fun BooleanArray.copyOfRange(
    fromIndex: Int, 
    toIndex: Int
): BooleanArray

fun CharArray.copyOfRange(
    fromIndex: Int, 
    toIndex: Int
): CharArray

fun <T> any_array<T>.count(): Int

fun <T> Array<out T>.count(predicate: (T) -> Boolean): Int

fun ByteArray.count(predicate: (Byte) -> Boolean): Int

fun ShortArray.count(predicate: (Short) -> Boolean): Int

fun IntArray.count(predicate: (Int) -> Boolean): Int

fun LongArray.count(predicate: (Long) -> Boolean): Int

fun FloatArray.count(predicate: (Float) -> Boolean): Int

fun DoubleArray.count(predicate: (Double) -> Boolean): Int

fun BooleanArray.count(predicate: (Boolean) -> Boolean): Int

fun CharArray.count(predicate: (Char) -> Boolean): Int

fun <T> Iterable<T>.count(predicate: (T) -> Boolean): Int

fun UIntArray.count(predicate: (UInt) -> Boolean): Int

fun ULongArray.count(predicate: (ULong) -> Boolean): Int

fun UByteArray.count(predicate: (UByte) -> Boolean): Int

fun UShortArray.count(predicate: (UShort) -> Boolean): Int

fun <T> Iterable<T>.count(): Int

fun <T> Collection<T>.count(): Int

fun <K, V> Map<out K, V>.count(): Int

fun <K, V> Map<out K, V>.count(
    predicate: (Entry<K, V>) -> Boolean
): Int

fun <T> any_array<T>.distinct(): List<T>

fun <T> Iterable<T>.distinct(): List<T>

fun <T, K> any_array<T>.distinctBy(
    selector: (T) -> K
): List<T>

fun <T, K> Iterable<T>.distinctBy(
    selector: (T) -> K
): List<T>

fun <T> Array<out T>.drop(n: Int): List<T>

fun ByteArray.drop(n: Int): List<Byte>

fun ShortArray.drop(n: Int): List<Short>

fun IntArray.drop(n: Int): List<Int>

fun LongArray.drop(n: Int): List<Long>

fun FloatArray.drop(n: Int): List<Float>

fun DoubleArray.drop(n: Int): List<Double>

fun BooleanArray.drop(n: Int): List<Boolean>

fun CharArray.drop(n: Int): List<Char>

fun <T> Iterable<T>.drop(n: Int): List<T>

fun UIntArray.drop(n: Int): List<UInt>

fun ULongArray.drop(n: Int): List<ULong>

fun UByteArray.drop(n: Int): List<UByte>

fun UShortArray.drop(n: Int): List<UShort>

fun <T> Array<out T>.dropLast(n: Int): List<T>

fun ByteArray.dropLast(n: Int): List<Byte>

fun ShortArray.dropLast(n: Int): List<Short>

fun IntArray.dropLast(n: Int): List<Int>

fun LongArray.dropLast(n: Int): List<Long>

fun FloatArray.dropLast(n: Int): List<Float>

fun DoubleArray.dropLast(n: Int): List<Double>

fun BooleanArray.dropLast(n: Int): List<Boolean>

fun CharArray.dropLast(n: Int): List<Char>

fun <T> List<T>.dropLast(n: Int): List<T>

fun UIntArray.dropLast(n: Int): List<UInt>

fun ULongArray.dropLast(n: Int): List<ULong>

fun UByteArray.dropLast(n: Int): List<UByte>

fun UShortArray.dropLast(n: Int): List<UShort>

fun <T> Array<out T>.elementAtOrElse(
    index: Int, 
    defaultValue: (Int) -> T
): T

fun ByteArray.elementAtOrElse(
    index: Int, 
    defaultValue: (Int) -> Byte
): Byte

fun ShortArray.elementAtOrElse(
    index: Int, 
    defaultValue: (Int) -> Short
): Short

fun IntArray.elementAtOrElse(
    index: Int, 
    defaultValue: (Int) -> Int
): Int

fun LongArray.elementAtOrElse(
    index: Int, 
    defaultValue: (Int) -> Long
): Long

fun FloatArray.elementAtOrElse(
    index: Int, 
    defaultValue: (Int) -> Float
): Float

fun DoubleArray.elementAtOrElse(
    index: Int, 
    defaultValue: (Int) -> Double
): Double

fun BooleanArray.elementAtOrElse(
    index: Int, 
    defaultValue: (Int) -> Boolean
): Boolean

fun CharArray.elementAtOrElse(
    index: Int, 
    defaultValue: (Int) -> Char
): Char

fun UIntArray.elementAtOrElse(
    index: Int, 
    defaultValue: (Int) -> UInt
): UInt

fun ULongArray.elementAtOrElse(
    index: Int, 
    defaultValue: (Int) -> ULong
): ULong

fun UByteArray.elementAtOrElse(
    index: Int, 
    defaultValue: (Int) -> UByte
): UByte

fun UShortArray.elementAtOrElse(
    index: Int, 
    defaultValue: (Int) -> UShort
): UShort

fun <T> Iterable<T>.elementAtOrElse(
    index: Int, 
    defaultValue: (Int) -> T
): T

fun <T> List<T>.elementAtOrElse(
    index: Int, 
    defaultValue: (Int) -> T
): T

fun <T> Array<out T>.elementAtOrNull(index: Int): T?

fun ByteArray.elementAtOrNull(index: Int): Byte?

fun ShortArray.elementAtOrNull(index: Int): Short?

fun IntArray.elementAtOrNull(index: Int): Int?

fun LongArray.elementAtOrNull(index: Int): Long?

fun FloatArray.elementAtOrNull(index: Int): Float?

fun DoubleArray.elementAtOrNull(index: Int): Double?

fun BooleanArray.elementAtOrNull(index: Int): Boolean?

fun CharArray.elementAtOrNull(index: Int): Char?

fun UIntArray.elementAtOrNull(index: Int): UInt?

fun ULongArray.elementAtOrNull(index: Int): ULong?

fun UByteArray.elementAtOrNull(index: Int): UByte?

fun UShortArray.elementAtOrNull(index: Int): UShort?

fun <T> Iterable<T>.elementAtOrNull(index: Int): T?

fun <T> List<T>.elementAtOrNull(index: Int): T?

fun <T> emptyList(): List<T>

fun <K, V> emptyMap(): Map<K, V>

fun <T> emptySet(): Set<T>

fun UIntArray.fill(
    element: UInt, 
    fromIndex: Int = 0, 
    toIndex: Int = size)

fun ULongArray.fill(
    element: ULong, 
    fromIndex: Int = 0, 
    toIndex: Int = size)

fun UByteArray.fill(
    element: UByte, 
    fromIndex: Int = 0, 
    toIndex: Int = size)

fun UShortArray.fill(
    element: UShort, 
    fromIndex: Int = 0, 
    toIndex: Int = size)

fun <T> Array<T>.fill(
    element: T, 
    fromIndex: Int = 0, 
    toIndex: Int = size)

fun ByteArray.fill(
    element: Byte, 
    fromIndex: Int = 0, 
    toIndex: Int = size)

fun ShortArray.fill(
    element: Short, 
    fromIndex: Int = 0, 
    toIndex: Int = size)

fun IntArray.fill(
    element: Int, 
    fromIndex: Int = 0, 
    toIndex: Int = size)

fun LongArray.fill(
    element: Long, 
    fromIndex: Int = 0, 
    toIndex: Int = size)

fun FloatArray.fill(
    element: Float, 
    fromIndex: Int = 0, 
    toIndex: Int = size)

fun DoubleArray.fill(
    element: Double, 
    fromIndex: Int = 0, 
    toIndex: Int = size)

fun BooleanArray.fill(
    element: Boolean, 
    fromIndex: Int = 0, 
    toIndex: Int = size)

fun CharArray.fill(
    element: Char, 
    fromIndex: Int = 0, 
    toIndex: Int = size)

fun <T> MutableList<T>.fill(value: T)

fun <T> Array<out T>.filter(
    predicate: (T) -> Boolean
): List<T>

fun ByteArray.filter(
    predicate: (Byte) -> Boolean
): List<Byte>

fun ShortArray.filter(
    predicate: (Short) -> Boolean
): List<Short>

fun IntArray.filter(predicate: (Int) -> Boolean): List<Int>

fun LongArray.filter(
    predicate: (Long) -> Boolean
): List<Long>

fun FloatArray.filter(
    predicate: (Float) -> Boolean
): List<Float>

fun DoubleArray.filter(
    predicate: (Double) -> Boolean
): List<Double>

fun BooleanArray.filter(
    predicate: (Boolean) -> Boolean
): List<Boolean>

fun CharArray.filter(
    predicate: (Char) -> Boolean
): List<Char>

fun <T> Iterable<T>.filter(
    predicate: (T) -> Boolean
): List<T>

fun UIntArray.filter(
    predicate: (UInt) -> Boolean
): List<UInt>

fun ULongArray.filter(
    predicate: (ULong) -> Boolean
): List<ULong>

fun UByteArray.filter(
    predicate: (UByte) -> Boolean
): List<UByte>

fun UShortArray.filter(
    predicate: (UShort) -> Boolean
): List<UShort>

fun <K, V> Map<out K, V>.filter(
    predicate: (Entry<K, V>) -> Boolean
): Map<K, V>

fun <T> Array<out T>.filterIndexed(
    predicate: (index: Int, T) -> Boolean
): List<T>

fun ByteArray.filterIndexed(
    predicate: (index: Int, Byte) -> Boolean
): List<Byte>

fun ShortArray.filterIndexed(
    predicate: (index: Int, Short) -> Boolean
): List<Short>

fun IntArray.filterIndexed(
    predicate: (index: Int, Int) -> Boolean
): List<Int>

fun LongArray.filterIndexed(
    predicate: (index: Int, Long) -> Boolean
): List<Long>

fun FloatArray.filterIndexed(
    predicate: (index: Int, Float) -> Boolean
): List<Float>

fun DoubleArray.filterIndexed(
    predicate: (index: Int, Double) -> Boolean
): List<Double>

fun BooleanArray.filterIndexed(
    predicate: (index: Int, Boolean) -> Boolean
): List<Boolean>

fun CharArray.filterIndexed(
    predicate: (index: Int, Char) -> Boolean
): List<Char>

fun <T> Iterable<T>.filterIndexed(
    predicate: (index: Int, T) -> Boolean
): List<T>

fun UIntArray.filterIndexed(
    predicate: (index: Int, UInt) -> Boolean
): List<UInt>

fun ULongArray.filterIndexed(
    predicate: (index: Int, ULong) -> Boolean
): List<ULong>

fun UByteArray.filterIndexed(
    predicate: (index: Int, UByte) -> Boolean
): List<UByte>

fun UShortArray.filterIndexed(
    predicate: (index: Int, UShort) -> Boolean
): List<UShort>

fun <T, C : MutableCollection<in T>> Array<out T>.filterIndexedTo(
    destination: C, 
    predicate: (index: Int, T) -> Boolean
): C

fun <C : MutableCollection<in Byte>> ByteArray.filterIndexedTo(
    destination: C, 
    predicate: (index: Int, Byte) -> Boolean
): C

fun <C : MutableCollection<in Short>> ShortArray.filterIndexedTo(
    destination: C, 
    predicate: (index: Int, Short) -> Boolean
): C

fun <C : MutableCollection<in Int>> IntArray.filterIndexedTo(
    destination: C, 
    predicate: (index: Int, Int) -> Boolean
): C

fun <C : MutableCollection<in Long>> LongArray.filterIndexedTo(
    destination: C, 
    predicate: (index: Int, Long) -> Boolean
): C

fun <C : MutableCollection<in Float>> FloatArray.filterIndexedTo(
    destination: C, 
    predicate: (index: Int, Float) -> Boolean
): C

fun <C : MutableCollection<in Double>> DoubleArray.filterIndexedTo(
    destination: C, 
    predicate: (index: Int, Double) -> Boolean
): C

fun <C : MutableCollection<in Boolean>> BooleanArray.filterIndexedTo(
    destination: C, 
    predicate: (index: Int, Boolean) -> Boolean
): C

fun <C : MutableCollection<in Char>> CharArray.filterIndexedTo(
    destination: C, 
    predicate: (index: Int, Char) -> Boolean
): C

fun <T, C : MutableCollection<in T>> Iterable<T>.filterIndexedTo(
    destination: C, 
    predicate: (index: Int, T) -> Boolean
): C

fun <C : MutableCollection<in UInt>> UIntArray.filterIndexedTo(
    destination: C, 
    predicate: (index: Int, UInt) -> Boolean
): C

fun <C : MutableCollection<in ULong>> ULongArray.filterIndexedTo(
    destination: C, 
    predicate: (index: Int, ULong) -> Boolean
): C

fun <C : MutableCollection<in UByte>> UByteArray.filterIndexedTo(
    destination: C, 
    predicate: (index: Int, UByte) -> Boolean
): C

fun <C : MutableCollection<in UShort>> UShortArray.filterIndexedTo(
    destination: C, 
    predicate: (index: Int, UShort) -> Boolean
): C

fun <R> Array<*>.filterIsInstance(): List<R>

fun <R> Iterable<*>.filterIsInstance(): List<R>

fun <R> Array<*>.filterIsInstance(klass: Class<R>): List<R>

fun <R> Iterable<*>.filterIsInstance(
    klass: Class<R>
): List<R>

fun <R, C : MutableCollection<in R>> Array<*>.filterIsInstanceTo(
    destination: C
): C

fun <R, C : MutableCollection<in R>> Iterable<*>.filterIsInstanceTo(
    destination: C
): C

fun <C : MutableCollection<in R>, R> Array<*>.filterIsInstanceTo(
    destination: C, 
    klass: Class<R>
): C

fun <C : MutableCollection<in R>, R> Iterable<*>.filterIsInstanceTo(
    destination: C, 
    klass: Class<R>
): C

fun <K, V> Map<out K, V>.filterKeys(
    predicate: (K) -> Boolean
): Map<K, V>

fun <T> Array<out T>.filterNot(
    predicate: (T) -> Boolean
): List<T>

fun ByteArray.filterNot(
    predicate: (Byte) -> Boolean
): List<Byte>

fun ShortArray.filterNot(
    predicate: (Short) -> Boolean
): List<Short>

fun IntArray.filterNot(
    predicate: (Int) -> Boolean
): List<Int>

fun LongArray.filterNot(
    predicate: (Long) -> Boolean
): List<Long>

fun FloatArray.filterNot(
    predicate: (Float) -> Boolean
): List<Float>

fun DoubleArray.filterNot(
    predicate: (Double) -> Boolean
): List<Double>

fun BooleanArray.filterNot(
    predicate: (Boolean) -> Boolean
): List<Boolean>

fun CharArray.filterNot(
    predicate: (Char) -> Boolean
): List<Char>

fun <T> Iterable<T>.filterNot(
    predicate: (T) -> Boolean
): List<T>

fun UIntArray.filterNot(
    predicate: (UInt) -> Boolean
): List<UInt>

fun ULongArray.filterNot(
    predicate: (ULong) -> Boolean
): List<ULong>

fun UByteArray.filterNot(
    predicate: (UByte) -> Boolean
): List<UByte>

fun UShortArray.filterNot(
    predicate: (UShort) -> Boolean
): List<UShort>

fun <K, V> Map<out K, V>.filterNot(
    predicate: (Entry<K, V>) -> Boolean
): Map<K, V>

fun <T : Any> Array<out T?>.filterNotNull(): List<T>

fun <T : Any> Iterable<T?>.filterNotNull(): List<T>

fun <C : MutableCollection<in T>, T : Any> Array<out T?>.filterNotNullTo(
    destination: C
): C

fun <C : MutableCollection<in T>, T : Any> Iterable<T?>.filterNotNullTo(
    destination: C
): C

fun <T, C : MutableCollection<in T>> Array<out T>.filterNotTo(
    destination: C, 
    predicate: (T) -> Boolean
): C

fun <C : MutableCollection<in Byte>> ByteArray.filterNotTo(
    destination: C, 
    predicate: (Byte) -> Boolean
): C

fun <C : MutableCollection<in Short>> ShortArray.filterNotTo(
    destination: C, 
    predicate: (Short) -> Boolean
): C

fun <C : MutableCollection<in Int>> IntArray.filterNotTo(
    destination: C, 
    predicate: (Int) -> Boolean
): C

fun <C : MutableCollection<in Long>> LongArray.filterNotTo(
    destination: C, 
    predicate: (Long) -> Boolean
): C

fun <C : MutableCollection<in Float>> FloatArray.filterNotTo(
    destination: C, 
    predicate: (Float) -> Boolean
): C

fun <C : MutableCollection<in Double>> DoubleArray.filterNotTo(
    destination: C, 
    predicate: (Double) -> Boolean
): C

fun <C : MutableCollection<in Boolean>> BooleanArray.filterNotTo(
    destination: C, 
    predicate: (Boolean) -> Boolean
): C

fun <C : MutableCollection<in Char>> CharArray.filterNotTo(
    destination: C, 
    predicate: (Char) -> Boolean
): C

fun <C : MutableCollection<in UInt>> UIntArray.filterNotTo(
    destination: C, 
    predicate: (UInt) -> Boolean
): C

fun <C : MutableCollection<in ULong>> ULongArray.filterNotTo(
    destination: C, 
    predicate: (ULong) -> Boolean
): C

fun <C : MutableCollection<in UByte>> UByteArray.filterNotTo(
    destination: C, 
    predicate: (UByte) -> Boolean
): C

fun <C : MutableCollection<in UShort>> UShortArray.filterNotTo(
    destination: C, 
    predicate: (UShort) -> Boolean
): C

fun <K, V, M : MutableMap<in K, in V>> Map<out K, V>.filterNotTo(
    destination: M, 
    predicate: (Entry<K, V>) -> Boolean
): M

fun <T, C : MutableCollection<in T>> Array<out T>.filterTo(
    destination: C, 
    predicate: (T) -> Boolean
): C

fun <C : MutableCollection<in Byte>> ByteArray.filterTo(
    destination: C, 
    predicate: (Byte) -> Boolean
): C

fun <C : MutableCollection<in Short>> ShortArray.filterTo(
    destination: C, 
    predicate: (Short) -> Boolean
): C

fun <C : MutableCollection<in Int>> IntArray.filterTo(
    destination: C, 
    predicate: (Int) -> Boolean
): C

fun <C : MutableCollection<in Long>> LongArray.filterTo(
    destination: C, 
    predicate: (Long) -> Boolean
): C

fun <C : MutableCollection<in Float>> FloatArray.filterTo(
    destination: C, 
    predicate: (Float) -> Boolean
): C

fun <C : MutableCollection<in Double>> DoubleArray.filterTo(
    destination: C, 
    predicate: (Double) -> Boolean
): C

fun <C : MutableCollection<in Boolean>> BooleanArray.filterTo(
    destination: C, 
    predicate: (Boolean) -> Boolean
): C

fun <C : MutableCollection<in Char>> CharArray.filterTo(
    destination: C, 
    predicate: (Char) -> Boolean
): C

fun <T, C : MutableCollection<in T>> Iterable<T>.filterTo(
    destination: C, 
    predicate: (T) -> Boolean
): C

fun <C : MutableCollection<in UInt>> UIntArray.filterTo(
    destination: C, 
    predicate: (UInt) -> Boolean
): C

fun <C : MutableCollection<in ULong>> ULongArray.filterTo(
    destination: C, 
    predicate: (ULong) -> Boolean
): C

fun <C : MutableCollection<in UByte>> UByteArray.filterTo(
    destination: C, 
    predicate: (UByte) -> Boolean
): C

fun <C : MutableCollection<in UShort>> UShortArray.filterTo(
    destination: C, 
    predicate: (UShort) -> Boolean
): C

fun <K, V, M : MutableMap<in K, in V>> Map<out K, V>.filterTo(
    destination: M, 
    predicate: (Entry<K, V>) -> Boolean
): M

fun <T> Array<out T>.first(): T

fun ByteArray.first(): Byte

fun ShortArray.first(): Short

fun IntArray.first(): Int

fun LongArray.first(): Long

fun FloatArray.first(): Float

fun DoubleArray.first(): Double

fun BooleanArray.first(): Boolean

fun CharArray.first(): Char

fun <T> Iterable<T>.first(): T

fun <T> List<T>.first(): T

fun UIntArray.first(): UInt

fun ULongArray.first(): ULong

fun UByteArray.first(): UByte

fun UShortArray.first(): UShort

fun <T> Array<out T>.firstOrNull(): T?

fun ByteArray.firstOrNull(): Byte?

fun ShortArray.firstOrNull(): Short?

fun IntArray.firstOrNull(): Int?

fun LongArray.firstOrNull(): Long?

fun FloatArray.firstOrNull(): Float?

fun DoubleArray.firstOrNull(): Double?

fun BooleanArray.firstOrNull(): Boolean?

fun CharArray.firstOrNull(): Char?

fun UIntArray.firstOrNull(): UInt?

fun ULongArray.firstOrNull(): ULong?

fun UByteArray.firstOrNull(): UByte?

fun UShortArray.firstOrNull(): UShort?

fun <T> Array<out T>.firstOrNull(
    predicate: (T) -> Boolean
): T?

fun ByteArray.firstOrNull(
    predicate: (Byte) -> Boolean
): Byte?

fun ShortArray.firstOrNull(
    predicate: (Short) -> Boolean
): Short?

fun IntArray.firstOrNull(predicate: (Int) -> Boolean): Int?

fun LongArray.firstOrNull(
    predicate: (Long) -> Boolean
): Long?

fun FloatArray.firstOrNull(
    predicate: (Float) -> Boolean
): Float?

fun DoubleArray.firstOrNull(
    predicate: (Double) -> Boolean
): Double?

fun BooleanArray.firstOrNull(
    predicate: (Boolean) -> Boolean
): Boolean?

fun CharArray.firstOrNull(
    predicate: (Char) -> Boolean
): Char?

fun <T> Iterable<T>.firstOrNull(
    predicate: (T) -> Boolean
): T?

fun UIntArray.firstOrNull(
    predicate: (UInt) -> Boolean
): UInt?

fun ULongArray.firstOrNull(
    predicate: (ULong) -> Boolean
): ULong?

fun UByteArray.firstOrNull(
    predicate: (UByte) -> Boolean
): UByte?

fun UShortArray.firstOrNull(
    predicate: (UShort) -> Boolean
): UShort?

fun <T> Iterable<T>.firstOrNull(): T?

fun <T> List<T>.firstOrNull(): T?

fun <T, R> Array<out T>.flatMapIndexed(
    transform: (index: Int, T) -> Iterable<R>
): List<R>

fun <R> ByteArray.flatMapIndexed(
    transform: (index: Int, Byte) -> Iterable<R>
): List<R>

fun <R> ShortArray.flatMapIndexed(
    transform: (index: Int, Short) -> Iterable<R>
): List<R>

fun <R> IntArray.flatMapIndexed(
    transform: (index: Int, Int) -> Iterable<R>
): List<R>

fun <R> LongArray.flatMapIndexed(
    transform: (index: Int, Long) -> Iterable<R>
): List<R>

fun <R> FloatArray.flatMapIndexed(
    transform: (index: Int, Float) -> Iterable<R>
): List<R>

fun <R> DoubleArray.flatMapIndexed(
    transform: (index: Int, Double) -> Iterable<R>
): List<R>

fun <R> BooleanArray.flatMapIndexed(
    transform: (index: Int, Boolean) -> Iterable<R>
): List<R>

fun <R> CharArray.flatMapIndexed(
    transform: (index: Int, Char) -> Iterable<R>
): List<R>

fun <T, R> Array<out T>.flatMapIndexed(
    transform: (index: Int, T) -> Sequence<R>
): List<R>

fun <R> UIntArray.flatMapIndexed(
    transform: (index: Int, UInt) -> Iterable<R>
): List<R>

fun <R> ULongArray.flatMapIndexed(
    transform: (index: Int, ULong) -> Iterable<R>
): List<R>

fun <R> UByteArray.flatMapIndexed(
    transform: (index: Int, UByte) -> Iterable<R>
): List<R>

fun <R> UShortArray.flatMapIndexed(
    transform: (index: Int, UShort) -> Iterable<R>
): List<R>

fun <T, R> Iterable<T>.flatMapIndexed(
    transform: (index: Int, T) -> Iterable<R>
): List<R>

fun <T, R> Iterable<T>.flatMapIndexed(
    transform: (index: Int, T) -> Sequence<R>
): List<R>

fun <T, R, C : MutableCollection<in R>> Array<out T>.flatMapIndexedTo(
    destination: C, 
    transform: (index: Int, T) -> Iterable<R>
): C

fun <R, C : MutableCollection<in R>> ByteArray.flatMapIndexedTo(
    destination: C, 
    transform: (index: Int, Byte) -> Iterable<R>
): C

fun <R, C : MutableCollection<in R>> ShortArray.flatMapIndexedTo(
    destination: C, 
    transform: (index: Int, Short) -> Iterable<R>
): C

fun <R, C : MutableCollection<in R>> IntArray.flatMapIndexedTo(
    destination: C, 
    transform: (index: Int, Int) -> Iterable<R>
): C

fun <R, C : MutableCollection<in R>> LongArray.flatMapIndexedTo(
    destination: C, 
    transform: (index: Int, Long) -> Iterable<R>
): C

fun <R, C : MutableCollection<in R>> FloatArray.flatMapIndexedTo(
    destination: C, 
    transform: (index: Int, Float) -> Iterable<R>
): C

fun <R, C : MutableCollection<in R>> DoubleArray.flatMapIndexedTo(
    destination: C, 
    transform: (index: Int, Double) -> Iterable<R>
): C

fun <R, C : MutableCollection<in R>> BooleanArray.flatMapIndexedTo(
    destination: C, 
    transform: (index: Int, Boolean) -> Iterable<R>
): C

fun <R, C : MutableCollection<in R>> CharArray.flatMapIndexedTo(
    destination: C, 
    transform: (index: Int, Char) -> Iterable<R>
): C

fun <T, R, C : MutableCollection<in R>> Array<out T>.flatMapIndexedTo(
    destination: C, 
    transform: (index: Int, T) -> Sequence<R>
): C

fun <R, C : MutableCollection<in R>> UIntArray.flatMapIndexedTo(
    destination: C, 
    transform: (index: Int, UInt) -> Iterable<R>
): C

fun <R, C : MutableCollection<in R>> ULongArray.flatMapIndexedTo(
    destination: C, 
    transform: (index: Int, ULong) -> Iterable<R>
): C

fun <R, C : MutableCollection<in R>> UByteArray.flatMapIndexedTo(
    destination: C, 
    transform: (index: Int, UByte) -> Iterable<R>
): C

fun <R, C : MutableCollection<in R>> UShortArray.flatMapIndexedTo(
    destination: C, 
    transform: (index: Int, UShort) -> Iterable<R>
): C

fun <T, R, C : MutableCollection<in R>> Iterable<T>.flatMapIndexedTo(
    destination: C, 
    transform: (index: Int, T) -> Iterable<R>
): C

fun <T, R, C : MutableCollection<in R>> Iterable<T>.flatMapIndexedTo(
    destination: C, 
    transform: (index: Int, T) -> Sequence<R>
): C

fun <T, R, C : MutableCollection<in R>> Array<out T>.flatMapTo(
    destination: C, 
    transform: (T) -> Iterable<R>
): C

fun <R, C : MutableCollection<in R>> ByteArray.flatMapTo(
    destination: C, 
    transform: (Byte) -> Iterable<R>
): C

fun <R, C : MutableCollection<in R>> ShortArray.flatMapTo(
    destination: C, 
    transform: (Short) -> Iterable<R>
): C

fun <R, C : MutableCollection<in R>> IntArray.flatMapTo(
    destination: C, 
    transform: (Int) -> Iterable<R>
): C

fun <R, C : MutableCollection<in R>> LongArray.flatMapTo(
    destination: C, 
    transform: (Long) -> Iterable<R>
): C

fun <R, C : MutableCollection<in R>> FloatArray.flatMapTo(
    destination: C, 
    transform: (Float) -> Iterable<R>
): C

fun <R, C : MutableCollection<in R>> DoubleArray.flatMapTo(
    destination: C, 
    transform: (Double) -> Iterable<R>
): C

fun <R, C : MutableCollection<in R>> BooleanArray.flatMapTo(
    destination: C, 
    transform: (Boolean) -> Iterable<R>
): C

fun <R, C : MutableCollection<in R>> CharArray.flatMapTo(
    destination: C, 
    transform: (Char) -> Iterable<R>
): C

fun <T, R, C : MutableCollection<in R>> Array<out T>.flatMapTo(
    destination: C, 
    transform: (T) -> Sequence<R>
): C

fun <R, C : MutableCollection<in R>> UIntArray.flatMapTo(
    destination: C, 
    transform: (UInt) -> Iterable<R>
): C

fun <R, C : MutableCollection<in R>> ULongArray.flatMapTo(
    destination: C, 
    transform: (ULong) -> Iterable<R>
): C

fun <R, C : MutableCollection<in R>> UByteArray.flatMapTo(
    destination: C, 
    transform: (UByte) -> Iterable<R>
): C

fun <R, C : MutableCollection<in R>> UShortArray.flatMapTo(
    destination: C, 
    transform: (UShort) -> Iterable<R>
): C

fun <T, R, C : MutableCollection<in R>> Iterable<T>.flatMapTo(
    destination: C, 
    transform: (T) -> Iterable<R>
): C

fun <T, R, C : MutableCollection<in R>> Iterable<T>.flatMapTo(
    destination: C, 
    transform: (T) -> Sequence<R>
): C

fun <K, V, R, C : MutableCollection<in R>> Map<out K, V>.flatMapTo(
    destination: C, 
    transform: (Entry<K, V>) -> Iterable<R>
): C

fun <K, V, R, C : MutableCollection<in R>> Map<out K, V>.flatMapTo(
    destination: C, 
    transform: (Entry<K, V>) -> Sequence<R>
): C

fun <T> Array<out Array<out T>>.flatten(): List<T>

fun <T> Iterable<Iterable<T>>.flatten(): List<T>

fun <T, R> Array<out T>.fold(
    initial: R, 
    operation: (acc: R, T) -> R
): R

fun <R> ByteArray.fold(
    initial: R, 
    operation: (acc: R, Byte) -> R
): R

fun <R> ShortArray.fold(
    initial: R, 
    operation: (acc: R, Short) -> R
): R

fun <R> IntArray.fold(
    initial: R, 
    operation: (acc: R, Int) -> R
): R

fun <R> LongArray.fold(
    initial: R, 
    operation: (acc: R, Long) -> R
): R

fun <R> FloatArray.fold(
    initial: R, 
    operation: (acc: R, Float) -> R
): R

fun <R> DoubleArray.fold(
    initial: R, 
    operation: (acc: R, Double) -> R
): R

fun <R> BooleanArray.fold(
    initial: R, 
    operation: (acc: R, Boolean) -> R
): R

fun <R> CharArray.fold(
    initial: R, 
    operation: (acc: R, Char) -> R
): R

fun <T, R> Iterable<T>.fold(
    initial: R, 
    operation: (acc: R, T) -> R
): R

fun <R> UIntArray.fold(
    initial: R, 
    operation: (acc: R, UInt) -> R
): R

fun <R> ULongArray.fold(
    initial: R, 
    operation: (acc: R, ULong) -> R
): R

fun <R> UByteArray.fold(
    initial: R, 
    operation: (acc: R, UByte) -> R
): R

fun <R> UShortArray.fold(
    initial: R, 
    operation: (acc: R, UShort) -> R
): R

fun <T, K, R> Grouping<T, K>.fold(
    initialValueSelector: (key: K, element: T) -> R, 
    operation: (key: K, accumulator: R, element: T) -> R
): Map<K, R>

fun <T, K, R> Grouping<T, K>.fold(
    initialValue: R, 
    operation: (accumulator: R, element: T) -> R
): Map<K, R>

fun <T, R> Array<out T>.foldIndexed(
    initial: R, 
    operation: (index: Int, acc: R, T) -> R
): R

fun <R> ByteArray.foldIndexed(
    initial: R, 
    operation: (index: Int, acc: R, Byte) -> R
): R

fun <R> ShortArray.foldIndexed(
    initial: R, 
    operation: (index: Int, acc: R, Short) -> R
): R

fun <R> IntArray.foldIndexed(
    initial: R, 
    operation: (index: Int, acc: R, Int) -> R
): R

fun <R> LongArray.foldIndexed(
    initial: R, 
    operation: (index: Int, acc: R, Long) -> R
): R

fun <R> FloatArray.foldIndexed(
    initial: R, 
    operation: (index: Int, acc: R, Float) -> R
): R

fun <R> DoubleArray.foldIndexed(
    initial: R, 
    operation: (index: Int, acc: R, Double) -> R
): R

fun <R> BooleanArray.foldIndexed(
    initial: R, 
    operation: (index: Int, acc: R, Boolean) -> R
): R

fun <R> CharArray.foldIndexed(
    initial: R, 
    operation: (index: Int, acc: R, Char) -> R
): R

fun <R> UIntArray.foldIndexed(
    initial: R, 
    operation: (index: Int, acc: R, UInt) -> R
): R

fun <R> ULongArray.foldIndexed(
    initial: R, 
    operation: (index: Int, acc: R, ULong) -> R
): R

fun <R> UByteArray.foldIndexed(
    initial: R, 
    operation: (index: Int, acc: R, UByte) -> R
): R

fun <R> UShortArray.foldIndexed(
    initial: R, 
    operation: (index: Int, acc: R, UShort) -> R
): R

fun <T, R> Iterable<T>.foldIndexed(
    initial: R, 
    operation: (index: Int, acc: R, T) -> R
): R

fun <T, R> Array<out T>.foldRight(
    initial: R, 
    operation: (T, acc: R) -> R
): R

fun <R> ByteArray.foldRight(
    initial: R, 
    operation: (Byte, acc: R) -> R
): R

fun <R> ShortArray.foldRight(
    initial: R, 
    operation: (Short, acc: R) -> R
): R

fun <R> IntArray.foldRight(
    initial: R, 
    operation: (Int, acc: R) -> R
): R

fun <R> LongArray.foldRight(
    initial: R, 
    operation: (Long, acc: R) -> R
): R

fun <R> FloatArray.foldRight(
    initial: R, 
    operation: (Float, acc: R) -> R
): R

fun <R> DoubleArray.foldRight(
    initial: R, 
    operation: (Double, acc: R) -> R
): R

fun <R> BooleanArray.foldRight(
    initial: R, 
    operation: (Boolean, acc: R) -> R
): R

fun <R> CharArray.foldRight(
    initial: R, 
    operation: (Char, acc: R) -> R
): R

fun <T, R> List<T>.foldRight(
    initial: R, 
    operation: (T, acc: R) -> R
): R

fun <R> UIntArray.foldRight(
    initial: R, 
    operation: (UInt, acc: R) -> R
): R

fun <R> ULongArray.foldRight(
    initial: R, 
    operation: (ULong, acc: R) -> R
): R

fun <R> UByteArray.foldRight(
    initial: R, 
    operation: (UByte, acc: R) -> R
): R

fun <R> UShortArray.foldRight(
    initial: R, 
    operation: (UShort, acc: R) -> R
): R

fun <T, R> Array<out T>.foldRightIndexed(
    initial: R, 
    operation: (index: Int, T, acc: R) -> R
): R

fun <R> ByteArray.foldRightIndexed(
    initial: R, 
    operation: (index: Int, Byte, acc: R) -> R
): R

fun <R> ShortArray.foldRightIndexed(
    initial: R, 
    operation: (index: Int, Short, acc: R) -> R
): R

fun <R> IntArray.foldRightIndexed(
    initial: R, 
    operation: (index: Int, Int, acc: R) -> R
): R

fun <R> LongArray.foldRightIndexed(
    initial: R, 
    operation: (index: Int, Long, acc: R) -> R
): R

fun <R> FloatArray.foldRightIndexed(
    initial: R, 
    operation: (index: Int, Float, acc: R) -> R
): R

fun <R> DoubleArray.foldRightIndexed(
    initial: R, 
    operation: (index: Int, Double, acc: R) -> R
): R

fun <R> BooleanArray.foldRightIndexed(
    initial: R, 
    operation: (index: Int, Boolean, acc: R) -> R
): R

fun <R> CharArray.foldRightIndexed(
    initial: R, 
    operation: (index: Int, Char, acc: R) -> R
): R

fun <R> UIntArray.foldRightIndexed(
    initial: R, 
    operation: (index: Int, UInt, acc: R) -> R
): R

fun <R> ULongArray.foldRightIndexed(
    initial: R, 
    operation: (index: Int, ULong, acc: R) -> R
): R

fun <R> UByteArray.foldRightIndexed(
    initial: R, 
    operation: (index: Int, UByte, acc: R) -> R
): R

fun <R> UShortArray.foldRightIndexed(
    initial: R, 
    operation: (index: Int, UShort, acc: R) -> R
): R

fun <T, R> List<T>.foldRightIndexed(
    initial: R, 
    operation: (index: Int, T, acc: R) -> R
): R

fun <T, K, R, M : MutableMap<in K, R>> Grouping<T, K>.foldTo(
    destination: M, 
    initialValueSelector: (key: K, element: T) -> R, 
    operation: (key: K, accumulator: R, element: T) -> R
): M

fun <T, K, R, M : MutableMap<in K, R>> Grouping<T, K>.foldTo(
    destination: M, 
    initialValue: R, 
    operation: (accumulator: R, element: T) -> R
): M

fun <T> Array<out T>.forEach(action: (T) -> Unit)

fun ByteArray.forEach(action: (Byte) -> Unit)

fun ShortArray.forEach(action: (Short) -> Unit)

fun IntArray.forEach(action: (Int) -> Unit)

fun LongArray.forEach(action: (Long) -> Unit)

fun FloatArray.forEach(action: (Float) -> Unit)

fun DoubleArray.forEach(action: (Double) -> Unit)

fun BooleanArray.forEach(action: (Boolean) -> Unit)

fun CharArray.forEach(action: (Char) -> Unit)

fun <T> Iterable<T>.forEach(action: (T) -> Unit)

fun UIntArray.forEach(action: (UInt) -> Unit)

fun ULongArray.forEach(action: (ULong) -> Unit)

fun UByteArray.forEach(action: (UByte) -> Unit)

fun UShortArray.forEach(action: (UShort) -> Unit)

fun <K, V> Map<out K, V>.forEach(
    action: (Entry<K, V>) -> Unit)

fun <T> Iterator<T>.forEach(operation: (T) -> Unit)

fun <T> Array<out T>.forEachIndexed(
    action: (index: Int, T) -> Unit)

fun ByteArray.forEachIndexed(
    action: (index: Int, Byte) -> Unit)

fun ShortArray.forEachIndexed(
    action: (index: Int, Short) -> Unit)

fun IntArray.forEachIndexed(
    action: (index: Int, Int) -> Unit)

fun LongArray.forEachIndexed(
    action: (index: Int, Long) -> Unit)

fun FloatArray.forEachIndexed(
    action: (index: Int, Float) -> Unit)

fun DoubleArray.forEachIndexed(
    action: (index: Int, Double) -> Unit)

fun BooleanArray.forEachIndexed(
    action: (index: Int, Boolean) -> Unit)

fun CharArray.forEachIndexed(
    action: (index: Int, Char) -> Unit)

fun <T> Iterable<T>.forEachIndexed(
    action: (index: Int, T) -> Unit)

fun UIntArray.forEachIndexed(
    action: (index: Int, UInt) -> Unit)

fun ULongArray.forEachIndexed(
    action: (index: Int, ULong) -> Unit)

fun UByteArray.forEachIndexed(
    action: (index: Int, UByte) -> Unit)

fun UShortArray.forEachIndexed(
    action: (index: Int, UShort) -> Unit)

operator fun <K, V> Map<out K, V>.get(key: K): V?

fun <K, V> Map<out K, V>.getOrDefault(
    key: K, 
    defaultValue: V
): V

fun <T> Array<out T>.getOrElse(
    index: Int, 
    defaultValue: (Int) -> T
): T

fun ByteArray.getOrElse(
    index: Int, 
    defaultValue: (Int) -> Byte
): Byte

fun ShortArray.getOrElse(
    index: Int, 
    defaultValue: (Int) -> Short
): Short

fun IntArray.getOrElse(
    index: Int, 
    defaultValue: (Int) -> Int
): Int

fun LongArray.getOrElse(
    index: Int, 
    defaultValue: (Int) -> Long
): Long

fun FloatArray.getOrElse(
    index: Int, 
    defaultValue: (Int) -> Float
): Float

fun DoubleArray.getOrElse(
    index: Int, 
    defaultValue: (Int) -> Double
): Double

fun BooleanArray.getOrElse(
    index: Int, 
    defaultValue: (Int) -> Boolean
): Boolean

fun CharArray.getOrElse(
    index: Int, 
    defaultValue: (Int) -> Char
): Char

fun UIntArray.getOrElse(
    index: Int, 
    defaultValue: (Int) -> UInt
): UInt

fun ULongArray.getOrElse(
    index: Int, 
    defaultValue: (Int) -> ULong
): ULong

fun UByteArray.getOrElse(
    index: Int, 
    defaultValue: (Int) -> UByte
): UByte

fun UShortArray.getOrElse(
    index: Int, 
    defaultValue: (Int) -> UShort
): UShort

fun <T> List<T>.getOrElse(
    index: Int, 
    defaultValue: (Int) -> T
): T

fun <K, V> Map<K, V>.getOrElse(
    key: K, 
    defaultValue: () -> V
): V

fun <T> Array<out T>.getOrNull(index: Int): T?

fun ByteArray.getOrNull(index: Int): Byte?

fun ShortArray.getOrNull(index: Int): Short?

fun IntArray.getOrNull(index: Int): Int?

fun LongArray.getOrNull(index: Int): Long?

fun FloatArray.getOrNull(index: Int): Float?

fun DoubleArray.getOrNull(index: Int): Double?

fun BooleanArray.getOrNull(index: Int): Boolean?

fun CharArray.getOrNull(index: Int): Char?

fun UIntArray.getOrNull(index: Int): UInt?

fun ULongArray.getOrNull(index: Int): ULong?

fun UByteArray.getOrNull(index: Int): UByte?

fun UShortArray.getOrNull(index: Int): UShort?

fun <T> List<T>.getOrNull(index: Int): T?

fun <T, K> Array<out T>.groupBy(
    keySelector: (T) -> K
): Map<K, List<T>>

fun <K> ByteArray.groupBy(
    keySelector: (Byte) -> K
): Map<K, List<Byte>>

fun <K> ShortArray.groupBy(
    keySelector: (Short) -> K
): Map<K, List<Short>>

fun <K> IntArray.groupBy(
    keySelector: (Int) -> K
): Map<K, List<Int>>

fun <K> LongArray.groupBy(
    keySelector: (Long) -> K
): Map<K, List<Long>>

fun <K> FloatArray.groupBy(
    keySelector: (Float) -> K
): Map<K, List<Float>>

fun <K> DoubleArray.groupBy(
    keySelector: (Double) -> K
): Map<K, List<Double>>

fun <K> BooleanArray.groupBy(
    keySelector: (Boolean) -> K
): Map<K, List<Boolean>>

fun <K> CharArray.groupBy(
    keySelector: (Char) -> K
): Map<K, List<Char>>

fun <K> UIntArray.groupBy(
    keySelector: (UInt) -> K
): Map<K, List<UInt>>

fun <K> ULongArray.groupBy(
    keySelector: (ULong) -> K
): Map<K, List<ULong>>

fun <K> UByteArray.groupBy(
    keySelector: (UByte) -> K
): Map<K, List<UByte>>

fun <K> UShortArray.groupBy(
    keySelector: (UShort) -> K
): Map<K, List<UShort>>

fun <T, K, V> Array<out T>.groupBy(
    keySelector: (T) -> K, 
    valueTransform: (T) -> V
): Map<K, List<V>>

fun <K, V> ByteArray.groupBy(
    keySelector: (Byte) -> K, 
    valueTransform: (Byte) -> V
): Map<K, List<V>>

fun <K, V> ShortArray.groupBy(
    keySelector: (Short) -> K, 
    valueTransform: (Short) -> V
): Map<K, List<V>>

fun <K, V> IntArray.groupBy(
    keySelector: (Int) -> K, 
    valueTransform: (Int) -> V
): Map<K, List<V>>

fun <K, V> LongArray.groupBy(
    keySelector: (Long) -> K, 
    valueTransform: (Long) -> V
): Map<K, List<V>>

fun <K, V> FloatArray.groupBy(
    keySelector: (Float) -> K, 
    valueTransform: (Float) -> V
): Map<K, List<V>>

fun <K, V> DoubleArray.groupBy(
    keySelector: (Double) -> K, 
    valueTransform: (Double) -> V
): Map<K, List<V>>

fun <K, V> BooleanArray.groupBy(
    keySelector: (Boolean) -> K, 
    valueTransform: (Boolean) -> V
): Map<K, List<V>>

fun <K, V> CharArray.groupBy(
    keySelector: (Char) -> K, 
    valueTransform: (Char) -> V
): Map<K, List<V>>

fun <K, V> UIntArray.groupBy(
    keySelector: (UInt) -> K, 
    valueTransform: (UInt) -> V
): Map<K, List<V>>

fun <K, V> ULongArray.groupBy(
    keySelector: (ULong) -> K, 
    valueTransform: (ULong) -> V
): Map<K, List<V>>

fun <K, V> UByteArray.groupBy(
    keySelector: (UByte) -> K, 
    valueTransform: (UByte) -> V
): Map<K, List<V>>

fun <K, V> UShortArray.groupBy(
    keySelector: (UShort) -> K, 
    valueTransform: (UShort) -> V
): Map<K, List<V>>

fun <T, K> Iterable<T>.groupBy(
    keySelector: (T) -> K
): Map<K, List<T>>

fun <T, K, V> Iterable<T>.groupBy(
    keySelector: (T) -> K, 
    valueTransform: (T) -> V
): Map<K, List<V>>

fun <T, K, M : MutableMap<in K, MutableList<T>>> Array<out T>.groupByTo(
    destination: M, 
    keySelector: (T) -> K
): M

fun <K, M : MutableMap<in K, MutableList<Byte>>> ByteArray.groupByTo(
    destination: M, 
    keySelector: (Byte) -> K
): M

fun <K, M : MutableMap<in K, MutableList<Short>>> ShortArray.groupByTo(
    destination: M, 
    keySelector: (Short) -> K
): M

fun <K, M : MutableMap<in K, MutableList<Int>>> IntArray.groupByTo(
    destination: M, 
    keySelector: (Int) -> K
): M

fun <K, M : MutableMap<in K, MutableList<Long>>> LongArray.groupByTo(
    destination: M, 
    keySelector: (Long) -> K
): M

fun <K, M : MutableMap<in K, MutableList<Float>>> FloatArray.groupByTo(
    destination: M, 
    keySelector: (Float) -> K
): M

fun <K, M : MutableMap<in K, MutableList<Double>>> DoubleArray.groupByTo(
    destination: M, 
    keySelector: (Double) -> K
): M

fun <K, M : MutableMap<in K, MutableList<Boolean>>> BooleanArray.groupByTo(
    destination: M, 
    keySelector: (Boolean) -> K
): M

fun <K, M : MutableMap<in K, MutableList<Char>>> CharArray.groupByTo(
    destination: M, 
    keySelector: (Char) -> K
): M

fun <K, M : MutableMap<in K, MutableList<UInt>>> UIntArray.groupByTo(
    destination: M, 
    keySelector: (UInt) -> K
): M

fun <K, M : MutableMap<in K, MutableList<ULong>>> ULongArray.groupByTo(
    destination: M, 
    keySelector: (ULong) -> K
): M

fun <K, M : MutableMap<in K, MutableList<UByte>>> UByteArray.groupByTo(
    destination: M, 
    keySelector: (UByte) -> K
): M

fun <K, M : MutableMap<in K, MutableList<UShort>>> UShortArray.groupByTo(
    destination: M, 
    keySelector: (UShort) -> K
): M

fun <T, K, V, M : MutableMap<in K, MutableList<V>>> Array<out T>.groupByTo(
    destination: M, 
    keySelector: (T) -> K, 
    valueTransform: (T) -> V
): M

fun <K, V, M : MutableMap<in K, MutableList<V>>> ByteArray.groupByTo(
    destination: M, 
    keySelector: (Byte) -> K, 
    valueTransform: (Byte) -> V
): M

fun <K, V, M : MutableMap<in K, MutableList<V>>> ShortArray.groupByTo(
    destination: M, 
    keySelector: (Short) -> K, 
    valueTransform: (Short) -> V
): M

fun <K, V, M : MutableMap<in K, MutableList<V>>> IntArray.groupByTo(
    destination: M, 
    keySelector: (Int) -> K, 
    valueTransform: (Int) -> V
): M

fun <K, V, M : MutableMap<in K, MutableList<V>>> LongArray.groupByTo(
    destination: M, 
    keySelector: (Long) -> K, 
    valueTransform: (Long) -> V
): M

fun <K, V, M : MutableMap<in K, MutableList<V>>> FloatArray.groupByTo(
    destination: M, 
    keySelector: (Float) -> K, 
    valueTransform: (Float) -> V
): M

fun <K, V, M : MutableMap<in K, MutableList<V>>> DoubleArray.groupByTo(
    destination: M, 
    keySelector: (Double) -> K, 
    valueTransform: (Double) -> V
): M

fun <K, V, M : MutableMap<in K, MutableList<V>>> BooleanArray.groupByTo(
    destination: M, 
    keySelector: (Boolean) -> K, 
    valueTransform: (Boolean) -> V
): M

fun <K, V, M : MutableMap<in K, MutableList<V>>> CharArray.groupByTo(
    destination: M, 
    keySelector: (Char) -> K, 
    valueTransform: (Char) -> V
): M

fun <K, V, M : MutableMap<in K, MutableList<V>>> UIntArray.groupByTo(
    destination: M, 
    keySelector: (UInt) -> K, 
    valueTransform: (UInt) -> V
): M

fun <K, V, M : MutableMap<in K, MutableList<V>>> ULongArray.groupByTo(
    destination: M, 
    keySelector: (ULong) -> K, 
    valueTransform: (ULong) -> V
): M

fun <K, V, M : MutableMap<in K, MutableList<V>>> UByteArray.groupByTo(
    destination: M, 
    keySelector: (UByte) -> K, 
    valueTransform: (UByte) -> V
): M

fun <K, V, M : MutableMap<in K, MutableList<V>>> UShortArray.groupByTo(
    destination: M, 
    keySelector: (UShort) -> K, 
    valueTransform: (UShort) -> V
): M

fun <T, K, M : MutableMap<in K, MutableList<T>>> Iterable<T>.groupByTo(
    destination: M, 
    keySelector: (T) -> K
): M

fun <T, K, V, M : MutableMap<in K, MutableList<V>>> Iterable<T>.groupByTo(
    destination: M, 
    keySelector: (T) -> K, 
    valueTransform: (T) -> V
): M

fun <T, K> Array<out T>.groupingBy(
    keySelector: (T) -> K
): Grouping<T, K>

fun <T, K> Iterable<T>.groupingBy(
    keySelector: (T) -> K
): Grouping<T, K>

fun <K, V> hashMapOf(): HashMap<K, V>

fun <K, V> hashMapOf(vararg pairs: Pair<K, V>): HashMap<K, V>

fun <T> hashSetOf(): HashSet<T>

fun <T> hashSetOf(vararg elements: T): HashSet<T>

fun <C, R> C.ifEmpty(
    defaultValue: () -> R
): R where C : Array<*>, C : R

fun <M, R> M.ifEmpty(
    defaultValue: () -> R
): R where M : Map<*, *>, M : R

fun <T> Array<out T>.indexOf(element: T): Int

fun ByteArray.indexOf(element: Byte): Int

fun ShortArray.indexOf(element: Short): Int

fun IntArray.indexOf(element: Int): Int

fun LongArray.indexOf(element: Long): Int

fun FloatArray.indexOf(element: Float): Int

fun DoubleArray.indexOf(element: Double): Int

fun BooleanArray.indexOf(element: Boolean): Int

fun CharArray.indexOf(element: Char): Int

fun UIntArray.indexOf(element: UInt): Int

fun ULongArray.indexOf(element: ULong): Int

fun UByteArray.indexOf(element: UByte): Int

fun UShortArray.indexOf(element: UShort): Int

fun <T> Iterable<T>.indexOf(element: T): Int

fun <T> List<T>.indexOf(element: T): Int

fun <T> Array<out T>.indexOfFirst(
    predicate: (T) -> Boolean
): Int

fun ByteArray.indexOfFirst(predicate: (Byte) -> Boolean): Int

fun ShortArray.indexOfFirst(
    predicate: (Short) -> Boolean
): Int

fun IntArray.indexOfFirst(predicate: (Int) -> Boolean): Int

fun LongArray.indexOfFirst(predicate: (Long) -> Boolean): Int

fun FloatArray.indexOfFirst(
    predicate: (Float) -> Boolean
): Int

fun DoubleArray.indexOfFirst(
    predicate: (Double) -> Boolean
): Int

fun BooleanArray.indexOfFirst(
    predicate: (Boolean) -> Boolean
): Int

fun CharArray.indexOfFirst(predicate: (Char) -> Boolean): Int

fun UIntArray.indexOfFirst(predicate: (UInt) -> Boolean): Int

fun ULongArray.indexOfFirst(
    predicate: (ULong) -> Boolean
): Int

fun UByteArray.indexOfFirst(
    predicate: (UByte) -> Boolean
): Int

fun UShortArray.indexOfFirst(
    predicate: (UShort) -> Boolean
): Int

fun <T> Iterable<T>.indexOfFirst(
    predicate: (T) -> Boolean
): Int

fun <T> List<T>.indexOfFirst(predicate: (T) -> Boolean): Int

fun <T> Array<out T>.indexOfLast(
    predicate: (T) -> Boolean
): Int

fun ByteArray.indexOfLast(predicate: (Byte) -> Boolean): Int

fun ShortArray.indexOfLast(
    predicate: (Short) -> Boolean
): Int

fun IntArray.indexOfLast(predicate: (Int) -> Boolean): Int

fun LongArray.indexOfLast(predicate: (Long) -> Boolean): Int

fun FloatArray.indexOfLast(
    predicate: (Float) -> Boolean
): Int

fun DoubleArray.indexOfLast(
    predicate: (Double) -> Boolean
): Int

fun BooleanArray.indexOfLast(
    predicate: (Boolean) -> Boolean
): Int

fun CharArray.indexOfLast(predicate: (Char) -> Boolean): Int

fun UIntArray.indexOfLast(predicate: (UInt) -> Boolean): Int

fun ULongArray.indexOfLast(
    predicate: (ULong) -> Boolean
): Int

fun UByteArray.indexOfLast(
    predicate: (UByte) -> Boolean
): Int

fun UShortArray.indexOfLast(
    predicate: (UShort) -> Boolean
): Int

fun <T> Iterable<T>.indexOfLast(
    predicate: (T) -> Boolean
): Int

fun <T> List<T>.indexOfLast(predicate: (T) -> Boolean): Int

infix fun <T> any_array<T>.intersect(
    other: Iterable<T>
): Set<T>

infix fun <T> Iterable<T>.intersect(
    other: Iterable<T>
): Set<T>

fun <T> any_array<T>.isEmpty(): Boolean

fun <T> any_array<T>.isNotEmpty(): Boolean

fun <T> Collection<T>.isNotEmpty(): Boolean

fun <K, V> Map<out K, V>.isNotEmpty(): Boolean

fun Array<*>?.isNullOrEmpty(): Boolean

fun <T> Collection<T>?.isNullOrEmpty(): Boolean

fun <K, V> Map<out K, V>?.isNullOrEmpty(): Boolean

fun <T> Iterable(iterator: () -> Iterator<T>): Iterable<T>

operator fun <T> Iterator<T>.iterator(): Iterator<T>

operator fun <K, V> Map<out K, V>.iterator(): Iterator<Entry<K, V>>

operator fun <K, V> MutableMap<K, V>.iterator(): MutableIterator<MutableEntry<K, V>>

fun <T, A : Appendable> Array<out T>.joinTo(
    buffer: A, 
    separator: CharSequence = ", ", 
    prefix: CharSequence = "", 
    postfix: CharSequence = "", 
    limit: Int = -1, 
    truncated: CharSequence = "...", 
    transform: ((T) -> CharSequence)? = null
): A

fun <A : Appendable> ByteArray.joinTo(
    buffer: A, 
    separator: CharSequence = ", ", 
    prefix: CharSequence = "", 
    postfix: CharSequence = "", 
    limit: Int = -1, 
    truncated: CharSequence = "...", 
    transform: ((Byte) -> CharSequence)? = null
): A

fun <A : Appendable> ShortArray.joinTo(
    buffer: A, 
    separator: CharSequence = ", ", 
    prefix: CharSequence = "", 
    postfix: CharSequence = "", 
    limit: Int = -1, 
    truncated: CharSequence = "...", 
    transform: ((Short) -> CharSequence)? = null
): A

fun <A : Appendable> IntArray.joinTo(
    buffer: A, 
    separator: CharSequence = ", ", 
    prefix: CharSequence = "", 
    postfix: CharSequence = "", 
    limit: Int = -1, 
    truncated: CharSequence = "...", 
    transform: ((Int) -> CharSequence)? = null
): A

fun <A : Appendable> LongArray.joinTo(
    buffer: A, 
    separator: CharSequence = ", ", 
    prefix: CharSequence = "", 
    postfix: CharSequence = "", 
    limit: Int = -1, 
    truncated: CharSequence = "...", 
    transform: ((Long) -> CharSequence)? = null
): A

fun <A : Appendable> FloatArray.joinTo(
    buffer: A, 
    separator: CharSequence = ", ", 
    prefix: CharSequence = "", 
    postfix: CharSequence = "", 
    limit: Int = -1, 
    truncated: CharSequence = "...", 
    transform: ((Float) -> CharSequence)? = null
): A

fun <A : Appendable> DoubleArray.joinTo(
    buffer: A, 
    separator: CharSequence = ", ", 
    prefix: CharSequence = "", 
    postfix: CharSequence = "", 
    limit: Int = -1, 
    truncated: CharSequence = "...", 
    transform: ((Double) -> CharSequence)? = null
): A

fun <A : Appendable> BooleanArray.joinTo(
    buffer: A, 
    separator: CharSequence = ", ", 
    prefix: CharSequence = "", 
    postfix: CharSequence = "", 
    limit: Int = -1, 
    truncated: CharSequence = "...", 
    transform: ((Boolean) -> CharSequence)? = null
): A

fun <A : Appendable> CharArray.joinTo(
    buffer: A, 
    separator: CharSequence = ", ", 
    prefix: CharSequence = "", 
    postfix: CharSequence = "", 
    limit: Int = -1, 
    truncated: CharSequence = "...", 
    transform: ((Char) -> CharSequence)? = null
): A

fun <T, A : Appendable> Iterable<T>.joinTo(
    buffer: A, 
    separator: CharSequence = ", ", 
    prefix: CharSequence = "", 
    postfix: CharSequence = "", 
    limit: Int = -1, 
    truncated: CharSequence = "...", 
    transform: ((T) -> CharSequence)? = null
): A

fun <T> Array<out T>.joinToString(
    separator: CharSequence = ", ", 
    prefix: CharSequence = "", 
    postfix: CharSequence = "", 
    limit: Int = -1, 
    truncated: CharSequence = "...", 
    transform: ((T) -> CharSequence)? = null
): String

fun ByteArray.joinToString(
    separator: CharSequence = ", ", 
    prefix: CharSequence = "", 
    postfix: CharSequence = "", 
    limit: Int = -1, 
    truncated: CharSequence = "...", 
    transform: ((Byte) -> CharSequence)? = null
): String

fun ShortArray.joinToString(
    separator: CharSequence = ", ", 
    prefix: CharSequence = "", 
    postfix: CharSequence = "", 
    limit: Int = -1, 
    truncated: CharSequence = "...", 
    transform: ((Short) -> CharSequence)? = null
): String

fun IntArray.joinToString(
    separator: CharSequence = ", ", 
    prefix: CharSequence = "", 
    postfix: CharSequence = "", 
    limit: Int = -1, 
    truncated: CharSequence = "...", 
    transform: ((Int) -> CharSequence)? = null
): String

fun LongArray.joinToString(
    separator: CharSequence = ", ", 
    prefix: CharSequence = "", 
    postfix: CharSequence = "", 
    limit: Int = -1, 
    truncated: CharSequence = "...", 
    transform: ((Long) -> CharSequence)? = null
): String

fun FloatArray.joinToString(
    separator: CharSequence = ", ", 
    prefix: CharSequence = "", 
    postfix: CharSequence = "", 
    limit: Int = -1, 
    truncated: CharSequence = "...", 
    transform: ((Float) -> CharSequence)? = null
): String

fun DoubleArray.joinToString(
    separator: CharSequence = ", ", 
    prefix: CharSequence = "", 
    postfix: CharSequence = "", 
    limit: Int = -1, 
    truncated: CharSequence = "...", 
    transform: ((Double) -> CharSequence)? = null
): String

fun BooleanArray.joinToString(
    separator: CharSequence = ", ", 
    prefix: CharSequence = "", 
    postfix: CharSequence = "", 
    limit: Int = -1, 
    truncated: CharSequence = "...", 
    transform: ((Boolean) -> CharSequence)? = null
): String

fun CharArray.joinToString(
    separator: CharSequence = ", ", 
    prefix: CharSequence = "", 
    postfix: CharSequence = "", 
    limit: Int = -1, 
    truncated: CharSequence = "...", 
    transform: ((Char) -> CharSequence)? = null
): String

fun <T> Iterable<T>.joinToString(
    separator: CharSequence = ", ", 
    prefix: CharSequence = "", 
    postfix: CharSequence = "", 
    limit: Int = -1, 
    truncated: CharSequence = "...", 
    transform: ((T) -> CharSequence)? = null
): String

fun <T> Array<out T>.last(): T

fun ByteArray.last(): Byte

fun ShortArray.last(): Short

fun IntArray.last(): Int

fun LongArray.last(): Long

fun FloatArray.last(): Float

fun DoubleArray.last(): Double

fun BooleanArray.last(): Boolean

fun CharArray.last(): Char

fun <T> Iterable<T>.last(): T

fun <T> List<T>.last(): T

fun UIntArray.last(): UInt

fun ULongArray.last(): ULong

fun UByteArray.last(): UByte

fun UShortArray.last(): UShort

fun <T> Array<out T>.lastOrNull(): T?

fun ByteArray.lastOrNull(): Byte?

fun ShortArray.lastOrNull(): Short?

fun IntArray.lastOrNull(): Int?

fun LongArray.lastOrNull(): Long?

fun FloatArray.lastOrNull(): Float?

fun DoubleArray.lastOrNull(): Double?

fun BooleanArray.lastOrNull(): Boolean?

fun CharArray.lastOrNull(): Char?

fun UIntArray.lastOrNull(): UInt?

fun ULongArray.lastOrNull(): ULong?

fun UByteArray.lastOrNull(): UByte?

fun UShortArray.lastOrNull(): UShort?

fun <T, R> Array<out T>.map(transform: (T) -> R): List<R>

fun <R> ByteArray.map(transform: (Byte) -> R): List<R>

fun <R> ShortArray.map(transform: (Short) -> R): List<R>

fun <R> IntArray.map(transform: (Int) -> R): List<R>

fun <R> LongArray.map(transform: (Long) -> R): List<R>

fun <R> FloatArray.map(transform: (Float) -> R): List<R>

fun <R> DoubleArray.map(transform: (Double) -> R): List<R>

fun <R> BooleanArray.map(transform: (Boolean) -> R): List<R>

fun <R> CharArray.map(transform: (Char) -> R): List<R>

fun <R> UIntArray.map(transform: (UInt) -> R): List<R>

fun <R> ULongArray.map(transform: (ULong) -> R): List<R>

fun <R> UByteArray.map(transform: (UByte) -> R): List<R>

fun <R> UShortArray.map(transform: (UShort) -> R): List<R>

fun <T, R> Iterable<T>.map(transform: (T) -> R): List<R>

fun <K, V, R> Map<out K, V>.map(
    transform: (Entry<K, V>) -> R
): List<R>

fun <T, R> Array<out T>.mapIndexed(
    transform: (index: Int, T) -> R
): List<R>

fun <R> ByteArray.mapIndexed(
    transform: (index: Int, Byte) -> R
): List<R>

fun <R> ShortArray.mapIndexed(
    transform: (index: Int, Short) -> R
): List<R>

fun <R> IntArray.mapIndexed(
    transform: (index: Int, Int) -> R
): List<R>

fun <R> LongArray.mapIndexed(
    transform: (index: Int, Long) -> R
): List<R>

fun <R> FloatArray.mapIndexed(
    transform: (index: Int, Float) -> R
): List<R>

fun <R> DoubleArray.mapIndexed(
    transform: (index: Int, Double) -> R
): List<R>

fun <R> BooleanArray.mapIndexed(
    transform: (index: Int, Boolean) -> R
): List<R>

fun <R> CharArray.mapIndexed(
    transform: (index: Int, Char) -> R
): List<R>

fun <R> UIntArray.mapIndexed(
    transform: (index: Int, UInt) -> R
): List<R>

fun <R> ULongArray.mapIndexed(
    transform: (index: Int, ULong) -> R
): List<R>

fun <R> UByteArray.mapIndexed(
    transform: (index: Int, UByte) -> R
): List<R>

fun <R> UShortArray.mapIndexed(
    transform: (index: Int, UShort) -> R
): List<R>

fun <T, R> Iterable<T>.mapIndexed(
    transform: (index: Int, T) -> R
): List<R>

fun <T, R : Any> Array<out T>.mapIndexedNotNull(
    transform: (index: Int, T) -> R?
): List<R>

fun <T, R : Any> Iterable<T>.mapIndexedNotNull(
    transform: (index: Int, T) -> R?
): List<R>

fun <T, R : Any, C : MutableCollection<in R>> Array<out T>.mapIndexedNotNullTo(
    destination: C, 
    transform: (index: Int, T) -> R?
): C

fun <T, R : Any, C : MutableCollection<in R>> Iterable<T>.mapIndexedNotNullTo(
    destination: C, 
    transform: (index: Int, T) -> R?
): C

fun <T, R, C : MutableCollection<in R>> Array<out T>.mapIndexedTo(
    destination: C, 
    transform: (index: Int, T) -> R
): C

fun <R, C : MutableCollection<in R>> ByteArray.mapIndexedTo(
    destination: C, 
    transform: (index: Int, Byte) -> R
): C

fun <R, C : MutableCollection<in R>> ShortArray.mapIndexedTo(
    destination: C, 
    transform: (index: Int, Short) -> R
): C

fun <R, C : MutableCollection<in R>> IntArray.mapIndexedTo(
    destination: C, 
    transform: (index: Int, Int) -> R
): C

fun <R, C : MutableCollection<in R>> LongArray.mapIndexedTo(
    destination: C, 
    transform: (index: Int, Long) -> R
): C

fun <R, C : MutableCollection<in R>> FloatArray.mapIndexedTo(
    destination: C, 
    transform: (index: Int, Float) -> R
): C

fun <R, C : MutableCollection<in R>> DoubleArray.mapIndexedTo(
    destination: C, 
    transform: (index: Int, Double) -> R
): C

fun <R, C : MutableCollection<in R>> BooleanArray.mapIndexedTo(
    destination: C, 
    transform: (index: Int, Boolean) -> R
): C

fun <R, C : MutableCollection<in R>> CharArray.mapIndexedTo(
    destination: C, 
    transform: (index: Int, Char) -> R
): C

fun <R, C : MutableCollection<in R>> UIntArray.mapIndexedTo(
    destination: C, 
    transform: (index: Int, UInt) -> R
): C

fun <R, C : MutableCollection<in R>> ULongArray.mapIndexedTo(
    destination: C, 
    transform: (index: Int, ULong) -> R
): C

fun <R, C : MutableCollection<in R>> UByteArray.mapIndexedTo(
    destination: C, 
    transform: (index: Int, UByte) -> R
): C

fun <R, C : MutableCollection<in R>> UShortArray.mapIndexedTo(
    destination: C, 
    transform: (index: Int, UShort) -> R
): C

fun <T, R, C : MutableCollection<in R>> Iterable<T>.mapIndexedTo(
    destination: C, 
    transform: (index: Int, T) -> R
): C

fun <K, V, R> Map<out K, V>.mapKeys(
    transform: (Entry<K, V>) -> R
): Map<R, V>

fun <K, V, R, M : MutableMap<in R, in V>> Map<out K, V>.mapKeysTo(
    destination: M, 
    transform: (Entry<K, V>) -> R
): M

fun <T, R : Any> Array<out T>.mapNotNull(
    transform: (T) -> R?
): List<R>

fun <T, R : Any> Iterable<T>.mapNotNull(
    transform: (T) -> R?
): List<R>

fun <K, V, R : Any> Map<out K, V>.mapNotNull(
    transform: (Entry<K, V>) -> R?
): List<R>

fun <T, R : Any, C : MutableCollection<in R>> Array<out T>.mapNotNullTo(
    destination: C, 
    transform: (T) -> R?
): C

fun <T, R : Any, C : MutableCollection<in R>> Iterable<T>.mapNotNullTo(
    destination: C, 
    transform: (T) -> R?
): C

fun <K, V, R : Any, C : MutableCollection<in R>> Map<out K, V>.mapNotNullTo(
    destination: C, 
    transform: (Entry<K, V>) -> R?
): C

fun <K, V> mapOf(vararg pairs: Pair<K, V>): Map<K, V>

fun <K, V> mapOf(): Map<K, V>

fun <K, V> mapOf(pair: Pair<K, V>): Map<K, V>

fun <T, R, C : MutableCollection<in R>> Array<out T>.mapTo(
    destination: C, 
    transform: (T) -> R
): C

fun <R, C : MutableCollection<in R>> ByteArray.mapTo(
    destination: C, 
    transform: (Byte) -> R
): C

fun <R, C : MutableCollection<in R>> ShortArray.mapTo(
    destination: C, 
    transform: (Short) -> R
): C

fun <R, C : MutableCollection<in R>> IntArray.mapTo(
    destination: C, 
    transform: (Int) -> R
): C

fun <R, C : MutableCollection<in R>> LongArray.mapTo(
    destination: C, 
    transform: (Long) -> R
): C

fun <R, C : MutableCollection<in R>> FloatArray.mapTo(
    destination: C, 
    transform: (Float) -> R
): C

fun <R, C : MutableCollection<in R>> DoubleArray.mapTo(
    destination: C, 
    transform: (Double) -> R
): C

fun <R, C : MutableCollection<in R>> BooleanArray.mapTo(
    destination: C, 
    transform: (Boolean) -> R
): C

fun <R, C : MutableCollection<in R>> CharArray.mapTo(
    destination: C, 
    transform: (Char) -> R
): C

fun <R, C : MutableCollection<in R>> UIntArray.mapTo(
    destination: C, 
    transform: (UInt) -> R
): C

fun <R, C : MutableCollection<in R>> ULongArray.mapTo(
    destination: C, 
    transform: (ULong) -> R
): C

fun <R, C : MutableCollection<in R>> UByteArray.mapTo(
    destination: C, 
    transform: (UByte) -> R
): C

fun <R, C : MutableCollection<in R>> UShortArray.mapTo(
    destination: C, 
    transform: (UShort) -> R
): C

fun <T, R, C : MutableCollection<in R>> Iterable<T>.mapTo(
    destination: C, 
    transform: (T) -> R
): C

fun <K, V, R, C : MutableCollection<in R>> Map<out K, V>.mapTo(
    destination: C, 
    transform: (Entry<K, V>) -> R
): C

fun <K, V, R> Map<out K, V>.mapValues(
    transform: (Entry<K, V>) -> R
): Map<K, R>

fun <K, V, R, M : MutableMap<in K, in R>> Map<out K, V>.mapValuesTo(
    destination: M, 
    transform: (Entry<K, V>) -> R
): M

fun Array<out Double>.max(): Double

fun Array<out Double>.max(): Double?

fun Array<out Float>.max(): Float

fun Array<out Float>.max(): Float?

fun <T : Comparable<T>> Array<out T>.max(): T

fun <T : Comparable<T>> Array<out T>.max(): T?

fun ByteArray.max(): Byte

fun ByteArray.max(): Byte?

fun ShortArray.max(): Short

fun ShortArray.max(): Short?

fun IntArray.max(): Int

fun IntArray.max(): Int?

fun LongArray.max(): Long

fun LongArray.max(): Long?

fun FloatArray.max(): Float

fun FloatArray.max(): Float?

fun DoubleArray.max(): Double

fun DoubleArray.max(): Double?

fun CharArray.max(): Char

fun CharArray.max(): Char?

fun Iterable<Double>.max(): Double

fun Iterable<Double>.max(): Double?

fun Iterable<Float>.max(): Float

fun Iterable<Float>.max(): Float?

fun <T : Comparable<T>> Iterable<T>.max(): T

fun <T : Comparable<T>> Iterable<T>.max(): T?

fun UIntArray.max(): UInt

fun UIntArray.max(): UInt?

fun ULongArray.max(): ULong

fun ULongArray.max(): ULong?

fun UByteArray.max(): UByte

fun UByteArray.max(): UByte?

fun UShortArray.max(): UShort

fun UShortArray.max(): UShort?

fun <T, R : Comparable<R>> Array<out T>.maxBy(
    selector: (T) -> R
): T

fun <T, R : Comparable<R>> Array<out T>.maxBy(
    selector: (T) -> R
): T?

fun <R : Comparable<R>> ByteArray.maxBy(
    selector: (Byte) -> R
): Byte

fun <R : Comparable<R>> ByteArray.maxBy(
    selector: (Byte) -> R
): Byte?

fun <R : Comparable<R>> ShortArray.maxBy(
    selector: (Short) -> R
): Short

fun <R : Comparable<R>> ShortArray.maxBy(
    selector: (Short) -> R
): Short?

fun <R : Comparable<R>> IntArray.maxBy(
    selector: (Int) -> R
): Int

fun <R : Comparable<R>> IntArray.maxBy(
    selector: (Int) -> R
): Int?

fun <R : Comparable<R>> LongArray.maxBy(
    selector: (Long) -> R
): Long

fun <R : Comparable<R>> LongArray.maxBy(
    selector: (Long) -> R
): Long?

fun <R : Comparable<R>> FloatArray.maxBy(
    selector: (Float) -> R
): Float

fun <R : Comparable<R>> FloatArray.maxBy(
    selector: (Float) -> R
): Float?

fun <R : Comparable<R>> DoubleArray.maxBy(
    selector: (Double) -> R
): Double

fun <R : Comparable<R>> DoubleArray.maxBy(
    selector: (Double) -> R
): Double?

fun <R : Comparable<R>> BooleanArray.maxBy(
    selector: (Boolean) -> R
): Boolean

fun <R : Comparable<R>> BooleanArray.maxBy(
    selector: (Boolean) -> R
): Boolean?

fun <R : Comparable<R>> CharArray.maxBy(
    selector: (Char) -> R
): Char

fun <R : Comparable<R>> CharArray.maxBy(
    selector: (Char) -> R
): Char?

fun <T, R : Comparable<R>> Iterable<T>.maxBy(
    selector: (T) -> R
): T

fun <T, R : Comparable<R>> Iterable<T>.maxBy(
    selector: (T) -> R
): T?

fun <R : Comparable<R>> UIntArray.maxBy(
    selector: (UInt) -> R
): UInt

fun <R : Comparable<R>> UIntArray.maxBy(
    selector: (UInt) -> R
): UInt?

fun <R : Comparable<R>> ULongArray.maxBy(
    selector: (ULong) -> R
): ULong

fun <R : Comparable<R>> ULongArray.maxBy(
    selector: (ULong) -> R
): ULong?

fun <R : Comparable<R>> UByteArray.maxBy(
    selector: (UByte) -> R
): UByte

fun <R : Comparable<R>> UByteArray.maxBy(
    selector: (UByte) -> R
): UByte?

fun <R : Comparable<R>> UShortArray.maxBy(
    selector: (UShort) -> R
): UShort

fun <R : Comparable<R>> UShortArray.maxBy(
    selector: (UShort) -> R
): UShort?

fun <K, V, R : Comparable<R>> Map<out K, V>.maxBy(
    selector: (Entry<K, V>) -> R
): Entry<K, V>

fun <K, V, R : Comparable<R>> Map<out K, V>.maxBy(
    selector: (Entry<K, V>) -> R
): Entry<K, V>?

fun <T, R : Comparable<R>> Array<out T>.maxByOrNull(
    selector: (T) -> R
): T?

fun <R : Comparable<R>> ByteArray.maxByOrNull(
    selector: (Byte) -> R
): Byte?

fun <R : Comparable<R>> ShortArray.maxByOrNull(
    selector: (Short) -> R
): Short?

fun <R : Comparable<R>> IntArray.maxByOrNull(
    selector: (Int) -> R
): Int?

fun <R : Comparable<R>> LongArray.maxByOrNull(
    selector: (Long) -> R
): Long?

fun <R : Comparable<R>> FloatArray.maxByOrNull(
    selector: (Float) -> R
): Float?

fun <R : Comparable<R>> DoubleArray.maxByOrNull(
    selector: (Double) -> R
): Double?

fun <R : Comparable<R>> BooleanArray.maxByOrNull(
    selector: (Boolean) -> R
): Boolean?

fun <R : Comparable<R>> CharArray.maxByOrNull(
    selector: (Char) -> R
): Char?

fun <T, R : Comparable<R>> Iterable<T>.maxByOrNull(
    selector: (T) -> R
): T?

fun <R : Comparable<R>> UIntArray.maxByOrNull(
    selector: (UInt) -> R
): UInt?

fun <R : Comparable<R>> ULongArray.maxByOrNull(
    selector: (ULong) -> R
): ULong?

fun <R : Comparable<R>> UByteArray.maxByOrNull(
    selector: (UByte) -> R
): UByte?

fun <R : Comparable<R>> UShortArray.maxByOrNull(
    selector: (UShort) -> R
): UShort?

fun <K, V, R : Comparable<R>> Map<out K, V>.maxByOrNull(
    selector: (Entry<K, V>) -> R
): Entry<K, V>?

fun <T> Array<out T>.maxOf(selector: (T) -> Double): Double

fun ByteArray.maxOf(selector: (Byte) -> Double): Double

fun ShortArray.maxOf(selector: (Short) -> Double): Double

fun IntArray.maxOf(selector: (Int) -> Double): Double

fun LongArray.maxOf(selector: (Long) -> Double): Double

fun FloatArray.maxOf(selector: (Float) -> Double): Double

fun DoubleArray.maxOf(selector: (Double) -> Double): Double

fun BooleanArray.maxOf(selector: (Boolean) -> Double): Double

fun CharArray.maxOf(selector: (Char) -> Double): Double

fun <T> Array<out T>.maxOf(selector: (T) -> Float): Float

fun ByteArray.maxOf(selector: (Byte) -> Float): Float

fun ShortArray.maxOf(selector: (Short) -> Float): Float

fun IntArray.maxOf(selector: (Int) -> Float): Float

fun LongArray.maxOf(selector: (Long) -> Float): Float

fun FloatArray.maxOf(selector: (Float) -> Float): Float

fun DoubleArray.maxOf(selector: (Double) -> Float): Float

fun BooleanArray.maxOf(selector: (Boolean) -> Float): Float

fun CharArray.maxOf(selector: (Char) -> Float): Float

fun <T, R : Comparable<R>> Array<out T>.maxOf(
    selector: (T) -> R
): R

fun <R : Comparable<R>> ByteArray.maxOf(
    selector: (Byte) -> R
): R

fun <R : Comparable<R>> ShortArray.maxOf(
    selector: (Short) -> R
): R

fun <R : Comparable<R>> IntArray.maxOf(
    selector: (Int) -> R
): R

fun <R : Comparable<R>> LongArray.maxOf(
    selector: (Long) -> R
): R

fun <R : Comparable<R>> FloatArray.maxOf(
    selector: (Float) -> R
): R

fun <R : Comparable<R>> DoubleArray.maxOf(
    selector: (Double) -> R
): R

fun <R : Comparable<R>> BooleanArray.maxOf(
    selector: (Boolean) -> R
): R

fun <R : Comparable<R>> CharArray.maxOf(
    selector: (Char) -> R
): R

fun UIntArray.maxOf(selector: (UInt) -> Double): Double

fun ULongArray.maxOf(selector: (ULong) -> Double): Double

fun UByteArray.maxOf(selector: (UByte) -> Double): Double

fun UShortArray.maxOf(selector: (UShort) -> Double): Double

fun UIntArray.maxOf(selector: (UInt) -> Float): Float

fun ULongArray.maxOf(selector: (ULong) -> Float): Float

fun UByteArray.maxOf(selector: (UByte) -> Float): Float

fun UShortArray.maxOf(selector: (UShort) -> Float): Float

fun <R : Comparable<R>> UIntArray.maxOf(
    selector: (UInt) -> R
): R

fun <R : Comparable<R>> ULongArray.maxOf(
    selector: (ULong) -> R
): R

fun <R : Comparable<R>> UByteArray.maxOf(
    selector: (UByte) -> R
): R

fun <R : Comparable<R>> UShortArray.maxOf(
    selector: (UShort) -> R
): R

fun <T> Iterable<T>.maxOf(selector: (T) -> Double): Double

fun <T> Iterable<T>.maxOf(selector: (T) -> Float): Float

fun <T, R : Comparable<R>> Iterable<T>.maxOf(
    selector: (T) -> R
): R

fun <K, V> Map<out K, V>.maxOf(
    selector: (Entry<K, V>) -> Double
): Double

fun <K, V> Map<out K, V>.maxOf(
    selector: (Entry<K, V>) -> Float
): Float

fun <K, V, R : Comparable<R>> Map<out K, V>.maxOf(
    selector: (Entry<K, V>) -> R
): R

fun <T> Array<out T>.maxOfOrNull(
    selector: (T) -> Double
): Double?

fun ByteArray.maxOfOrNull(
    selector: (Byte) -> Double
): Double?

fun ShortArray.maxOfOrNull(
    selector: (Short) -> Double
): Double?

fun IntArray.maxOfOrNull(selector: (Int) -> Double): Double?

fun LongArray.maxOfOrNull(
    selector: (Long) -> Double
): Double?

fun FloatArray.maxOfOrNull(
    selector: (Float) -> Double
): Double?

fun DoubleArray.maxOfOrNull(
    selector: (Double) -> Double
): Double?

fun BooleanArray.maxOfOrNull(
    selector: (Boolean) -> Double
): Double?

fun CharArray.maxOfOrNull(
    selector: (Char) -> Double
): Double?

fun <T> Array<out T>.maxOfOrNull(
    selector: (T) -> Float
): Float?

fun ByteArray.maxOfOrNull(selector: (Byte) -> Float): Float?

fun ShortArray.maxOfOrNull(
    selector: (Short) -> Float
): Float?

fun IntArray.maxOfOrNull(selector: (Int) -> Float): Float?

fun LongArray.maxOfOrNull(selector: (Long) -> Float): Float?

fun FloatArray.maxOfOrNull(
    selector: (Float) -> Float
): Float?

fun DoubleArray.maxOfOrNull(
    selector: (Double) -> Float
): Float?

fun BooleanArray.maxOfOrNull(
    selector: (Boolean) -> Float
): Float?

fun CharArray.maxOfOrNull(selector: (Char) -> Float): Float?

fun <T, R : Comparable<R>> Array<out T>.maxOfOrNull(
    selector: (T) -> R
): R?

fun <R : Comparable<R>> ByteArray.maxOfOrNull(
    selector: (Byte) -> R
): R?

fun <R : Comparable<R>> ShortArray.maxOfOrNull(
    selector: (Short) -> R
): R?

fun <R : Comparable<R>> IntArray.maxOfOrNull(
    selector: (Int) -> R
): R?

fun <R : Comparable<R>> LongArray.maxOfOrNull(
    selector: (Long) -> R
): R?

fun <R : Comparable<R>> FloatArray.maxOfOrNull(
    selector: (Float) -> R
): R?

fun <R : Comparable<R>> DoubleArray.maxOfOrNull(
    selector: (Double) -> R
): R?

fun <R : Comparable<R>> BooleanArray.maxOfOrNull(
    selector: (Boolean) -> R
): R?

fun <R : Comparable<R>> CharArray.maxOfOrNull(
    selector: (Char) -> R
): R?

fun UIntArray.maxOfOrNull(
    selector: (UInt) -> Double
): Double?

fun ULongArray.maxOfOrNull(
    selector: (ULong) -> Double
): Double?

fun UByteArray.maxOfOrNull(
    selector: (UByte) -> Double
): Double?

fun UShortArray.maxOfOrNull(
    selector: (UShort) -> Double
): Double?

fun UIntArray.maxOfOrNull(selector: (UInt) -> Float): Float?

fun ULongArray.maxOfOrNull(
    selector: (ULong) -> Float
): Float?

fun UByteArray.maxOfOrNull(
    selector: (UByte) -> Float
): Float?

fun UShortArray.maxOfOrNull(
    selector: (UShort) -> Float
): Float?

fun <R : Comparable<R>> UIntArray.maxOfOrNull(
    selector: (UInt) -> R
): R?

fun <R : Comparable<R>> ULongArray.maxOfOrNull(
    selector: (ULong) -> R
): R?

fun <R : Comparable<R>> UByteArray.maxOfOrNull(
    selector: (UByte) -> R
): R?

fun <R : Comparable<R>> UShortArray.maxOfOrNull(
    selector: (UShort) -> R
): R?

fun <T> Iterable<T>.maxOfOrNull(
    selector: (T) -> Double
): Double?

fun <T> Iterable<T>.maxOfOrNull(
    selector: (T) -> Float
): Float?

fun <T, R : Comparable<R>> Iterable<T>.maxOfOrNull(
    selector: (T) -> R
): R?

fun <K, V> Map<out K, V>.maxOfOrNull(
    selector: (Entry<K, V>) -> Double
): Double?

fun <K, V> Map<out K, V>.maxOfOrNull(
    selector: (Entry<K, V>) -> Float
): Float?

fun <K, V, R : Comparable<R>> Map<out K, V>.maxOfOrNull(
    selector: (Entry<K, V>) -> R
): R?

fun <T, R> Array<out T>.maxOfWith(
    comparator: Comparator<in R>, 
    selector: (T) -> R
): R

fun <R> ByteArray.maxOfWith(
    comparator: Comparator<in R>, 
    selector: (Byte) -> R
): R

fun <R> ShortArray.maxOfWith(
    comparator: Comparator<in R>, 
    selector: (Short) -> R
): R

fun <R> IntArray.maxOfWith(
    comparator: Comparator<in R>, 
    selector: (Int) -> R
): R

fun <R> LongArray.maxOfWith(
    comparator: Comparator<in R>, 
    selector: (Long) -> R
): R

fun <R> FloatArray.maxOfWith(
    comparator: Comparator<in R>, 
    selector: (Float) -> R
): R

fun <R> DoubleArray.maxOfWith(
    comparator: Comparator<in R>, 
    selector: (Double) -> R
): R

fun <R> BooleanArray.maxOfWith(
    comparator: Comparator<in R>, 
    selector: (Boolean) -> R
): R

fun <R> CharArray.maxOfWith(
    comparator: Comparator<in R>, 
    selector: (Char) -> R
): R

fun <R> UIntArray.maxOfWith(
    comparator: Comparator<in R>, 
    selector: (UInt) -> R
): R

fun <R> ULongArray.maxOfWith(
    comparator: Comparator<in R>, 
    selector: (ULong) -> R
): R

fun <R> UByteArray.maxOfWith(
    comparator: Comparator<in R>, 
    selector: (UByte) -> R
): R

fun <R> UShortArray.maxOfWith(
    comparator: Comparator<in R>, 
    selector: (UShort) -> R
): R

fun <T, R> Iterable<T>.maxOfWith(
    comparator: Comparator<in R>, 
    selector: (T) -> R
): R

fun <K, V, R> Map<out K, V>.maxOfWith(
    comparator: Comparator<in R>, 
    selector: (Entry<K, V>) -> R
): R

fun <T, R> Array<out T>.maxOfWithOrNull(
    comparator: Comparator<in R>, 
    selector: (T) -> R
): R?

fun <R> ByteArray.maxOfWithOrNull(
    comparator: Comparator<in R>, 
    selector: (Byte) -> R
): R?

fun <R> ShortArray.maxOfWithOrNull(
    comparator: Comparator<in R>, 
    selector: (Short) -> R
): R?

fun <R> IntArray.maxOfWithOrNull(
    comparator: Comparator<in R>, 
    selector: (Int) -> R
): R?

fun <R> LongArray.maxOfWithOrNull(
    comparator: Comparator<in R>, 
    selector: (Long) -> R
): R?

fun <R> FloatArray.maxOfWithOrNull(
    comparator: Comparator<in R>, 
    selector: (Float) -> R
): R?

fun <R> DoubleArray.maxOfWithOrNull(
    comparator: Comparator<in R>, 
    selector: (Double) -> R
): R?

fun <R> BooleanArray.maxOfWithOrNull(
    comparator: Comparator<in R>, 
    selector: (Boolean) -> R
): R?

fun <R> CharArray.maxOfWithOrNull(
    comparator: Comparator<in R>, 
    selector: (Char) -> R
): R?

fun <R> UIntArray.maxOfWithOrNull(
    comparator: Comparator<in R>, 
    selector: (UInt) -> R
): R?

fun <R> ULongArray.maxOfWithOrNull(
    comparator: Comparator<in R>, 
    selector: (ULong) -> R
): R?

fun <R> UByteArray.maxOfWithOrNull(
    comparator: Comparator<in R>, 
    selector: (UByte) -> R
): R?

fun <R> UShortArray.maxOfWithOrNull(
    comparator: Comparator<in R>, 
    selector: (UShort) -> R
): R?

fun <T, R> Iterable<T>.maxOfWithOrNull(
    comparator: Comparator<in R>, 
    selector: (T) -> R
): R?

fun <K, V, R> Map<out K, V>.maxOfWithOrNull(
    comparator: Comparator<in R>, 
    selector: (Entry<K, V>) -> R
): R?

fun Array<out Double>.maxOrNull(): Double?

fun Array<out Float>.maxOrNull(): Float?

fun <T : Comparable<T>> Array<out T>.maxOrNull(): T?

fun ByteArray.maxOrNull(): Byte?

fun ShortArray.maxOrNull(): Short?

fun IntArray.maxOrNull(): Int?

fun LongArray.maxOrNull(): Long?

fun FloatArray.maxOrNull(): Float?

fun DoubleArray.maxOrNull(): Double?

fun CharArray.maxOrNull(): Char?

fun Iterable<Double>.maxOrNull(): Double?

fun Iterable<Float>.maxOrNull(): Float?

fun <T : Comparable<T>> Iterable<T>.maxOrNull(): T?

fun UIntArray.maxOrNull(): UInt?

fun ULongArray.maxOrNull(): ULong?

fun UByteArray.maxOrNull(): UByte?

fun UShortArray.maxOrNull(): UShort?

fun <T> Array<out T>.maxWith(comparator: Comparator<in T>): T

fun ByteArray.maxWith(comparator: Comparator<in Byte>): Byte

fun ShortArray.maxWith(
    comparator: Comparator<in Short>
): Short

fun IntArray.maxWith(comparator: Comparator<in Int>): Int

fun LongArray.maxWith(comparator: Comparator<in Long>): Long

fun FloatArray.maxWith(
    comparator: Comparator<in Float>
): Float

fun DoubleArray.maxWith(
    comparator: Comparator<in Double>
): Double

fun BooleanArray.maxWith(
    comparator: Comparator<in Boolean>
): Boolean

fun CharArray.maxWith(comparator: Comparator<in Char>): Char

fun <T> Iterable<T>.maxWith(comparator: Comparator<in T>): T

fun UIntArray.maxWith(comparator: Comparator<in UInt>): UInt

fun ULongArray.maxWith(
    comparator: Comparator<in ULong>
): ULong

fun UByteArray.maxWith(
    comparator: Comparator<in UByte>
): UByte

fun UShortArray.maxWith(
    comparator: Comparator<in UShort>
): UShort

fun <K, V> Map<out K, V>.maxWith(
    comparator: Comparator<in Entry<K, V>>
): Entry<K, V>

fun <T> Array<out T>.maxWith(
    comparator: Comparator<in T>
): T?

fun ByteArray.maxWith(comparator: Comparator<in Byte>): Byte?

fun ShortArray.maxWith(
    comparator: Comparator<in Short>
): Short?

fun IntArray.maxWith(comparator: Comparator<in Int>): Int?

fun LongArray.maxWith(comparator: Comparator<in Long>): Long?

fun FloatArray.maxWith(
    comparator: Comparator<in Float>
): Float?

fun DoubleArray.maxWith(
    comparator: Comparator<in Double>
): Double?

fun BooleanArray.maxWith(
    comparator: Comparator<in Boolean>
): Boolean?

fun CharArray.maxWith(comparator: Comparator<in Char>): Char?

fun <T> Iterable<T>.maxWith(comparator: Comparator<in T>): T?

fun <K, V> Map<out K, V>.maxWith(
    comparator: Comparator<in Entry<K, V>>
): Entry<K, V>?

fun UIntArray.maxWith(comparator: Comparator<in UInt>): UInt?

fun ULongArray.maxWith(
    comparator: Comparator<in ULong>
): ULong?

fun UByteArray.maxWith(
    comparator: Comparator<in UByte>
): UByte?

fun UShortArray.maxWith(
    comparator: Comparator<in UShort>
): UShort?

fun <T> Array<out T>.maxWithOrNull(
    comparator: Comparator<in T>
): T?

fun ByteArray.maxWithOrNull(
    comparator: Comparator<in Byte>
): Byte?

fun ShortArray.maxWithOrNull(
    comparator: Comparator<in Short>
): Short?

fun IntArray.maxWithOrNull(
    comparator: Comparator<in Int>
): Int?

fun LongArray.maxWithOrNull(
    comparator: Comparator<in Long>
): Long?

fun FloatArray.maxWithOrNull(
    comparator: Comparator<in Float>
): Float?

fun DoubleArray.maxWithOrNull(
    comparator: Comparator<in Double>
): Double?

fun BooleanArray.maxWithOrNull(
    comparator: Comparator<in Boolean>
): Boolean?

fun CharArray.maxWithOrNull(
    comparator: Comparator<in Char>
): Char?

fun <T> Iterable<T>.maxWithOrNull(
    comparator: Comparator<in T>
): T?

fun UIntArray.maxWithOrNull(
    comparator: Comparator<in UInt>
): UInt?

fun ULongArray.maxWithOrNull(
    comparator: Comparator<in ULong>
): ULong?

fun UByteArray.maxWithOrNull(
    comparator: Comparator<in UByte>
): UByte?

fun UShortArray.maxWithOrNull(
    comparator: Comparator<in UShort>
): UShort?

fun <K, V> Map<out K, V>.maxWithOrNull(
    comparator: Comparator<in Entry<K, V>>
): Entry<K, V>?

fun Array<out Double>.min(): Double

fun Array<out Double>.min(): Double?

fun Array<out Float>.min(): Float

fun Array<out Float>.min(): Float?

fun <T : Comparable<T>> Array<out T>.min(): T

fun <T : Comparable<T>> Array<out T>.min(): T?

fun ByteArray.min(): Byte

fun ByteArray.min(): Byte?

fun ShortArray.min(): Short

fun ShortArray.min(): Short?

fun IntArray.min(): Int

fun IntArray.min(): Int?

fun LongArray.min(): Long

fun LongArray.min(): Long?

fun FloatArray.min(): Float

fun FloatArray.min(): Float?

fun DoubleArray.min(): Double

fun DoubleArray.min(): Double?

fun CharArray.min(): Char

fun CharArray.min(): Char?

fun Iterable<Double>.min(): Double

fun Iterable<Double>.min(): Double?

fun Iterable<Float>.min(): Float

fun Iterable<Float>.min(): Float?

fun <T : Comparable<T>> Iterable<T>.min(): T

fun <T : Comparable<T>> Iterable<T>.min(): T?

fun UIntArray.min(): UInt

fun UIntArray.min(): UInt?

fun ULongArray.min(): ULong

fun ULongArray.min(): ULong?

fun UByteArray.min(): UByte

fun UByteArray.min(): UByte?

fun UShortArray.min(): UShort

fun UShortArray.min(): UShort?

fun <T, R : Comparable<R>> Array<out T>.minBy(
    selector: (T) -> R
): T

fun <T, R : Comparable<R>> Array<out T>.minBy(
    selector: (T) -> R
): T?

fun <R : Comparable<R>> ByteArray.minBy(
    selector: (Byte) -> R
): Byte

fun <R : Comparable<R>> ByteArray.minBy(
    selector: (Byte) -> R
): Byte?

fun <R : Comparable<R>> ShortArray.minBy(
    selector: (Short) -> R
): Short

fun <R : Comparable<R>> ShortArray.minBy(
    selector: (Short) -> R
): Short?

fun <R : Comparable<R>> IntArray.minBy(
    selector: (Int) -> R
): Int

fun <R : Comparable<R>> IntArray.minBy(
    selector: (Int) -> R
): Int?

fun <R : Comparable<R>> LongArray.minBy(
    selector: (Long) -> R
): Long

fun <R : Comparable<R>> LongArray.minBy(
    selector: (Long) -> R
): Long?

fun <R : Comparable<R>> FloatArray.minBy(
    selector: (Float) -> R
): Float

fun <R : Comparable<R>> FloatArray.minBy(
    selector: (Float) -> R
): Float?

fun <R : Comparable<R>> DoubleArray.minBy(
    selector: (Double) -> R
): Double

fun <R : Comparable<R>> DoubleArray.minBy(
    selector: (Double) -> R
): Double?

fun <R : Comparable<R>> BooleanArray.minBy(
    selector: (Boolean) -> R
): Boolean

fun <R : Comparable<R>> BooleanArray.minBy(
    selector: (Boolean) -> R
): Boolean?

fun <R : Comparable<R>> CharArray.minBy(
    selector: (Char) -> R
): Char

fun <R : Comparable<R>> CharArray.minBy(
    selector: (Char) -> R
): Char?

fun <T, R : Comparable<R>> Iterable<T>.minBy(
    selector: (T) -> R
): T

fun <T, R : Comparable<R>> Iterable<T>.minBy(
    selector: (T) -> R
): T?

fun <R : Comparable<R>> UIntArray.minBy(
    selector: (UInt) -> R
): UInt

fun <R : Comparable<R>> UIntArray.minBy(
    selector: (UInt) -> R
): UInt?

fun <R : Comparable<R>> ULongArray.minBy(
    selector: (ULong) -> R
): ULong

fun <R : Comparable<R>> ULongArray.minBy(
    selector: (ULong) -> R
): ULong?

fun <R : Comparable<R>> UByteArray.minBy(
    selector: (UByte) -> R
): UByte

fun <R : Comparable<R>> UByteArray.minBy(
    selector: (UByte) -> R
): UByte?

fun <R : Comparable<R>> UShortArray.minBy(
    selector: (UShort) -> R
): UShort

fun <R : Comparable<R>> UShortArray.minBy(
    selector: (UShort) -> R
): UShort?

fun <K, V, R : Comparable<R>> Map<out K, V>.minBy(
    selector: (Entry<K, V>) -> R
): Entry<K, V>

fun <K, V, R : Comparable<R>> Map<out K, V>.minBy(
    selector: (Entry<K, V>) -> R
): Entry<K, V>?

fun <T, R : Comparable<R>> Array<out T>.minByOrNull(
    selector: (T) -> R
): T?

fun <R : Comparable<R>> ByteArray.minByOrNull(
    selector: (Byte) -> R
): Byte?

fun <R : Comparable<R>> ShortArray.minByOrNull(
    selector: (Short) -> R
): Short?

fun <R : Comparable<R>> IntArray.minByOrNull(
    selector: (Int) -> R
): Int?

fun <R : Comparable<R>> LongArray.minByOrNull(
    selector: (Long) -> R
): Long?

fun <R : Comparable<R>> FloatArray.minByOrNull(
    selector: (Float) -> R
): Float?

fun <R : Comparable<R>> DoubleArray.minByOrNull(
    selector: (Double) -> R
): Double?

fun <R : Comparable<R>> BooleanArray.minByOrNull(
    selector: (Boolean) -> R
): Boolean?

fun <R : Comparable<R>> CharArray.minByOrNull(
    selector: (Char) -> R
): Char?

fun <T, R : Comparable<R>> Iterable<T>.minByOrNull(
    selector: (T) -> R
): T?

fun <R : Comparable<R>> UIntArray.minByOrNull(
    selector: (UInt) -> R
): UInt?

fun <R : Comparable<R>> ULongArray.minByOrNull(
    selector: (ULong) -> R
): ULong?

fun <R : Comparable<R>> UByteArray.minByOrNull(
    selector: (UByte) -> R
): UByte?

fun <R : Comparable<R>> UShortArray.minByOrNull(
    selector: (UShort) -> R
): UShort?

fun <K, V, R : Comparable<R>> Map<out K, V>.minByOrNull(
    selector: (Entry<K, V>) -> R
): Entry<K, V>?

fun <T> Array<out T>.minOf(selector: (T) -> Double): Double

fun ByteArray.minOf(selector: (Byte) -> Double): Double

fun ShortArray.minOf(selector: (Short) -> Double): Double

fun IntArray.minOf(selector: (Int) -> Double): Double

fun LongArray.minOf(selector: (Long) -> Double): Double

fun FloatArray.minOf(selector: (Float) -> Double): Double

fun DoubleArray.minOf(selector: (Double) -> Double): Double

fun BooleanArray.minOf(selector: (Boolean) -> Double): Double

fun CharArray.minOf(selector: (Char) -> Double): Double

fun <T> Array<out T>.minOf(selector: (T) -> Float): Float

fun ByteArray.minOf(selector: (Byte) -> Float): Float

fun ShortArray.minOf(selector: (Short) -> Float): Float

fun IntArray.minOf(selector: (Int) -> Float): Float

fun LongArray.minOf(selector: (Long) -> Float): Float

fun FloatArray.minOf(selector: (Float) -> Float): Float

fun DoubleArray.minOf(selector: (Double) -> Float): Float

fun BooleanArray.minOf(selector: (Boolean) -> Float): Float

fun CharArray.minOf(selector: (Char) -> Float): Float

fun <T, R : Comparable<R>> Array<out T>.minOf(
    selector: (T) -> R
): R

fun <R : Comparable<R>> ByteArray.minOf(
    selector: (Byte) -> R
): R

fun <R : Comparable<R>> ShortArray.minOf(
    selector: (Short) -> R
): R

fun <R : Comparable<R>> IntArray.minOf(
    selector: (Int) -> R
): R

fun <R : Comparable<R>> LongArray.minOf(
    selector: (Long) -> R
): R

fun <R : Comparable<R>> FloatArray.minOf(
    selector: (Float) -> R
): R

fun <R : Comparable<R>> DoubleArray.minOf(
    selector: (Double) -> R
): R

fun <R : Comparable<R>> BooleanArray.minOf(
    selector: (Boolean) -> R
): R

fun <R : Comparable<R>> CharArray.minOf(
    selector: (Char) -> R
): R

fun UIntArray.minOf(selector: (UInt) -> Double): Double

fun ULongArray.minOf(selector: (ULong) -> Double): Double

fun UByteArray.minOf(selector: (UByte) -> Double): Double

fun UShortArray.minOf(selector: (UShort) -> Double): Double

fun UIntArray.minOf(selector: (UInt) -> Float): Float

fun ULongArray.minOf(selector: (ULong) -> Float): Float

fun UByteArray.minOf(selector: (UByte) -> Float): Float

fun UShortArray.minOf(selector: (UShort) -> Float): Float

fun <R : Comparable<R>> UIntArray.minOf(
    selector: (UInt) -> R
): R

fun <R : Comparable<R>> ULongArray.minOf(
    selector: (ULong) -> R
): R

fun <R : Comparable<R>> UByteArray.minOf(
    selector: (UByte) -> R
): R

fun <R : Comparable<R>> UShortArray.minOf(
    selector: (UShort) -> R
): R

fun <T> Iterable<T>.minOf(selector: (T) -> Double): Double

fun <T> Iterable<T>.minOf(selector: (T) -> Float): Float

fun <T, R : Comparable<R>> Iterable<T>.minOf(
    selector: (T) -> R
): R

fun <K, V> Map<out K, V>.minOf(
    selector: (Entry<K, V>) -> Double
): Double

fun <K, V> Map<out K, V>.minOf(
    selector: (Entry<K, V>) -> Float
): Float

fun <K, V, R : Comparable<R>> Map<out K, V>.minOf(
    selector: (Entry<K, V>) -> R
): R

fun <T> Array<out T>.minOfOrNull(
    selector: (T) -> Double
): Double?

fun ByteArray.minOfOrNull(
    selector: (Byte) -> Double
): Double?

fun ShortArray.minOfOrNull(
    selector: (Short) -> Double
): Double?

fun IntArray.minOfOrNull(selector: (Int) -> Double): Double?

fun LongArray.minOfOrNull(
    selector: (Long) -> Double
): Double?

fun FloatArray.minOfOrNull(
    selector: (Float) -> Double
): Double?

fun DoubleArray.minOfOrNull(
    selector: (Double) -> Double
): Double?

fun BooleanArray.minOfOrNull(
    selector: (Boolean) -> Double
): Double?

fun CharArray.minOfOrNull(
    selector: (Char) -> Double
): Double?

fun <T> Array<out T>.minOfOrNull(
    selector: (T) -> Float
): Float?

fun ByteArray.minOfOrNull(selector: (Byte) -> Float): Float?

fun ShortArray.minOfOrNull(
    selector: (Short) -> Float
): Float?

fun IntArray.minOfOrNull(selector: (Int) -> Float): Float?

fun LongArray.minOfOrNull(selector: (Long) -> Float): Float?

fun FloatArray.minOfOrNull(
    selector: (Float) -> Float
): Float?

fun DoubleArray.minOfOrNull(
    selector: (Double) -> Float
): Float?

fun BooleanArray.minOfOrNull(
    selector: (Boolean) -> Float
): Float?

fun CharArray.minOfOrNull(selector: (Char) -> Float): Float?

fun <T, R : Comparable<R>> Array<out T>.minOfOrNull(
    selector: (T) -> R
): R?

fun <R : Comparable<R>> ByteArray.minOfOrNull(
    selector: (Byte) -> R
): R?

fun <R : Comparable<R>> ShortArray.minOfOrNull(
    selector: (Short) -> R
): R?

fun <R : Comparable<R>> IntArray.minOfOrNull(
    selector: (Int) -> R
): R?

fun <R : Comparable<R>> LongArray.minOfOrNull(
    selector: (Long) -> R
): R?

fun <R : Comparable<R>> FloatArray.minOfOrNull(
    selector: (Float) -> R
): R?

fun <R : Comparable<R>> DoubleArray.minOfOrNull(
    selector: (Double) -> R
): R?

fun <R : Comparable<R>> BooleanArray.minOfOrNull(
    selector: (Boolean) -> R
): R?

fun <R : Comparable<R>> CharArray.minOfOrNull(
    selector: (Char) -> R
): R?

fun UIntArray.minOfOrNull(
    selector: (UInt) -> Double
): Double?

fun ULongArray.minOfOrNull(
    selector: (ULong) -> Double
): Double?

fun UByteArray.minOfOrNull(
    selector: (UByte) -> Double
): Double?

fun UShortArray.minOfOrNull(
    selector: (UShort) -> Double
): Double?

fun UIntArray.minOfOrNull(selector: (UInt) -> Float): Float?

fun ULongArray.minOfOrNull(
    selector: (ULong) -> Float
): Float?

fun UByteArray.minOfOrNull(
    selector: (UByte) -> Float
): Float?

fun UShortArray.minOfOrNull(
    selector: (UShort) -> Float
): Float?

fun <R : Comparable<R>> UIntArray.minOfOrNull(
    selector: (UInt) -> R
): R?

fun <R : Comparable<R>> ULongArray.minOfOrNull(
    selector: (ULong) -> R
): R?

fun <R : Comparable<R>> UByteArray.minOfOrNull(
    selector: (UByte) -> R
): R?

fun <R : Comparable<R>> UShortArray.minOfOrNull(
    selector: (UShort) -> R
): R?

fun <T> Iterable<T>.minOfOrNull(
    selector: (T) -> Double
): Double?

fun <T> Iterable<T>.minOfOrNull(
    selector: (T) -> Float
): Float?

fun <T, R : Comparable<R>> Iterable<T>.minOfOrNull(
    selector: (T) -> R
): R?

fun <K, V> Map<out K, V>.minOfOrNull(
    selector: (Entry<K, V>) -> Double
): Double?

fun <K, V> Map<out K, V>.minOfOrNull(
    selector: (Entry<K, V>) -> Float
): Float?

fun <K, V, R : Comparable<R>> Map<out K, V>.minOfOrNull(
    selector: (Entry<K, V>) -> R
): R?

fun <T, R> Array<out T>.minOfWith(
    comparator: Comparator<in R>, 
    selector: (T) -> R
): R

fun <R> ByteArray.minOfWith(
    comparator: Comparator<in R>, 
    selector: (Byte) -> R
): R

fun <R> ShortArray.minOfWith(
    comparator: Comparator<in R>, 
    selector: (Short) -> R
): R

fun <R> IntArray.minOfWith(
    comparator: Comparator<in R>, 
    selector: (Int) -> R
): R

fun <R> LongArray.minOfWith(
    comparator: Comparator<in R>, 
    selector: (Long) -> R
): R

fun <R> FloatArray.minOfWith(
    comparator: Comparator<in R>, 
    selector: (Float) -> R
): R

fun <R> DoubleArray.minOfWith(
    comparator: Comparator<in R>, 
    selector: (Double) -> R
): R

fun <R> BooleanArray.minOfWith(
    comparator: Comparator<in R>, 
    selector: (Boolean) -> R
): R

fun <R> CharArray.minOfWith(
    comparator: Comparator<in R>, 
    selector: (Char) -> R
): R

fun <R> UIntArray.minOfWith(
    comparator: Comparator<in R>, 
    selector: (UInt) -> R
): R

fun <R> ULongArray.minOfWith(
    comparator: Comparator<in R>, 
    selector: (ULong) -> R
): R

fun <R> UByteArray.minOfWith(
    comparator: Comparator<in R>, 
    selector: (UByte) -> R
): R

fun <R> UShortArray.minOfWith(
    comparator: Comparator<in R>, 
    selector: (UShort) -> R
): R

fun <T, R> Iterable<T>.minOfWith(
    comparator: Comparator<in R>, 
    selector: (T) -> R
): R

fun <K, V, R> Map<out K, V>.minOfWith(
    comparator: Comparator<in R>, 
    selector: (Entry<K, V>) -> R
): R

fun <T, R> Array<out T>.minOfWithOrNull(
    comparator: Comparator<in R>, 
    selector: (T) -> R
): R?

fun <R> ByteArray.minOfWithOrNull(
    comparator: Comparator<in R>, 
    selector: (Byte) -> R
): R?

fun <R> ShortArray.minOfWithOrNull(
    comparator: Comparator<in R>, 
    selector: (Short) -> R
): R?

fun <R> IntArray.minOfWithOrNull(
    comparator: Comparator<in R>, 
    selector: (Int) -> R
): R?

fun <R> LongArray.minOfWithOrNull(
    comparator: Comparator<in R>, 
    selector: (Long) -> R
): R?

fun <R> FloatArray.minOfWithOrNull(
    comparator: Comparator<in R>, 
    selector: (Float) -> R
): R?

fun <R> DoubleArray.minOfWithOrNull(
    comparator: Comparator<in R>, 
    selector: (Double) -> R
): R?

fun <R> BooleanArray.minOfWithOrNull(
    comparator: Comparator<in R>, 
    selector: (Boolean) -> R
): R?

fun <R> CharArray.minOfWithOrNull(
    comparator: Comparator<in R>, 
    selector: (Char) -> R
): R?

fun <R> UIntArray.minOfWithOrNull(
    comparator: Comparator<in R>, 
    selector: (UInt) -> R
): R?

fun <R> ULongArray.minOfWithOrNull(
    comparator: Comparator<in R>, 
    selector: (ULong) -> R
): R?

fun <R> UByteArray.minOfWithOrNull(
    comparator: Comparator<in R>, 
    selector: (UByte) -> R
): R?

fun <R> UShortArray.minOfWithOrNull(
    comparator: Comparator<in R>, 
    selector: (UShort) -> R
): R?

fun <T, R> Iterable<T>.minOfWithOrNull(
    comparator: Comparator<in R>, 
    selector: (T) -> R
): R?

fun <K, V, R> Map<out K, V>.minOfWithOrNull(
    comparator: Comparator<in R>, 
    selector: (Entry<K, V>) -> R
): R?

fun Array<out Double>.minOrNull(): Double?

fun Array<out Float>.minOrNull(): Float?

fun <T : Comparable<T>> Array<out T>.minOrNull(): T?

fun ByteArray.minOrNull(): Byte?

fun ShortArray.minOrNull(): Short?

fun IntArray.minOrNull(): Int?

fun LongArray.minOrNull(): Long?

fun FloatArray.minOrNull(): Float?

fun DoubleArray.minOrNull(): Double?

fun CharArray.minOrNull(): Char?

fun Iterable<Double>.minOrNull(): Double?

fun Iterable<Float>.minOrNull(): Float?

fun <T : Comparable<T>> Iterable<T>.minOrNull(): T?

fun UIntArray.minOrNull(): UInt?

fun ULongArray.minOrNull(): ULong?

fun UByteArray.minOrNull(): UByte?

fun UShortArray.minOrNull(): UShort?

operator fun <T> Iterable<T>.minus(element: T): List<T>

operator fun <T> Iterable<T>.minus(
    elements: Array<out T>
): List<T>

operator fun <T> Iterable<T>.minus(
    elements: Iterable<T>
): List<T>

operator fun <T> Iterable<T>.minus(
    elements: Sequence<T>
): List<T>

operator fun <T> Set<T>.minus(element: T): Set<T>

operator fun <T> Set<T>.minus(elements: Array<out T>): Set<T>

operator fun <T> Set<T>.minus(elements: Iterable<T>): Set<T>

operator fun <T> Set<T>.minus(elements: Sequence<T>): Set<T>

operator fun <K, V> Map<out K, V>.minus(key: K): Map<K, V>

operator fun <K, V> Map<out K, V>.minus(
    keys: Iterable<K>
): Map<K, V>

operator fun <K, V> Map<out K, V>.minus(
    keys: Array<out K>
): Map<K, V>

operator fun <K, V> Map<out K, V>.minus(
    keys: Sequence<K>
): Map<K, V>

operator fun <K, V> MutableMap<K, V>.minusAssign(key: K)

operator fun <K, V> MutableMap<K, V>.minusAssign(
    keys: Iterable<K>)

operator fun <K, V> MutableMap<K, V>.minusAssign(
    keys: Array<out K>)

operator fun <K, V> MutableMap<K, V>.minusAssign(
    keys: Sequence<K>)

operator fun <T> MutableCollection<in T>.minusAssign(
    element: T)

operator fun <T> MutableCollection<in T>.minusAssign(
    elements: Iterable<T>)

operator fun <T> MutableCollection<in T>.minusAssign(
    elements: Array<T>)

operator fun <T> MutableCollection<in T>.minusAssign(
    elements: Sequence<T>)

fun <T> Iterable<T>.minusElement(element: T): List<T>

fun <T> Set<T>.minusElement(element: T): Set<T>

fun <T> Array<out T>.minWith(comparator: Comparator<in T>): T

fun ByteArray.minWith(comparator: Comparator<in Byte>): Byte

fun ShortArray.minWith(
    comparator: Comparator<in Short>
): Short

fun IntArray.minWith(comparator: Comparator<in Int>): Int

fun LongArray.minWith(comparator: Comparator<in Long>): Long

fun FloatArray.minWith(
    comparator: Comparator<in Float>
): Float

fun DoubleArray.minWith(
    comparator: Comparator<in Double>
): Double

fun BooleanArray.minWith(
    comparator: Comparator<in Boolean>
): Boolean

fun CharArray.minWith(comparator: Comparator<in Char>): Char

fun <T> Iterable<T>.minWith(comparator: Comparator<in T>): T

fun UIntArray.minWith(comparator: Comparator<in UInt>): UInt

fun ULongArray.minWith(
    comparator: Comparator<in ULong>
): ULong

fun UByteArray.minWith(
    comparator: Comparator<in UByte>
): UByte

fun UShortArray.minWith(
    comparator: Comparator<in UShort>
): UShort

fun <K, V> Map<out K, V>.minWith(
    comparator: Comparator<in Entry<K, V>>
): Entry<K, V>

fun <T> Array<out T>.minWith(
    comparator: Comparator<in T>
): T?

fun ByteArray.minWith(comparator: Comparator<in Byte>): Byte?

fun ShortArray.minWith(
    comparator: Comparator<in Short>
): Short?

fun IntArray.minWith(comparator: Comparator<in Int>): Int?

fun LongArray.minWith(comparator: Comparator<in Long>): Long?

fun FloatArray.minWith(
    comparator: Comparator<in Float>
): Float?

fun DoubleArray.minWith(
    comparator: Comparator<in Double>
): Double?

fun BooleanArray.minWith(
    comparator: Comparator<in Boolean>
): Boolean?

fun CharArray.minWith(comparator: Comparator<in Char>): Char?

fun <T> Iterable<T>.minWith(comparator: Comparator<in T>): T?

fun <K, V> Map<out K, V>.minWith(
    comparator: Comparator<in Entry<K, V>>
): Entry<K, V>?

fun UIntArray.minWith(comparator: Comparator<in UInt>): UInt?

fun ULongArray.minWith(
    comparator: Comparator<in ULong>
): ULong?

fun UByteArray.minWith(
    comparator: Comparator<in UByte>
): UByte?

fun UShortArray.minWith(
    comparator: Comparator<in UShort>
): UShort?

fun <T> Array<out T>.minWithOrNull(
    comparator: Comparator<in T>
): T?

fun ByteArray.minWithOrNull(
    comparator: Comparator<in Byte>
): Byte?

fun ShortArray.minWithOrNull(
    comparator: Comparator<in Short>
): Short?

fun IntArray.minWithOrNull(
    comparator: Comparator<in Int>
): Int?

fun LongArray.minWithOrNull(
    comparator: Comparator<in Long>
): Long?

fun FloatArray.minWithOrNull(
    comparator: Comparator<in Float>
): Float?

fun DoubleArray.minWithOrNull(
    comparator: Comparator<in Double>
): Double?

fun BooleanArray.minWithOrNull(
    comparator: Comparator<in Boolean>
): Boolean?

fun CharArray.minWithOrNull(
    comparator: Comparator<in Char>
): Char?

fun <T> Iterable<T>.minWithOrNull(
    comparator: Comparator<in T>
): T?

fun UIntArray.minWithOrNull(
    comparator: Comparator<in UInt>
): UInt?

fun ULongArray.minWithOrNull(
    comparator: Comparator<in ULong>
): ULong?

fun UByteArray.minWithOrNull(
    comparator: Comparator<in UByte>
): UByte?

fun UShortArray.minWithOrNull(
    comparator: Comparator<in UShort>
): UShort?

fun <K, V> Map<out K, V>.minWithOrNull(
    comparator: Comparator<in Entry<K, V>>
): Entry<K, V>?

fun <T> MutableList(
    size: Int, 
    init: (index: Int) -> T
): MutableList<T>

fun <T> mutableListOf(): MutableList<T>

fun <T> mutableListOf(vararg elements: T): MutableList<T>

fun <K, V> mutableMapOf(): MutableMap<K, V>

fun <K, V> mutableMapOf(
    vararg pairs: Pair<K, V>
): MutableMap<K, V>

fun <T> mutableSetOf(): MutableSet<T>

fun <T> mutableSetOf(vararg elements: T): MutableSet<T>

fun <T> Array<out T>.none(): Boolean

fun ByteArray.none(): Boolean

fun ShortArray.none(): Boolean

fun IntArray.none(): Boolean

fun LongArray.none(): Boolean

fun FloatArray.none(): Boolean

fun DoubleArray.none(): Boolean

fun BooleanArray.none(): Boolean

fun CharArray.none(): Boolean

fun UIntArray.none(): Boolean

fun ULongArray.none(): Boolean

fun UByteArray.none(): Boolean

fun UShortArray.none(): Boolean

fun <T> Array<out T>.none(predicate: (T) -> Boolean): Boolean

fun ByteArray.none(predicate: (Byte) -> Boolean): Boolean

fun ShortArray.none(predicate: (Short) -> Boolean): Boolean

fun IntArray.none(predicate: (Int) -> Boolean): Boolean

fun LongArray.none(predicate: (Long) -> Boolean): Boolean

fun FloatArray.none(predicate: (Float) -> Boolean): Boolean

fun DoubleArray.none(predicate: (Double) -> Boolean): Boolean

fun BooleanArray.none(
    predicate: (Boolean) -> Boolean
): Boolean

fun CharArray.none(predicate: (Char) -> Boolean): Boolean

fun <T> Iterable<T>.none(predicate: (T) -> Boolean): Boolean

fun UIntArray.none(predicate: (UInt) -> Boolean): Boolean

fun ULongArray.none(predicate: (ULong) -> Boolean): Boolean

fun UByteArray.none(predicate: (UByte) -> Boolean): Boolean

fun UShortArray.none(predicate: (UShort) -> Boolean): Boolean

fun <T> Iterable<T>.none(): Boolean

fun <K, V> Map<out K, V>.none(): Boolean

fun <K, V> Map<out K, V>.none(
    predicate: (Entry<K, V>) -> Boolean
): Boolean

fun <T> Array<out T>.onEach(
    action: (T) -> Unit
): Array<out T>

fun ByteArray.onEach(action: (Byte) -> Unit): ByteArray

fun ShortArray.onEach(action: (Short) -> Unit): ShortArray

fun IntArray.onEach(action: (Int) -> Unit): IntArray

fun LongArray.onEach(action: (Long) -> Unit): LongArray

fun FloatArray.onEach(action: (Float) -> Unit): FloatArray

fun DoubleArray.onEach(action: (Double) -> Unit): DoubleArray

fun BooleanArray.onEach(
    action: (Boolean) -> Unit
): BooleanArray

fun CharArray.onEach(action: (Char) -> Unit): CharArray

fun UIntArray.onEach(action: (UInt) -> Unit): UIntArray

fun ULongArray.onEach(action: (ULong) -> Unit): ULongArray

fun UByteArray.onEach(action: (UByte) -> Unit): UByteArray

fun UShortArray.onEach(action: (UShort) -> Unit): UShortArray

fun <T, C : Iterable<T>> C.onEach(action: (T) -> Unit): C

fun <K, V, M : Map<out K, V>> M.onEach(
    action: (Entry<K, V>) -> Unit
): M

fun <T> Array<out T>.onEachIndexed(
    action: (index: Int, T) -> Unit
): Array<out T>

fun ByteArray.onEachIndexed(
    action: (index: Int, Byte) -> Unit
): ByteArray

fun ShortArray.onEachIndexed(
    action: (index: Int, Short) -> Unit
): ShortArray

fun IntArray.onEachIndexed(
    action: (index: Int, Int) -> Unit
): IntArray

fun LongArray.onEachIndexed(
    action: (index: Int, Long) -> Unit
): LongArray

fun FloatArray.onEachIndexed(
    action: (index: Int, Float) -> Unit
): FloatArray

fun DoubleArray.onEachIndexed(
    action: (index: Int, Double) -> Unit
): DoubleArray

fun BooleanArray.onEachIndexed(
    action: (index: Int, Boolean) -> Unit
): BooleanArray

fun CharArray.onEachIndexed(
    action: (index: Int, Char) -> Unit
): CharArray

fun UIntArray.onEachIndexed(
    action: (index: Int, UInt) -> Unit
): UIntArray

fun ULongArray.onEachIndexed(
    action: (index: Int, ULong) -> Unit
): ULongArray

fun UByteArray.onEachIndexed(
    action: (index: Int, UByte) -> Unit
): UByteArray

fun UShortArray.onEachIndexed(
    action: (index: Int, UShort) -> Unit
): UShortArray

fun <T, C : Iterable<T>> C.onEachIndexed(
    action: (index: Int, T) -> Unit
): C

fun <K, V, M : Map<out K, V>> M.onEachIndexed(
    action: (index: Int, Entry<K, V>) -> Unit
): M

fun <T> Collection<T>?.orEmpty(): Collection<T>

fun <T> List<T>?.orEmpty(): List<T>

fun <K, V> Map<K, V>?.orEmpty(): Map<K, V>

fun <T> Set<T>?.orEmpty(): Set<T>

fun <T> any_array<T>.orEmpty(): Array<out T>

fun <T> any_array<T>.partition(
    predicate: (T) -> Boolean
): Pair<List<T>, List<T>>

fun <T> Iterable<T>.partition(
    predicate: (T) -> Boolean
): Pair<List<T>, List<T>>

operator fun <K, V> MutableMap<in K, in V>.plusAssign(
    pair: Pair<K, V>)

operator fun <K, V> MutableMap<in K, in V>.plusAssign(
    pairs: Iterable<Pair<K, V>>)

operator fun <K, V> MutableMap<in K, in V>.plusAssign(
    pairs: Array<out Pair<K, V>>)

operator fun <K, V> MutableMap<in K, in V>.plusAssign(
    pairs: Sequence<Pair<K, V>>)

operator fun <K, V> MutableMap<in K, in V>.plusAssign(
    map: Map<K, V>)

operator fun <T> MutableCollection<in T>.plusAssign(
    element: T)

operator fun <T> MutableCollection<in T>.plusAssign(
    elements: Iterable<T>)

operator fun <T> MutableCollection<in T>.plusAssign(
    elements: Array<T>)

operator fun <T> MutableCollection<in T>.plusAssign(
    elements: Sequence<T>)

fun <T> Iterable<T>.plusElement(element: T): List<T>

fun <T> Collection<T>.plusElement(element: T): List<T>

fun <T> Set<T>.plusElement(element: T): Set<T>

fun <T> any_array<T>.plusElement(element: T): Array<T>

fun <K, V> MutableMap<in K, in V>.putAll(
    pairs: Array<out Pair<K, V>>)

fun <K, V> MutableMap<in K, in V>.putAll(
    pairs: Iterable<Pair<K, V>>)

fun <K, V> MutableMap<in K, in V>.putAll(
    pairs: Sequence<Pair<K, V>>)

fun <T> Array<out T>.random(): T

fun ByteArray.random(): Byte

fun ShortArray.random(): Short

fun IntArray.random(): Int

fun LongArray.random(): Long

fun FloatArray.random(): Float

fun DoubleArray.random(): Double

fun BooleanArray.random(): Boolean

fun CharArray.random(): Char

fun UIntArray.random(): UInt

fun ULongArray.random(): ULong

fun UByteArray.random(): UByte

fun UShortArray.random(): UShort

fun <T> Array<out T>.random(random: Random): T

fun ByteArray.random(random: Random): Byte

fun ShortArray.random(random: Random): Short

fun IntArray.random(random: Random): Int

fun LongArray.random(random: Random): Long

fun FloatArray.random(random: Random): Float

fun DoubleArray.random(random: Random): Double

fun BooleanArray.random(random: Random): Boolean

fun CharArray.random(random: Random): Char

fun UIntArray.random(random: Random): UInt

fun ULongArray.random(random: Random): ULong

fun UByteArray.random(random: Random): UByte

fun UShortArray.random(random: Random): UShort

fun <T> Collection<T>.random(): T

fun <T> Collection<T>.random(random: Random): T

fun <T> Array<out T>.randomOrNull(): T?

fun ByteArray.randomOrNull(): Byte?

fun ShortArray.randomOrNull(): Short?

fun IntArray.randomOrNull(): Int?

fun LongArray.randomOrNull(): Long?

fun FloatArray.randomOrNull(): Float?

fun DoubleArray.randomOrNull(): Double?

fun BooleanArray.randomOrNull(): Boolean?

fun CharArray.randomOrNull(): Char?

fun UIntArray.randomOrNull(): UInt?

fun ULongArray.randomOrNull(): ULong?

fun UByteArray.randomOrNull(): UByte?

fun UShortArray.randomOrNull(): UShort?

fun <T> Array<out T>.randomOrNull(random: Random): T?

fun ByteArray.randomOrNull(random: Random): Byte?

fun ShortArray.randomOrNull(random: Random): Short?

fun IntArray.randomOrNull(random: Random): Int?

fun LongArray.randomOrNull(random: Random): Long?

fun FloatArray.randomOrNull(random: Random): Float?

fun DoubleArray.randomOrNull(random: Random): Double?

fun BooleanArray.randomOrNull(random: Random): Boolean?

fun CharArray.randomOrNull(random: Random): Char?

fun UIntArray.randomOrNull(random: Random): UInt?

fun ULongArray.randomOrNull(random: Random): ULong?

fun UByteArray.randomOrNull(random: Random): UByte?

fun UShortArray.randomOrNull(random: Random): UShort?

fun <T> Collection<T>.randomOrNull(): T?

fun <T> Collection<T>.randomOrNull(random: Random): T?

fun <S, T : S> Array<out T>.reduce(
    operation: (acc: S, T) -> S
): S

fun ByteArray.reduce(
    operation: (acc: Byte, Byte) -> Byte
): Byte

fun ShortArray.reduce(
    operation: (acc: Short, Short) -> Short
): Short

fun IntArray.reduce(operation: (acc: Int, Int) -> Int): Int

fun LongArray.reduce(
    operation: (acc: Long, Long) -> Long
): Long

fun FloatArray.reduce(
    operation: (acc: Float, Float) -> Float
): Float

fun DoubleArray.reduce(
    operation: (acc: Double, Double) -> Double
): Double

fun BooleanArray.reduce(
    operation: (acc: Boolean, Boolean) -> Boolean
): Boolean

fun CharArray.reduce(
    operation: (acc: Char, Char) -> Char
): Char

fun <S, T : S> Iterable<T>.reduce(
    operation: (acc: S, T) -> S
): S

fun UIntArray.reduce(
    operation: (acc: UInt, UInt) -> UInt
): UInt

fun ULongArray.reduce(
    operation: (acc: ULong, ULong) -> ULong
): ULong

fun UByteArray.reduce(
    operation: (acc: UByte, UByte) -> UByte
): UByte

fun UShortArray.reduce(
    operation: (acc: UShort, UShort) -> UShort
): UShort

fun <S, T : S, K> Grouping<T, K>.reduce(
    operation: (key: K, accumulator: S, element: T) -> S
): Map<K, S>

fun <S, T : S> Array<out T>.reduceIndexed(
    operation: (index: Int, acc: S, T) -> S
): S

fun ByteArray.reduceIndexed(
    operation: (index: Int, acc: Byte, Byte) -> Byte
): Byte

fun ShortArray.reduceIndexed(
    operation: (index: Int, acc: Short, Short) -> Short
): Short

fun IntArray.reduceIndexed(
    operation: (index: Int, acc: Int, Int) -> Int
): Int

fun LongArray.reduceIndexed(
    operation: (index: Int, acc: Long, Long) -> Long
): Long

fun FloatArray.reduceIndexed(
    operation: (index: Int, acc: Float, Float) -> Float
): Float

fun DoubleArray.reduceIndexed(
    operation: (index: Int, acc: Double, Double) -> Double
): Double

fun BooleanArray.reduceIndexed(
    operation: (index: Int, acc: Boolean, Boolean) -> Boolean
): Boolean

fun CharArray.reduceIndexed(
    operation: (index: Int, acc: Char, Char) -> Char
): Char

fun UIntArray.reduceIndexed(
    operation: (index: Int, acc: UInt, UInt) -> UInt
): UInt

fun ULongArray.reduceIndexed(
    operation: (index: Int, acc: ULong, ULong) -> ULong
): ULong

fun UByteArray.reduceIndexed(
    operation: (index: Int, acc: UByte, UByte) -> UByte
): UByte

fun UShortArray.reduceIndexed(
    operation: (index: Int, acc: UShort, UShort) -> UShort
): UShort

fun <S, T : S> Iterable<T>.reduceIndexed(
    operation: (index: Int, acc: S, T) -> S
): S

fun <S, T : S> Array<out T>.reduceIndexedOrNull(
    operation: (index: Int, acc: S, T) -> S
): S?

fun ByteArray.reduceIndexedOrNull(
    operation: (index: Int, acc: Byte, Byte) -> Byte
): Byte?

fun ShortArray.reduceIndexedOrNull(
    operation: (index: Int, acc: Short, Short) -> Short
): Short?

fun IntArray.reduceIndexedOrNull(
    operation: (index: Int, acc: Int, Int) -> Int
): Int?

fun LongArray.reduceIndexedOrNull(
    operation: (index: Int, acc: Long, Long) -> Long
): Long?

fun FloatArray.reduceIndexedOrNull(
    operation: (index: Int, acc: Float, Float) -> Float
): Float?

fun DoubleArray.reduceIndexedOrNull(
    operation: (index: Int, acc: Double, Double) -> Double
): Double?

fun BooleanArray.reduceIndexedOrNull(
    operation: (index: Int, acc: Boolean, Boolean) -> Boolean
): Boolean?

fun CharArray.reduceIndexedOrNull(
    operation: (index: Int, acc: Char, Char) -> Char
): Char?

fun UIntArray.reduceIndexedOrNull(
    operation: (index: Int, acc: UInt, UInt) -> UInt
): UInt?

fun ULongArray.reduceIndexedOrNull(
    operation: (index: Int, acc: ULong, ULong) -> ULong
): ULong?

fun UByteArray.reduceIndexedOrNull(
    operation: (index: Int, acc: UByte, UByte) -> UByte
): UByte?

fun UShortArray.reduceIndexedOrNull(
    operation: (index: Int, acc: UShort, UShort) -> UShort
): UShort?

fun <S, T : S> Iterable<T>.reduceIndexedOrNull(
    operation: (index: Int, acc: S, T) -> S
): S?

fun <S, T : S> Array<out T>.reduceOrNull(
    operation: (acc: S, T) -> S
): S?

fun ByteArray.reduceOrNull(
    operation: (acc: Byte, Byte) -> Byte
): Byte?

fun ShortArray.reduceOrNull(
    operation: (acc: Short, Short) -> Short
): Short?

fun IntArray.reduceOrNull(
    operation: (acc: Int, Int) -> Int
): Int?

fun LongArray.reduceOrNull(
    operation: (acc: Long, Long) -> Long
): Long?

fun FloatArray.reduceOrNull(
    operation: (acc: Float, Float) -> Float
): Float?

fun DoubleArray.reduceOrNull(
    operation: (acc: Double, Double) -> Double
): Double?

fun BooleanArray.reduceOrNull(
    operation: (acc: Boolean, Boolean) -> Boolean
): Boolean?

fun CharArray.reduceOrNull(
    operation: (acc: Char, Char) -> Char
): Char?

fun <S, T : S> Iterable<T>.reduceOrNull(
    operation: (acc: S, T) -> S
): S?

fun UIntArray.reduceOrNull(
    operation: (acc: UInt, UInt) -> UInt
): UInt?

fun ULongArray.reduceOrNull(
    operation: (acc: ULong, ULong) -> ULong
): ULong?

fun UByteArray.reduceOrNull(
    operation: (acc: UByte, UByte) -> UByte
): UByte?

fun UShortArray.reduceOrNull(
    operation: (acc: UShort, UShort) -> UShort
): UShort?

fun <S, T : S> Array<out T>.reduceRight(
    operation: (T, acc: S) -> S
): S

fun ByteArray.reduceRight(
    operation: (Byte, acc: Byte) -> Byte
): Byte

fun ShortArray.reduceRight(
    operation: (Short, acc: Short) -> Short
): Short

fun IntArray.reduceRight(
    operation: (Int, acc: Int) -> Int
): Int

fun LongArray.reduceRight(
    operation: (Long, acc: Long) -> Long
): Long

fun FloatArray.reduceRight(
    operation: (Float, acc: Float) -> Float
): Float

fun DoubleArray.reduceRight(
    operation: (Double, acc: Double) -> Double
): Double

fun BooleanArray.reduceRight(
    operation: (Boolean, acc: Boolean) -> Boolean
): Boolean

fun CharArray.reduceRight(
    operation: (Char, acc: Char) -> Char
): Char

fun <S, T : S> List<T>.reduceRight(
    operation: (T, acc: S) -> S
): S

fun UIntArray.reduceRight(
    operation: (UInt, acc: UInt) -> UInt
): UInt

fun ULongArray.reduceRight(
    operation: (ULong, acc: ULong) -> ULong
): ULong

fun UByteArray.reduceRight(
    operation: (UByte, acc: UByte) -> UByte
): UByte

fun UShortArray.reduceRight(
    operation: (UShort, acc: UShort) -> UShort
): UShort

fun <S, T : S> Array<out T>.reduceRightIndexed(
    operation: (index: Int, T, acc: S) -> S
): S

fun ByteArray.reduceRightIndexed(
    operation: (index: Int, Byte, acc: Byte) -> Byte
): Byte

fun ShortArray.reduceRightIndexed(
    operation: (index: Int, Short, acc: Short) -> Short
): Short

fun IntArray.reduceRightIndexed(
    operation: (index: Int, Int, acc: Int) -> Int
): Int

fun LongArray.reduceRightIndexed(
    operation: (index: Int, Long, acc: Long) -> Long
): Long

fun FloatArray.reduceRightIndexed(
    operation: (index: Int, Float, acc: Float) -> Float
): Float

fun DoubleArray.reduceRightIndexed(
    operation: (index: Int, Double, acc: Double) -> Double
): Double

fun BooleanArray.reduceRightIndexed(
    operation: (index: Int, Boolean, acc: Boolean) -> Boolean
): Boolean

fun CharArray.reduceRightIndexed(
    operation: (index: Int, Char, acc: Char) -> Char
): Char

fun UIntArray.reduceRightIndexed(
    operation: (index: Int, UInt, acc: UInt) -> UInt
): UInt

fun ULongArray.reduceRightIndexed(
    operation: (index: Int, ULong, acc: ULong) -> ULong
): ULong

fun UByteArray.reduceRightIndexed(
    operation: (index: Int, UByte, acc: UByte) -> UByte
): UByte

fun UShortArray.reduceRightIndexed(
    operation: (index: Int, UShort, acc: UShort) -> UShort
): UShort

fun <S, T : S> List<T>.reduceRightIndexed(
    operation: (index: Int, T, acc: S) -> S
): S

fun <S, T : S> Array<out T>.reduceRightIndexedOrNull(
    operation: (index: Int, T, acc: S) -> S
): S?

fun ByteArray.reduceRightIndexedOrNull(
    operation: (index: Int, Byte, acc: Byte) -> Byte
): Byte?

fun ShortArray.reduceRightIndexedOrNull(
    operation: (index: Int, Short, acc: Short) -> Short
): Short?

fun IntArray.reduceRightIndexedOrNull(
    operation: (index: Int, Int, acc: Int) -> Int
): Int?

fun LongArray.reduceRightIndexedOrNull(
    operation: (index: Int, Long, acc: Long) -> Long
): Long?

fun FloatArray.reduceRightIndexedOrNull(
    operation: (index: Int, Float, acc: Float) -> Float
): Float?

fun DoubleArray.reduceRightIndexedOrNull(
    operation: (index: Int, Double, acc: Double) -> Double
): Double?

fun BooleanArray.reduceRightIndexedOrNull(
    operation: (index: Int, Boolean, acc: Boolean) -> Boolean
): Boolean?

fun CharArray.reduceRightIndexedOrNull(
    operation: (index: Int, Char, acc: Char) -> Char
): Char?

fun UIntArray.reduceRightIndexedOrNull(
    operation: (index: Int, UInt, acc: UInt) -> UInt
): UInt?

fun ULongArray.reduceRightIndexedOrNull(
    operation: (index: Int, ULong, acc: ULong) -> ULong
): ULong?

fun UByteArray.reduceRightIndexedOrNull(
    operation: (index: Int, UByte, acc: UByte) -> UByte
): UByte?

fun UShortArray.reduceRightIndexedOrNull(
    operation: (index: Int, UShort, acc: UShort) -> UShort
): UShort?

fun <S, T : S> List<T>.reduceRightIndexedOrNull(
    operation: (index: Int, T, acc: S) -> S
): S?

fun <S, T : S> Array<out T>.reduceRightOrNull(
    operation: (T, acc: S) -> S
): S?

fun ByteArray.reduceRightOrNull(
    operation: (Byte, acc: Byte) -> Byte
): Byte?

fun ShortArray.reduceRightOrNull(
    operation: (Short, acc: Short) -> Short
): Short?

fun IntArray.reduceRightOrNull(
    operation: (Int, acc: Int) -> Int
): Int?

fun LongArray.reduceRightOrNull(
    operation: (Long, acc: Long) -> Long
): Long?

fun FloatArray.reduceRightOrNull(
    operation: (Float, acc: Float) -> Float
): Float?

fun DoubleArray.reduceRightOrNull(
    operation: (Double, acc: Double) -> Double
): Double?

fun BooleanArray.reduceRightOrNull(
    operation: (Boolean, acc: Boolean) -> Boolean
): Boolean?

fun CharArray.reduceRightOrNull(
    operation: (Char, acc: Char) -> Char
): Char?

fun <S, T : S> List<T>.reduceRightOrNull(
    operation: (T, acc: S) -> S
): S?

fun UIntArray.reduceRightOrNull(
    operation: (UInt, acc: UInt) -> UInt
): UInt?

fun ULongArray.reduceRightOrNull(
    operation: (ULong, acc: ULong) -> ULong
): ULong?

fun UByteArray.reduceRightOrNull(
    operation: (UByte, acc: UByte) -> UByte
): UByte?

fun UShortArray.reduceRightOrNull(
    operation: (UShort, acc: UShort) -> UShort
): UShort?

fun <S, T : S, K, M : MutableMap<in K, S>> Grouping<T, K>.reduceTo(
    destination: M, 
    operation: (key: K, accumulator: S, element: T) -> S
): M

fun <K, V> MutableMap<out K, V>.remove(key: K): V?

fun <T> MutableCollection<out T>.remove(element: T): Boolean

fun <T> MutableList<T>.remove(index: Int): T

fun <K, V> MutableMap<out K, out V>.remove(
    key: K, 
    value: V
): Boolean

fun <T> MutableCollection<out T>.removeAll(
    elements: Collection<T>
): Boolean

fun <T> MutableCollection<in T>.removeAll(
    elements: Iterable<T>
): Boolean

fun <T> MutableCollection<in T>.removeAll(
    elements: Sequence<T>
): Boolean

fun <T> MutableCollection<in T>.removeAll(
    elements: Array<out T>
): Boolean

fun <T> MutableIterable<T>.removeAll(
    predicate: (T) -> Boolean
): Boolean

fun <T> MutableList<T>.removeAll(
    predicate: (T) -> Boolean
): Boolean

fun <T> MutableList<T>.removeFirst(): T

fun <T> MutableList<T>.removeFirstOrNull(): T?

fun <T> MutableList<T>.removeLast(): T

fun <T> MutableList<T>.removeLastOrNull(): T?

fun <T : Any> Array<T?>.requireNoNulls(): Array<T>

fun <T : Any> Iterable<T?>.requireNoNulls(): Iterable<T>

fun <T : Any> List<T?>.requireNoNulls(): List<T>

fun <T> MutableCollection<out T>.retainAll(
    elements: Collection<T>
): Boolean

fun <T> MutableCollection<in T>.retainAll(
    elements: Iterable<T>
): Boolean

fun <T> MutableCollection<in T>.retainAll(
    elements: Array<out T>
): Boolean

fun <T> MutableCollection<in T>.retainAll(
    elements: Sequence<T>
): Boolean

fun <T> MutableIterable<T>.retainAll(
    predicate: (T) -> Boolean
): Boolean

fun <T> MutableList<T>.retainAll(
    predicate: (T) -> Boolean
): Boolean

fun <T> Array<T>.reverse()

fun ByteArray.reverse()

fun ShortArray.reverse()

fun IntArray.reverse()

fun LongArray.reverse()

fun FloatArray.reverse()

fun DoubleArray.reverse()

fun BooleanArray.reverse()

fun CharArray.reverse()

fun UIntArray.reverse()

fun ULongArray.reverse()

fun UByteArray.reverse()

fun UShortArray.reverse()

fun <T> Array<T>.reverse(fromIndex: Int, toIndex: Int)

fun ByteArray.reverse(fromIndex: Int, toIndex: Int)

fun ShortArray.reverse(fromIndex: Int, toIndex: Int)

fun IntArray.reverse(fromIndex: Int, toIndex: Int)

fun LongArray.reverse(fromIndex: Int, toIndex: Int)

fun FloatArray.reverse(fromIndex: Int, toIndex: Int)

fun DoubleArray.reverse(fromIndex: Int, toIndex: Int)

fun BooleanArray.reverse(fromIndex: Int, toIndex: Int)

fun CharArray.reverse(fromIndex: Int, toIndex: Int)

fun UIntArray.reverse(fromIndex: Int, toIndex: Int)

fun ULongArray.reverse(fromIndex: Int, toIndex: Int)

fun UByteArray.reverse(fromIndex: Int, toIndex: Int)

fun UShortArray.reverse(fromIndex: Int, toIndex: Int)

fun <T> MutableList<T>.reverse()

fun <T> Array<out T>.reversed(): List<T>

fun ByteArray.reversed(): List<Byte>

fun ShortArray.reversed(): List<Short>

fun IntArray.reversed(): List<Int>

fun LongArray.reversed(): List<Long>

fun FloatArray.reversed(): List<Float>

fun DoubleArray.reversed(): List<Double>

fun BooleanArray.reversed(): List<Boolean>

fun CharArray.reversed(): List<Char>

fun <T> Iterable<T>.reversed(): List<T>

fun UIntArray.reversed(): List<UInt>

fun ULongArray.reversed(): List<ULong>

fun UByteArray.reversed(): List<UByte>

fun UShortArray.reversed(): List<UShort>

fun <T> Array<T>.reversedArray(): Array<T>

fun ByteArray.reversedArray(): ByteArray

fun ShortArray.reversedArray(): ShortArray

fun IntArray.reversedArray(): IntArray

fun LongArray.reversedArray(): LongArray

fun FloatArray.reversedArray(): FloatArray

fun DoubleArray.reversedArray(): DoubleArray

fun BooleanArray.reversedArray(): BooleanArray

fun CharArray.reversedArray(): CharArray

fun UIntArray.reversedArray(): UIntArray

fun ULongArray.reversedArray(): ULongArray

fun UByteArray.reversedArray(): UByteArray

fun UShortArray.reversedArray(): UShortArray

fun <T, R> Array<out T>.runningFold(
    initial: R, 
    operation: (acc: R, T) -> R
): List<R>

fun <R> ByteArray.runningFold(
    initial: R, 
    operation: (acc: R, Byte) -> R
): List<R>

fun <R> ShortArray.runningFold(
    initial: R, 
    operation: (acc: R, Short) -> R
): List<R>

fun <R> IntArray.runningFold(
    initial: R, 
    operation: (acc: R, Int) -> R
): List<R>

fun <R> LongArray.runningFold(
    initial: R, 
    operation: (acc: R, Long) -> R
): List<R>

fun <R> FloatArray.runningFold(
    initial: R, 
    operation: (acc: R, Float) -> R
): List<R>

fun <R> DoubleArray.runningFold(
    initial: R, 
    operation: (acc: R, Double) -> R
): List<R>

fun <R> BooleanArray.runningFold(
    initial: R, 
    operation: (acc: R, Boolean) -> R
): List<R>

fun <R> CharArray.runningFold(
    initial: R, 
    operation: (acc: R, Char) -> R
): List<R>

fun <T, R> Iterable<T>.runningFold(
    initial: R, 
    operation: (acc: R, T) -> R
): List<R>

fun <R> UIntArray.runningFold(
    initial: R, 
    operation: (acc: R, UInt) -> R
): List<R>

fun <R> ULongArray.runningFold(
    initial: R, 
    operation: (acc: R, ULong) -> R
): List<R>

fun <R> UByteArray.runningFold(
    initial: R, 
    operation: (acc: R, UByte) -> R
): List<R>

fun <R> UShortArray.runningFold(
    initial: R, 
    operation: (acc: R, UShort) -> R
): List<R>

fun <T, R> Array<out T>.runningFoldIndexed(
    initial: R, 
    operation: (index: Int, acc: R, T) -> R
): List<R>

fun <R> ByteArray.runningFoldIndexed(
    initial: R, 
    operation: (index: Int, acc: R, Byte) -> R
): List<R>

fun <R> ShortArray.runningFoldIndexed(
    initial: R, 
    operation: (index: Int, acc: R, Short) -> R
): List<R>

fun <R> IntArray.runningFoldIndexed(
    initial: R, 
    operation: (index: Int, acc: R, Int) -> R
): List<R>

fun <R> LongArray.runningFoldIndexed(
    initial: R, 
    operation: (index: Int, acc: R, Long) -> R
): List<R>

fun <R> FloatArray.runningFoldIndexed(
    initial: R, 
    operation: (index: Int, acc: R, Float) -> R
): List<R>

fun <R> DoubleArray.runningFoldIndexed(
    initial: R, 
    operation: (index: Int, acc: R, Double) -> R
): List<R>

fun <R> BooleanArray.runningFoldIndexed(
    initial: R, 
    operation: (index: Int, acc: R, Boolean) -> R
): List<R>

fun <R> CharArray.runningFoldIndexed(
    initial: R, 
    operation: (index: Int, acc: R, Char) -> R
): List<R>

fun <R> UIntArray.runningFoldIndexed(
    initial: R, 
    operation: (index: Int, acc: R, UInt) -> R
): List<R>

fun <R> ULongArray.runningFoldIndexed(
    initial: R, 
    operation: (index: Int, acc: R, ULong) -> R
): List<R>

fun <R> UByteArray.runningFoldIndexed(
    initial: R, 
    operation: (index: Int, acc: R, UByte) -> R
): List<R>

fun <R> UShortArray.runningFoldIndexed(
    initial: R, 
    operation: (index: Int, acc: R, UShort) -> R
): List<R>

fun <T, R> Iterable<T>.runningFoldIndexed(
    initial: R, 
    operation: (index: Int, acc: R, T) -> R
): List<R>

fun <S, T : S> Array<out T>.runningReduce(
    operation: (acc: S, T) -> S
): List<S>

fun ByteArray.runningReduce(
    operation: (acc: Byte, Byte) -> Byte
): List<Byte>

fun ShortArray.runningReduce(
    operation: (acc: Short, Short) -> Short
): List<Short>

fun IntArray.runningReduce(
    operation: (acc: Int, Int) -> Int
): List<Int>

fun LongArray.runningReduce(
    operation: (acc: Long, Long) -> Long
): List<Long>

fun FloatArray.runningReduce(
    operation: (acc: Float, Float) -> Float
): List<Float>

fun DoubleArray.runningReduce(
    operation: (acc: Double, Double) -> Double
): List<Double>

fun BooleanArray.runningReduce(
    operation: (acc: Boolean, Boolean) -> Boolean
): List<Boolean>

fun CharArray.runningReduce(
    operation: (acc: Char, Char) -> Char
): List<Char>

fun UIntArray.runningReduce(
    operation: (acc: UInt, UInt) -> UInt
): List<UInt>

fun ULongArray.runningReduce(
    operation: (acc: ULong, ULong) -> ULong
): List<ULong>

fun UByteArray.runningReduce(
    operation: (acc: UByte, UByte) -> UByte
): List<UByte>

fun UShortArray.runningReduce(
    operation: (acc: UShort, UShort) -> UShort
): List<UShort>

fun <S, T : S> Iterable<T>.runningReduce(
    operation: (acc: S, T) -> S
): List<S>

fun <S, T : S> Array<out T>.runningReduceIndexed(
    operation: (index: Int, acc: S, T) -> S
): List<S>

fun ByteArray.runningReduceIndexed(
    operation: (index: Int, acc: Byte, Byte) -> Byte
): List<Byte>

fun ShortArray.runningReduceIndexed(
    operation: (index: Int, acc: Short, Short) -> Short
): List<Short>

fun IntArray.runningReduceIndexed(
    operation: (index: Int, acc: Int, Int) -> Int
): List<Int>

fun LongArray.runningReduceIndexed(
    operation: (index: Int, acc: Long, Long) -> Long
): List<Long>

fun FloatArray.runningReduceIndexed(
    operation: (index: Int, acc: Float, Float) -> Float
): List<Float>

fun DoubleArray.runningReduceIndexed(
    operation: (index: Int, acc: Double, Double) -> Double
): List<Double>

fun BooleanArray.runningReduceIndexed(
    operation: (index: Int, acc: Boolean, Boolean) -> Boolean
): List<Boolean>

fun CharArray.runningReduceIndexed(
    operation: (index: Int, acc: Char, Char) -> Char
): List<Char>

fun UIntArray.runningReduceIndexed(
    operation: (index: Int, acc: UInt, UInt) -> UInt
): List<UInt>

fun ULongArray.runningReduceIndexed(
    operation: (index: Int, acc: ULong, ULong) -> ULong
): List<ULong>

fun UByteArray.runningReduceIndexed(
    operation: (index: Int, acc: UByte, UByte) -> UByte
): List<UByte>

fun UShortArray.runningReduceIndexed(
    operation: (index: Int, acc: UShort, UShort) -> UShort
): List<UShort>

fun <S, T : S> Iterable<T>.runningReduceIndexed(
    operation: (index: Int, acc: S, T) -> S
): List<S>

fun <T, R> Array<out T>.scan(
    initial: R, 
    operation: (acc: R, T) -> R
): List<R>

fun <R> ByteArray.scan(
    initial: R, 
    operation: (acc: R, Byte) -> R
): List<R>

fun <R> ShortArray.scan(
    initial: R, 
    operation: (acc: R, Short) -> R
): List<R>

fun <R> IntArray.scan(
    initial: R, 
    operation: (acc: R, Int) -> R
): List<R>

fun <R> LongArray.scan(
    initial: R, 
    operation: (acc: R, Long) -> R
): List<R>

fun <R> FloatArray.scan(
    initial: R, 
    operation: (acc: R, Float) -> R
): List<R>

fun <R> DoubleArray.scan(
    initial: R, 
    operation: (acc: R, Double) -> R
): List<R>

fun <R> BooleanArray.scan(
    initial: R, 
    operation: (acc: R, Boolean) -> R
): List<R>

fun <R> CharArray.scan(
    initial: R, 
    operation: (acc: R, Char) -> R
): List<R>

fun <T, R> Iterable<T>.scan(
    initial: R, 
    operation: (acc: R, T) -> R
): List<R>

fun <R> UIntArray.scan(
    initial: R, 
    operation: (acc: R, UInt) -> R
): List<R>

fun <R> ULongArray.scan(
    initial: R, 
    operation: (acc: R, ULong) -> R
): List<R>

fun <R> UByteArray.scan(
    initial: R, 
    operation: (acc: R, UByte) -> R
): List<R>

fun <R> UShortArray.scan(
    initial: R, 
    operation: (acc: R, UShort) -> R
): List<R>

fun <T, R> Array<out T>.scanIndexed(
    initial: R, 
    operation: (index: Int, acc: R, T) -> R
): List<R>

fun <R> ByteArray.scanIndexed(
    initial: R, 
    operation: (index: Int, acc: R, Byte) -> R
): List<R>

fun <R> ShortArray.scanIndexed(
    initial: R, 
    operation: (index: Int, acc: R, Short) -> R
): List<R>

fun <R> IntArray.scanIndexed(
    initial: R, 
    operation: (index: Int, acc: R, Int) -> R
): List<R>

fun <R> LongArray.scanIndexed(
    initial: R, 
    operation: (index: Int, acc: R, Long) -> R
): List<R>

fun <R> FloatArray.scanIndexed(
    initial: R, 
    operation: (index: Int, acc: R, Float) -> R
): List<R>

fun <R> DoubleArray.scanIndexed(
    initial: R, 
    operation: (index: Int, acc: R, Double) -> R
): List<R>

fun <R> BooleanArray.scanIndexed(
    initial: R, 
    operation: (index: Int, acc: R, Boolean) -> R
): List<R>

fun <R> CharArray.scanIndexed(
    initial: R, 
    operation: (index: Int, acc: R, Char) -> R
): List<R>

fun <R> UIntArray.scanIndexed(
    initial: R, 
    operation: (index: Int, acc: R, UInt) -> R
): List<R>

fun <R> ULongArray.scanIndexed(
    initial: R, 
    operation: (index: Int, acc: R, ULong) -> R
): List<R>

fun <R> UByteArray.scanIndexed(
    initial: R, 
    operation: (index: Int, acc: R, UByte) -> R
): List<R>

fun <R> UShortArray.scanIndexed(
    initial: R, 
    operation: (index: Int, acc: R, UShort) -> R
): List<R>

fun <T, R> Iterable<T>.scanIndexed(
    initial: R, 
    operation: (index: Int, acc: R, T) -> R
): List<R>

operator fun <K, V> MutableMap<K, V>.set(key: K, value: V)

fun <T> setOf(vararg elements: T): Set<T>

fun <T> setOf(): Set<T>

fun <T> setOf(element: T): Set<T>

fun <T : Any> setOfNotNull(element: T?): Set<T>

fun <T : Any> setOfNotNull(vararg elements: T?): Set<T>

operator fun <V> MutableMap<in String, in V>.setValue(
    thisRef: Any?, 
    property: KProperty<*>, 
    value: V)

fun <T> Array<T>.shuffle()

fun ByteArray.shuffle()

fun ShortArray.shuffle()

fun IntArray.shuffle()

fun LongArray.shuffle()

fun FloatArray.shuffle()

fun DoubleArray.shuffle()

fun BooleanArray.shuffle()

fun CharArray.shuffle()

fun UIntArray.shuffle()

fun ULongArray.shuffle()

fun UByteArray.shuffle()

fun UShortArray.shuffle()

fun <T> Array<T>.shuffle(random: Random)

fun ByteArray.shuffle(random: Random)

fun ShortArray.shuffle(random: Random)

fun IntArray.shuffle(random: Random)

fun LongArray.shuffle(random: Random)

fun FloatArray.shuffle(random: Random)

fun DoubleArray.shuffle(random: Random)

fun BooleanArray.shuffle(random: Random)

fun CharArray.shuffle(random: Random)

fun UIntArray.shuffle(random: Random)

fun ULongArray.shuffle(random: Random)

fun UByteArray.shuffle(random: Random)

fun UShortArray.shuffle(random: Random)

fun <T> MutableList<T>.shuffle(random: Random)

fun <T> MutableList<T>.shuffle(random: Random)

fun <T> MutableList<T>.shuffle()

fun <T> Iterable<T>.shuffled(random: Random): List<T>

fun <T> Iterable<T>.shuffled(random: Random): List<T>

fun <T> Iterable<T>.shuffled(): List<T>

fun <T> Array<out T>.single(): T

fun ByteArray.single(): Byte

fun ShortArray.single(): Short

fun IntArray.single(): Int

fun LongArray.single(): Long

fun FloatArray.single(): Float

fun DoubleArray.single(): Double

fun BooleanArray.single(): Boolean

fun CharArray.single(): Char

fun UIntArray.single(): UInt

fun ULongArray.single(): ULong

fun UByteArray.single(): UByte

fun UShortArray.single(): UShort

fun <T> Array<out T>.single(predicate: (T) -> Boolean): T

fun ByteArray.single(predicate: (Byte) -> Boolean): Byte

fun ShortArray.single(predicate: (Short) -> Boolean): Short

fun IntArray.single(predicate: (Int) -> Boolean): Int

fun LongArray.single(predicate: (Long) -> Boolean): Long

fun FloatArray.single(predicate: (Float) -> Boolean): Float

fun DoubleArray.single(
    predicate: (Double) -> Boolean
): Double

fun BooleanArray.single(
    predicate: (Boolean) -> Boolean
): Boolean

fun CharArray.single(predicate: (Char) -> Boolean): Char

fun <T> Iterable<T>.single(predicate: (T) -> Boolean): T

fun UIntArray.single(predicate: (UInt) -> Boolean): UInt

fun ULongArray.single(predicate: (ULong) -> Boolean): ULong

fun UByteArray.single(predicate: (UByte) -> Boolean): UByte

fun UShortArray.single(
    predicate: (UShort) -> Boolean
): UShort

fun <T> Iterable<T>.single(): T

fun <T> List<T>.single(): T

fun <T> Array<out T>.singleOrNull(): T?

fun ByteArray.singleOrNull(): Byte?

fun ShortArray.singleOrNull(): Short?

fun IntArray.singleOrNull(): Int?

fun LongArray.singleOrNull(): Long?

fun FloatArray.singleOrNull(): Float?

fun DoubleArray.singleOrNull(): Double?

fun BooleanArray.singleOrNull(): Boolean?

fun CharArray.singleOrNull(): Char?

fun UIntArray.singleOrNull(): UInt?

fun ULongArray.singleOrNull(): ULong?

fun UByteArray.singleOrNull(): UByte?

fun UShortArray.singleOrNull(): UShort?

fun <T> Array<out T>.singleOrNull(
    predicate: (T) -> Boolean
): T?

fun ByteArray.singleOrNull(
    predicate: (Byte) -> Boolean
): Byte?

fun ShortArray.singleOrNull(
    predicate: (Short) -> Boolean
): Short?

fun IntArray.singleOrNull(predicate: (Int) -> Boolean): Int?

fun LongArray.singleOrNull(
    predicate: (Long) -> Boolean
): Long?

fun FloatArray.singleOrNull(
    predicate: (Float) -> Boolean
): Float?

fun DoubleArray.singleOrNull(
    predicate: (Double) -> Boolean
): Double?

fun BooleanArray.singleOrNull(
    predicate: (Boolean) -> Boolean
): Boolean?

fun CharArray.singleOrNull(
    predicate: (Char) -> Boolean
): Char?

fun <T> Iterable<T>.singleOrNull(
    predicate: (T) -> Boolean
): T?

fun UIntArray.singleOrNull(
    predicate: (UInt) -> Boolean
): UInt?

fun ULongArray.singleOrNull(
    predicate: (ULong) -> Boolean
): ULong?

fun UByteArray.singleOrNull(
    predicate: (UByte) -> Boolean
): UByte?

fun UShortArray.singleOrNull(
    predicate: (UShort) -> Boolean
): UShort?

fun <T> Iterable<T>.singleOrNull(): T?

fun <T> List<T>.singleOrNull(): T?

fun <T> Array<out T>.slice(indices: IntRange): List<T>

fun ByteArray.slice(indices: IntRange): List<Byte>

fun ShortArray.slice(indices: IntRange): List<Short>

fun IntArray.slice(indices: IntRange): List<Int>

fun LongArray.slice(indices: IntRange): List<Long>

fun FloatArray.slice(indices: IntRange): List<Float>

fun DoubleArray.slice(indices: IntRange): List<Double>

fun BooleanArray.slice(indices: IntRange): List<Boolean>

fun CharArray.slice(indices: IntRange): List<Char>

fun <T> List<T>.slice(indices: IntRange): List<T>

fun UIntArray.slice(indices: IntRange): List<UInt>

fun ULongArray.slice(indices: IntRange): List<ULong>

fun UByteArray.slice(indices: IntRange): List<UByte>

fun UShortArray.slice(indices: IntRange): List<UShort>

fun <T> Array<out T>.slice(indices: Iterable<Int>): List<T>

fun ByteArray.slice(indices: Iterable<Int>): List<Byte>

fun ShortArray.slice(indices: Iterable<Int>): List<Short>

fun IntArray.slice(indices: Iterable<Int>): List<Int>

fun LongArray.slice(indices: Iterable<Int>): List<Long>

fun FloatArray.slice(indices: Iterable<Int>): List<Float>

fun DoubleArray.slice(indices: Iterable<Int>): List<Double>

fun BooleanArray.slice(indices: Iterable<Int>): List<Boolean>

fun CharArray.slice(indices: Iterable<Int>): List<Char>