diff --git a/libraries/stdlib/src/generated/_Aggregates.kt b/libraries/stdlib/src/generated/_Aggregates.kt
index aedd06d709b..372567d6967 100644
--- a/libraries/stdlib/src/generated/_Aggregates.kt
+++ b/libraries/stdlib/src/generated/_Aggregates.kt
@@ -10,1391 +10,1253 @@ import java.util.*
 /**
  * Returns *true* if all elements match the given *predicate*
  */
-public inline fun <T> Array<out T>.all(predicate: (T) -> Boolean) : Boolean {
+public inline fun <T> Array<out T>.all(predicate: (T) -> Boolean): Boolean {
     for (element in this) if (!predicate(element)) return false
     return true
-    
 }
 
 /**
  * Returns *true* if all elements match the given *predicate*
  */
-public inline fun BooleanArray.all(predicate: (Boolean) -> Boolean) : Boolean {
+public inline fun BooleanArray.all(predicate: (Boolean) -> Boolean): Boolean {
     for (element in this) if (!predicate(element)) return false
     return true
-    
 }
 
 /**
  * Returns *true* if all elements match the given *predicate*
  */
-public inline fun ByteArray.all(predicate: (Byte) -> Boolean) : Boolean {
+public inline fun ByteArray.all(predicate: (Byte) -> Boolean): Boolean {
     for (element in this) if (!predicate(element)) return false
     return true
-    
 }
 
 /**
  * Returns *true* if all elements match the given *predicate*
  */
-public inline fun CharArray.all(predicate: (Char) -> Boolean) : Boolean {
+public inline fun CharArray.all(predicate: (Char) -> Boolean): Boolean {
     for (element in this) if (!predicate(element)) return false
     return true
-    
 }
 
 /**
  * Returns *true* if all elements match the given *predicate*
  */
-public inline fun DoubleArray.all(predicate: (Double) -> Boolean) : Boolean {
+public inline fun DoubleArray.all(predicate: (Double) -> Boolean): Boolean {
     for (element in this) if (!predicate(element)) return false
     return true
-    
 }
 
 /**
  * Returns *true* if all elements match the given *predicate*
  */
-public inline fun FloatArray.all(predicate: (Float) -> Boolean) : Boolean {
+public inline fun FloatArray.all(predicate: (Float) -> Boolean): Boolean {
     for (element in this) if (!predicate(element)) return false
     return true
-    
 }
 
 /**
  * Returns *true* if all elements match the given *predicate*
  */
-public inline fun IntArray.all(predicate: (Int) -> Boolean) : Boolean {
+public inline fun IntArray.all(predicate: (Int) -> Boolean): Boolean {
     for (element in this) if (!predicate(element)) return false
     return true
-    
 }
 
 /**
  * Returns *true* if all elements match the given *predicate*
  */
-public inline fun LongArray.all(predicate: (Long) -> Boolean) : Boolean {
+public inline fun LongArray.all(predicate: (Long) -> Boolean): Boolean {
     for (element in this) if (!predicate(element)) return false
     return true
-    
 }
 
 /**
  * Returns *true* if all elements match the given *predicate*
  */
-public inline fun ShortArray.all(predicate: (Short) -> Boolean) : Boolean {
+public inline fun ShortArray.all(predicate: (Short) -> Boolean): Boolean {
     for (element in this) if (!predicate(element)) return false
     return true
-    
 }
 
 /**
  * Returns *true* if all elements match the given *predicate*
  */
-public inline fun <T> Iterable<T>.all(predicate: (T) -> Boolean) : Boolean {
+public inline fun <T> Iterable<T>.all(predicate: (T) -> Boolean): Boolean {
     for (element in this) if (!predicate(element)) return false
     return true
-    
 }
 
 /**
  * Returns *true* if all elements match the given *predicate*
  */
-public inline fun <K, V> Map<K,V>.all(predicate: (Map.Entry<K,V>) -> Boolean) : Boolean {
+public inline fun <K, V> Map<K, V>.all(predicate: (Map.Entry<K, V>) -> Boolean): Boolean {
     for (element in this) if (!predicate(element)) return false
     return true
-    
 }
 
 /**
  * Returns *true* if all elements match the given *predicate*
  */
-public inline fun <T> Stream<T>.all(predicate: (T) -> Boolean) : Boolean {
+public inline fun <T> Stream<T>.all(predicate: (T) -> Boolean): Boolean {
     for (element in this) if (!predicate(element)) return false
     return true
-    
 }
 
 /**
  * Returns *true* if all elements match the given *predicate*
  */
-public inline fun String.all(predicate: (Char) -> Boolean) : Boolean {
+public inline fun String.all(predicate: (Char) -> Boolean): Boolean {
     for (element in this) if (!predicate(element)) return false
     return true
-    
 }
 
 /**
  * Returns *true* if collection has at least one element
  */
-public fun <T> Array<out T>.any() : Boolean {
+public fun <T> Array<out T>.any(): Boolean {
     for (element in this) return true
     return false
-    
 }
 
 /**
  * Returns *true* if collection has at least one element
  */
-public fun BooleanArray.any() : Boolean {
+public fun BooleanArray.any(): Boolean {
     for (element in this) return true
     return false
-    
 }
 
 /**
  * Returns *true* if collection has at least one element
  */
-public fun ByteArray.any() : Boolean {
+public fun ByteArray.any(): Boolean {
     for (element in this) return true
     return false
-    
 }
 
 /**
  * Returns *true* if collection has at least one element
  */
-public fun CharArray.any() : Boolean {
+public fun CharArray.any(): Boolean {
     for (element in this) return true
     return false
-    
 }
 
 /**
  * Returns *true* if collection has at least one element
  */
-public fun DoubleArray.any() : Boolean {
+public fun DoubleArray.any(): Boolean {
     for (element in this) return true
     return false
-    
 }
 
 /**
  * Returns *true* if collection has at least one element
  */
-public fun FloatArray.any() : Boolean {
+public fun FloatArray.any(): Boolean {
     for (element in this) return true
     return false
-    
 }
 
 /**
  * Returns *true* if collection has at least one element
  */
-public fun IntArray.any() : Boolean {
+public fun IntArray.any(): Boolean {
     for (element in this) return true
     return false
-    
 }
 
 /**
  * Returns *true* if collection has at least one element
  */
-public fun LongArray.any() : Boolean {
+public fun LongArray.any(): Boolean {
     for (element in this) return true
     return false
-    
 }
 
 /**
  * Returns *true* if collection has at least one element
  */
-public fun ShortArray.any() : Boolean {
+public fun ShortArray.any(): Boolean {
     for (element in this) return true
     return false
-    
 }
 
 /**
  * Returns *true* if collection has at least one element
  */
-public fun <T> Iterable<T>.any() : Boolean {
+public fun <T> Iterable<T>.any(): Boolean {
     for (element in this) return true
     return false
-    
 }
 
 /**
  * Returns *true* if collection has at least one element
  */
-public fun <K, V> Map<K,V>.any() : Boolean {
+public fun <K, V> Map<K, V>.any(): Boolean {
     for (element in this) return true
     return false
-    
 }
 
 /**
  * Returns *true* if collection has at least one element
  */
-public fun <T> Stream<T>.any() : Boolean {
+public fun <T> Stream<T>.any(): Boolean {
     for (element in this) return true
     return false
-    
 }
 
 /**
  * Returns *true* if collection has at least one element
  */
-public fun String.any() : Boolean {
+public fun String.any(): Boolean {
     for (element in this) return true
     return false
-    
 }
 
 /**
  * Returns *true* if any element matches the given *predicate*
  */
-public inline fun <T> Array<out T>.any(predicate: (T) -> Boolean) : Boolean {
+public inline fun <T> Array<out T>.any(predicate: (T) -> Boolean): Boolean {
     for (element in this) if (predicate(element)) return true
     return false
-    
 }
 
 /**
  * Returns *true* if any element matches the given *predicate*
  */
-public inline fun BooleanArray.any(predicate: (Boolean) -> Boolean) : Boolean {
+public inline fun BooleanArray.any(predicate: (Boolean) -> Boolean): Boolean {
     for (element in this) if (predicate(element)) return true
     return false
-    
 }
 
 /**
  * Returns *true* if any element matches the given *predicate*
  */
-public inline fun ByteArray.any(predicate: (Byte) -> Boolean) : Boolean {
+public inline fun ByteArray.any(predicate: (Byte) -> Boolean): Boolean {
     for (element in this) if (predicate(element)) return true
     return false
-    
 }
 
 /**
  * Returns *true* if any element matches the given *predicate*
  */
-public inline fun CharArray.any(predicate: (Char) -> Boolean) : Boolean {
+public inline fun CharArray.any(predicate: (Char) -> Boolean): Boolean {
     for (element in this) if (predicate(element)) return true
     return false
-    
 }
 
 /**
  * Returns *true* if any element matches the given *predicate*
  */
-public inline fun DoubleArray.any(predicate: (Double) -> Boolean) : Boolean {
+public inline fun DoubleArray.any(predicate: (Double) -> Boolean): Boolean {
     for (element in this) if (predicate(element)) return true
     return false
-    
 }
 
 /**
  * Returns *true* if any element matches the given *predicate*
  */
-public inline fun FloatArray.any(predicate: (Float) -> Boolean) : Boolean {
+public inline fun FloatArray.any(predicate: (Float) -> Boolean): Boolean {
     for (element in this) if (predicate(element)) return true
     return false
-    
 }
 
 /**
  * Returns *true* if any element matches the given *predicate*
  */
-public inline fun IntArray.any(predicate: (Int) -> Boolean) : Boolean {
+public inline fun IntArray.any(predicate: (Int) -> Boolean): Boolean {
     for (element in this) if (predicate(element)) return true
     return false
-    
 }
 
 /**
  * Returns *true* if any element matches the given *predicate*
  */
-public inline fun LongArray.any(predicate: (Long) -> Boolean) : Boolean {
+public inline fun LongArray.any(predicate: (Long) -> Boolean): Boolean {
     for (element in this) if (predicate(element)) return true
     return false
-    
 }
 
 /**
  * Returns *true* if any element matches the given *predicate*
  */
-public inline fun ShortArray.any(predicate: (Short) -> Boolean) : Boolean {
+public inline fun ShortArray.any(predicate: (Short) -> Boolean): Boolean {
     for (element in this) if (predicate(element)) return true
     return false
-    
 }
 
 /**
  * Returns *true* if any element matches the given *predicate*
  */
-public inline fun <T> Iterable<T>.any(predicate: (T) -> Boolean) : Boolean {
+public inline fun <T> Iterable<T>.any(predicate: (T) -> Boolean): Boolean {
     for (element in this) if (predicate(element)) return true
     return false
-    
 }
 
 /**
  * Returns *true* if any element matches the given *predicate*
  */
-public inline fun <K, V> Map<K,V>.any(predicate: (Map.Entry<K,V>) -> Boolean) : Boolean {
+public inline fun <K, V> Map<K, V>.any(predicate: (Map.Entry<K, V>) -> Boolean): Boolean {
     for (element in this) if (predicate(element)) return true
     return false
-    
 }
 
 /**
  * Returns *true* if any element matches the given *predicate*
  */
-public inline fun <T> Stream<T>.any(predicate: (T) -> Boolean) : Boolean {
+public inline fun <T> Stream<T>.any(predicate: (T) -> Boolean): Boolean {
     for (element in this) if (predicate(element)) return true
     return false
-    
 }
 
 /**
  * Returns *true* if any element matches the given *predicate*
  */
-public inline fun String.any(predicate: (Char) -> Boolean) : Boolean {
+public inline fun String.any(predicate: (Char) -> Boolean): Boolean {
     for (element in this) if (predicate(element)) return true
     return false
-    
 }
 
 /**
  * Returns the number of elements
  */
-public fun <T> Array<out T>.count() : Int {
+public fun <T> Array<out T>.count(): Int {
     return size
 }
 
 /**
  * Returns the number of elements
  */
-public fun BooleanArray.count() : Int {
+public fun BooleanArray.count(): Int {
     return size
 }
 
 /**
  * Returns the number of elements
  */
-public fun ByteArray.count() : Int {
+public fun ByteArray.count(): Int {
     return size
 }
 
 /**
  * Returns the number of elements
  */
-public fun CharArray.count() : Int {
+public fun CharArray.count(): Int {
     return size
 }
 
 /**
  * Returns the number of elements
  */
-public fun DoubleArray.count() : Int {
+public fun DoubleArray.count(): Int {
     return size
 }
 
 /**
  * Returns the number of elements
  */
-public fun FloatArray.count() : Int {
+public fun FloatArray.count(): Int {
     return size
 }
 
 /**
  * Returns the number of elements
  */
-public fun IntArray.count() : Int {
+public fun IntArray.count(): Int {
     return size
 }
 
 /**
  * Returns the number of elements
  */
-public fun LongArray.count() : Int {
+public fun LongArray.count(): Int {
     return size
 }
 
 /**
  * Returns the number of elements
  */
-public fun ShortArray.count() : Int {
+public fun ShortArray.count(): Int {
     return size
 }
 
 /**
  * Returns the number of elements
  */
-public fun <T> Collection<T>.count() : Int {
+public fun <T> Collection<T>.count(): Int {
     return size
 }
 
 /**
  * Returns the number of elements
  */
-public fun <T> Iterable<T>.count() : Int {
+public fun <T> Iterable<T>.count(): Int {
     var count = 0
     for (element in this) count++
     return count
-    
 }
 
 /**
  * Returns the number of elements
  */
-public fun <K, V> Map<K,V>.count() : Int {
+public fun <K, V> Map<K, V>.count(): Int {
     return size
 }
 
 /**
  * Returns the number of elements
  */
-public fun <T> Stream<T>.count() : Int {
+public fun <T> Stream<T>.count(): Int {
     var count = 0
     for (element in this) count++
     return count
-    
 }
 
 /**
  * Returns the number of elements
  */
-public fun String.count() : Int {
+public fun String.count(): Int {
     return size
 }
 
 /**
  * Returns the number of elements matching the given *predicate*
  */
-public inline fun <T> Array<out T>.count(predicate: (T) -> Boolean) : Int {
+public inline fun <T> Array<out T>.count(predicate: (T) -> Boolean): Int {
     var count = 0
     for (element in this) if (predicate(element)) count++
     return count
-    
 }
 
 /**
  * Returns the number of elements matching the given *predicate*
  */
-public inline fun BooleanArray.count(predicate: (Boolean) -> Boolean) : Int {
+public inline fun BooleanArray.count(predicate: (Boolean) -> Boolean): Int {
     var count = 0
     for (element in this) if (predicate(element)) count++
     return count
-    
 }
 
 /**
  * Returns the number of elements matching the given *predicate*
  */
-public inline fun ByteArray.count(predicate: (Byte) -> Boolean) : Int {
+public inline fun ByteArray.count(predicate: (Byte) -> Boolean): Int {
     var count = 0
     for (element in this) if (predicate(element)) count++
     return count
-    
 }
 
 /**
  * Returns the number of elements matching the given *predicate*
  */
-public inline fun CharArray.count(predicate: (Char) -> Boolean) : Int {
+public inline fun CharArray.count(predicate: (Char) -> Boolean): Int {
     var count = 0
     for (element in this) if (predicate(element)) count++
     return count
-    
 }
 
 /**
  * Returns the number of elements matching the given *predicate*
  */
-public inline fun DoubleArray.count(predicate: (Double) -> Boolean) : Int {
+public inline fun DoubleArray.count(predicate: (Double) -> Boolean): Int {
     var count = 0
     for (element in this) if (predicate(element)) count++
     return count
-    
 }
 
 /**
  * Returns the number of elements matching the given *predicate*
  */
-public inline fun FloatArray.count(predicate: (Float) -> Boolean) : Int {
+public inline fun FloatArray.count(predicate: (Float) -> Boolean): Int {
     var count = 0
     for (element in this) if (predicate(element)) count++
     return count
-    
 }
 
 /**
  * Returns the number of elements matching the given *predicate*
  */
-public inline fun IntArray.count(predicate: (Int) -> Boolean) : Int {
+public inline fun IntArray.count(predicate: (Int) -> Boolean): Int {
     var count = 0
     for (element in this) if (predicate(element)) count++
     return count
-    
 }
 
 /**
  * Returns the number of elements matching the given *predicate*
  */
-public inline fun LongArray.count(predicate: (Long) -> Boolean) : Int {
+public inline fun LongArray.count(predicate: (Long) -> Boolean): Int {
     var count = 0
     for (element in this) if (predicate(element)) count++
     return count
-    
 }
 
 /**
  * Returns the number of elements matching the given *predicate*
  */
-public inline fun ShortArray.count(predicate: (Short) -> Boolean) : Int {
+public inline fun ShortArray.count(predicate: (Short) -> Boolean): Int {
     var count = 0
     for (element in this) if (predicate(element)) count++
     return count
-    
 }
 
 /**
  * Returns the number of elements matching the given *predicate*
  */
-public inline fun <T> Iterable<T>.count(predicate: (T) -> Boolean) : Int {
+public inline fun <T> Iterable<T>.count(predicate: (T) -> Boolean): Int {
     var count = 0
     for (element in this) if (predicate(element)) count++
     return count
-    
 }
 
 /**
  * Returns the number of elements matching the given *predicate*
  */
-public inline fun <K, V> Map<K,V>.count(predicate: (Map.Entry<K,V>) -> Boolean) : Int {
+public inline fun <K, V> Map<K, V>.count(predicate: (Map.Entry<K, V>) -> Boolean): Int {
     var count = 0
     for (element in this) if (predicate(element)) count++
     return count
-    
 }
 
 /**
  * Returns the number of elements matching the given *predicate*
  */
-public inline fun <T> Stream<T>.count(predicate: (T) -> Boolean) : Int {
+public inline fun <T> Stream<T>.count(predicate: (T) -> Boolean): Int {
     var count = 0
     for (element in this) if (predicate(element)) count++
     return count
-    
 }
 
 /**
  * Returns the number of elements matching the given *predicate*
  */
-public inline fun String.count(predicate: (Char) -> Boolean) : Int {
+public inline fun String.count(predicate: (Char) -> Boolean): Int {
     var count = 0
     for (element in this) if (predicate(element)) count++
     return count
-    
 }
 
 /**
  * Accumulates value starting with *initial* value and applying *operation* from left to right to current accumulator value and each element
  */
-public inline fun <T, R> Array<out T>.fold(initial: R, operation: (R, T) -> R) : R {
+public inline fun <T, R> Array<out T>.fold(initial: R, operation: (R, T) -> R): R {
     var accumulator = initial
     for (element in this) accumulator = operation(accumulator, element)
     return accumulator
-    
 }
 
 /**
  * Accumulates value starting with *initial* value and applying *operation* from left to right to current accumulator value and each element
  */
-public inline fun <R> BooleanArray.fold(initial: R, operation: (R, Boolean) -> R) : R {
+public inline fun <R> BooleanArray.fold(initial: R, operation: (R, Boolean) -> R): R {
     var accumulator = initial
     for (element in this) accumulator = operation(accumulator, element)
     return accumulator
-    
 }
 
 /**
  * Accumulates value starting with *initial* value and applying *operation* from left to right to current accumulator value and each element
  */
-public inline fun <R> ByteArray.fold(initial: R, operation: (R, Byte) -> R) : R {
+public inline fun <R> ByteArray.fold(initial: R, operation: (R, Byte) -> R): R {
     var accumulator = initial
     for (element in this) accumulator = operation(accumulator, element)
     return accumulator
-    
 }
 
 /**
  * Accumulates value starting with *initial* value and applying *operation* from left to right to current accumulator value and each element
  */
-public inline fun <R> CharArray.fold(initial: R, operation: (R, Char) -> R) : R {
+public inline fun <R> CharArray.fold(initial: R, operation: (R, Char) -> R): R {
     var accumulator = initial
     for (element in this) accumulator = operation(accumulator, element)
     return accumulator
-    
 }
 
 /**
  * Accumulates value starting with *initial* value and applying *operation* from left to right to current accumulator value and each element
  */
-public inline fun <R> DoubleArray.fold(initial: R, operation: (R, Double) -> R) : R {
+public inline fun <R> DoubleArray.fold(initial: R, operation: (R, Double) -> R): R {
     var accumulator = initial
     for (element in this) accumulator = operation(accumulator, element)
     return accumulator
-    
 }
 
 /**
  * Accumulates value starting with *initial* value and applying *operation* from left to right to current accumulator value and each element
  */
-public inline fun <R> FloatArray.fold(initial: R, operation: (R, Float) -> R) : R {
+public inline fun <R> FloatArray.fold(initial: R, operation: (R, Float) -> R): R {
     var accumulator = initial
     for (element in this) accumulator = operation(accumulator, element)
     return accumulator
-    
 }
 
 /**
  * Accumulates value starting with *initial* value and applying *operation* from left to right to current accumulator value and each element
  */
-public inline fun <R> IntArray.fold(initial: R, operation: (R, Int) -> R) : R {
+public inline fun <R> IntArray.fold(initial: R, operation: (R, Int) -> R): R {
     var accumulator = initial
     for (element in this) accumulator = operation(accumulator, element)
     return accumulator
-    
 }
 
 /**
  * Accumulates value starting with *initial* value and applying *operation* from left to right to current accumulator value and each element
  */
-public inline fun <R> LongArray.fold(initial: R, operation: (R, Long) -> R) : R {
+public inline fun <R> LongArray.fold(initial: R, operation: (R, Long) -> R): R {
     var accumulator = initial
     for (element in this) accumulator = operation(accumulator, element)
     return accumulator
-    
 }
 
 /**
  * Accumulates value starting with *initial* value and applying *operation* from left to right to current accumulator value and each element
  */
-public inline fun <R> ShortArray.fold(initial: R, operation: (R, Short) -> R) : R {
+public inline fun <R> ShortArray.fold(initial: R, operation: (R, Short) -> R): R {
     var accumulator = initial
     for (element in this) accumulator = operation(accumulator, element)
     return accumulator
-    
 }
 
 /**
  * Accumulates value starting with *initial* value and applying *operation* from left to right to current accumulator value and each element
  */
-public inline fun <T, R> Iterable<T>.fold(initial: R, operation: (R, T) -> R) : R {
+public inline fun <T, R> Iterable<T>.fold(initial: R, operation: (R, T) -> R): R {
     var accumulator = initial
     for (element in this) accumulator = operation(accumulator, element)
     return accumulator
-    
 }
 
 /**
  * Accumulates value starting with *initial* value and applying *operation* from left to right to current accumulator value and each element
  */
-public inline fun <T, R> Stream<T>.fold(initial: R, operation: (R, T) -> R) : R {
+public inline fun <T, R> Stream<T>.fold(initial: R, operation: (R, T) -> R): R {
     var accumulator = initial
     for (element in this) accumulator = operation(accumulator, element)
     return accumulator
-    
 }
 
 /**
  * Accumulates value starting with *initial* value and applying *operation* from left to right to current accumulator value and each element
  */
-public inline fun <R> String.fold(initial: R, operation: (R, Char) -> R) : R {
+public inline fun <R> String.fold(initial: R, operation: (R, Char) -> R): R {
     var accumulator = initial
     for (element in this) accumulator = operation(accumulator, element)
     return accumulator
-    
 }
 
 /**
  * Accumulates value starting with *initial* value and applying *operation* from right to left to each element and current accumulator value
  */
-public inline fun <T, R> Array<out T>.foldRight(initial: R, operation: (T, R) -> R) : R {
+public inline fun <T, R> Array<out T>.foldRight(initial: R, operation: (T, R) -> R): R {
     var index = size - 1
     var accumulator = initial
     while (index >= 0) {
         accumulator = operation(get(index--), accumulator)
     }
     return accumulator
-    
 }
 
 /**
  * Accumulates value starting with *initial* value and applying *operation* from right to left to each element and current accumulator value
  */
-public inline fun <R> BooleanArray.foldRight(initial: R, operation: (Boolean, R) -> R) : R {
+public inline fun <R> BooleanArray.foldRight(initial: R, operation: (Boolean, R) -> R): R {
     var index = size - 1
     var accumulator = initial
     while (index >= 0) {
         accumulator = operation(get(index--), accumulator)
     }
     return accumulator
-    
 }
 
 /**
  * Accumulates value starting with *initial* value and applying *operation* from right to left to each element and current accumulator value
  */
-public inline fun <R> ByteArray.foldRight(initial: R, operation: (Byte, R) -> R) : R {
+public inline fun <R> ByteArray.foldRight(initial: R, operation: (Byte, R) -> R): R {
     var index = size - 1
     var accumulator = initial
     while (index >= 0) {
         accumulator = operation(get(index--), accumulator)
     }
     return accumulator
-    
 }
 
 /**
  * Accumulates value starting with *initial* value and applying *operation* from right to left to each element and current accumulator value
  */
-public inline fun <R> CharArray.foldRight(initial: R, operation: (Char, R) -> R) : R {
+public inline fun <R> CharArray.foldRight(initial: R, operation: (Char, R) -> R): R {
     var index = size - 1
     var accumulator = initial
     while (index >= 0) {
         accumulator = operation(get(index--), accumulator)
     }
     return accumulator
-    
 }
 
 /**
  * Accumulates value starting with *initial* value and applying *operation* from right to left to each element and current accumulator value
  */
-public inline fun <R> DoubleArray.foldRight(initial: R, operation: (Double, R) -> R) : R {
+public inline fun <R> DoubleArray.foldRight(initial: R, operation: (Double, R) -> R): R {
     var index = size - 1
     var accumulator = initial
     while (index >= 0) {
         accumulator = operation(get(index--), accumulator)
     }
     return accumulator
-    
 }
 
 /**
  * Accumulates value starting with *initial* value and applying *operation* from right to left to each element and current accumulator value
  */
-public inline fun <R> FloatArray.foldRight(initial: R, operation: (Float, R) -> R) : R {
+public inline fun <R> FloatArray.foldRight(initial: R, operation: (Float, R) -> R): R {
     var index = size - 1
     var accumulator = initial
     while (index >= 0) {
         accumulator = operation(get(index--), accumulator)
     }
     return accumulator
-    
 }
 
 /**
  * Accumulates value starting with *initial* value and applying *operation* from right to left to each element and current accumulator value
  */
-public inline fun <R> IntArray.foldRight(initial: R, operation: (Int, R) -> R) : R {
+public inline fun <R> IntArray.foldRight(initial: R, operation: (Int, R) -> R): R {
     var index = size - 1
     var accumulator = initial
     while (index >= 0) {
         accumulator = operation(get(index--), accumulator)
     }
     return accumulator
-    
 }
 
 /**
  * Accumulates value starting with *initial* value and applying *operation* from right to left to each element and current accumulator value
  */
-public inline fun <R> LongArray.foldRight(initial: R, operation: (Long, R) -> R) : R {
+public inline fun <R> LongArray.foldRight(initial: R, operation: (Long, R) -> R): R {
     var index = size - 1
     var accumulator = initial
     while (index >= 0) {
         accumulator = operation(get(index--), accumulator)
     }
     return accumulator
-    
 }
 
 /**
  * Accumulates value starting with *initial* value and applying *operation* from right to left to each element and current accumulator value
  */
-public inline fun <R> ShortArray.foldRight(initial: R, operation: (Short, R) -> R) : R {
+public inline fun <R> ShortArray.foldRight(initial: R, operation: (Short, R) -> R): R {
     var index = size - 1
     var accumulator = initial
     while (index >= 0) {
         accumulator = operation(get(index--), accumulator)
     }
     return accumulator
-    
 }
 
 /**
  * Accumulates value starting with *initial* value and applying *operation* from right to left to each element and current accumulator value
  */
-public inline fun <T, R> List<T>.foldRight(initial: R, operation: (T, R) -> R) : R {
+public inline fun <T, R> List<T>.foldRight(initial: R, operation: (T, R) -> R): R {
     var index = size - 1
     var accumulator = initial
     while (index >= 0) {
         accumulator = operation(get(index--), accumulator)
     }
     return accumulator
-    
 }
 
 /**
  * Accumulates value starting with *initial* value and applying *operation* from right to left to each element and current accumulator value
  */
-public inline fun <R> String.foldRight(initial: R, operation: (Char, R) -> R) : R {
+public inline fun <R> String.foldRight(initial: R, operation: (Char, R) -> R): R {
     var index = size - 1
     var accumulator = initial
     while (index >= 0) {
         accumulator = operation(get(index--), accumulator)
     }
     return accumulator
-    
 }
 
 /**
  * Performs the given *operation* on each element
  */
-public inline fun <T> Array<out T>.forEach(operation: (T) -> Unit) : Unit {
+public inline fun <T> Array<out T>.forEach(operation: (T) -> Unit): Unit {
     for (element in this) operation(element)
-    
 }
 
 /**
  * Performs the given *operation* on each element
  */
-public inline fun BooleanArray.forEach(operation: (Boolean) -> Unit) : Unit {
+public inline fun BooleanArray.forEach(operation: (Boolean) -> Unit): Unit {
     for (element in this) operation(element)
-    
 }
 
 /**
  * Performs the given *operation* on each element
  */
-public inline fun ByteArray.forEach(operation: (Byte) -> Unit) : Unit {
+public inline fun ByteArray.forEach(operation: (Byte) -> Unit): Unit {
     for (element in this) operation(element)
-    
 }
 
 /**
  * Performs the given *operation* on each element
  */
-public inline fun CharArray.forEach(operation: (Char) -> Unit) : Unit {
+public inline fun CharArray.forEach(operation: (Char) -> Unit): Unit {
     for (element in this) operation(element)
-    
 }
 
 /**
  * Performs the given *operation* on each element
  */
-public inline fun DoubleArray.forEach(operation: (Double) -> Unit) : Unit {
+public inline fun DoubleArray.forEach(operation: (Double) -> Unit): Unit {
     for (element in this) operation(element)
-    
 }
 
 /**
  * Performs the given *operation* on each element
  */
-public inline fun FloatArray.forEach(operation: (Float) -> Unit) : Unit {
+public inline fun FloatArray.forEach(operation: (Float) -> Unit): Unit {
     for (element in this) operation(element)
-    
 }
 
 /**
  * Performs the given *operation* on each element
  */
-public inline fun IntArray.forEach(operation: (Int) -> Unit) : Unit {
+public inline fun IntArray.forEach(operation: (Int) -> Unit): Unit {
     for (element in this) operation(element)
-    
 }
 
 /**
  * Performs the given *operation* on each element
  */
-public inline fun LongArray.forEach(operation: (Long) -> Unit) : Unit {
+public inline fun LongArray.forEach(operation: (Long) -> Unit): Unit {
     for (element in this) operation(element)
-    
 }
 
 /**
  * Performs the given *operation* on each element
  */
-public inline fun ShortArray.forEach(operation: (Short) -> Unit) : Unit {
+public inline fun ShortArray.forEach(operation: (Short) -> Unit): Unit {
     for (element in this) operation(element)
-    
 }
 
 /**
  * Performs the given *operation* on each element
  */
-public inline fun <T> Iterable<T>.forEach(operation: (T) -> Unit) : Unit {
+public inline fun <T> Iterable<T>.forEach(operation: (T) -> Unit): Unit {
     for (element in this) operation(element)
-    
 }
 
 /**
  * Performs the given *operation* on each element
  */
-public inline fun <K, V> Map<K,V>.forEach(operation: (Map.Entry<K,V>) -> Unit) : Unit {
+public inline fun <K, V> Map<K, V>.forEach(operation: (Map.Entry<K, V>) -> Unit): Unit {
     for (element in this) operation(element)
-    
 }
 
 /**
  * Performs the given *operation* on each element
  */
-public inline fun <T> Stream<T>.forEach(operation: (T) -> Unit) : Unit {
+public inline fun <T> Stream<T>.forEach(operation: (T) -> Unit): Unit {
     for (element in this) operation(element)
-    
 }
 
 /**
  * Performs the given *operation* on each element
  */
-public inline fun String.forEach(operation: (Char) -> Unit) : Unit {
+public inline fun String.forEach(operation: (Char) -> Unit): Unit {
     for (element in this) operation(element)
-    
 }
 
 /**
  * Returns the largest element or null if there are no elements
  */
-public fun <T: Comparable<T>> Array<out T>.max() : T? {
+public fun <T : Comparable<T>> Array<out T>.max(): T? {
     if (isEmpty()) return null
-    
     var max = this[0]
     for (i in 1..lastIndex) {
         val e = this[i]
         if (max < e) max = e
     }
     return max
-    
 }
 
 /**
  * Returns the largest element or null if there are no elements
  */
-public fun ByteArray.max() : Byte? {
+public fun ByteArray.max(): Byte? {
     if (isEmpty()) return null
-    
     var max = this[0]
     for (i in 1..lastIndex) {
         val e = this[i]
         if (max < e) max = e
     }
     return max
-    
 }
 
 /**
  * Returns the largest element or null if there are no elements
  */
-public fun CharArray.max() : Char? {
+public fun CharArray.max(): Char? {
     if (isEmpty()) return null
-    
     var max = this[0]
     for (i in 1..lastIndex) {
         val e = this[i]
         if (max < e) max = e
     }
     return max
-    
 }
 
 /**
  * Returns the largest element or null if there are no elements
  */
-public fun DoubleArray.max() : Double? {
+public fun DoubleArray.max(): Double? {
     if (isEmpty()) return null
-    
     var max = this[0]
     for (i in 1..lastIndex) {
         val e = this[i]
         if (max < e) max = e
     }
     return max
-    
 }
 
 /**
  * Returns the largest element or null if there are no elements
  */
-public fun FloatArray.max() : Float? {
+public fun FloatArray.max(): Float? {
     if (isEmpty()) return null
-    
     var max = this[0]
     for (i in 1..lastIndex) {
         val e = this[i]
         if (max < e) max = e
     }
     return max
-    
 }
 
 /**
  * Returns the largest element or null if there are no elements
  */
-public fun IntArray.max() : Int? {
+public fun IntArray.max(): Int? {
     if (isEmpty()) return null
-    
     var max = this[0]
     for (i in 1..lastIndex) {
         val e = this[i]
         if (max < e) max = e
     }
     return max
-    
 }
 
 /**
  * Returns the largest element or null if there are no elements
  */
-public fun LongArray.max() : Long? {
+public fun LongArray.max(): Long? {
     if (isEmpty()) return null
-    
     var max = this[0]
     for (i in 1..lastIndex) {
         val e = this[i]
         if (max < e) max = e
     }
     return max
-    
 }
 
 /**
  * Returns the largest element or null if there are no elements
  */
-public fun ShortArray.max() : Short? {
+public fun ShortArray.max(): Short? {
     if (isEmpty()) return null
-    
     var max = this[0]
     for (i in 1..lastIndex) {
         val e = this[i]
         if (max < e) max = e
     }
     return max
-    
 }
 
 /**
  * Returns the largest element or null if there are no elements
  */
-public fun <T: Comparable<T>> Iterable<T>.max() : T? {
+public fun <T : Comparable<T>> Iterable<T>.max(): T? {
     val iterator = iterator()
     if (!iterator.hasNext()) return null
-    
     var max = iterator.next()
     while (iterator.hasNext()) {
         val e = iterator.next()
         if (max < e) max = e
     }
     return max
-    
 }
 
 /**
  * Returns the largest element or null if there are no elements
  */
-public fun <T: Comparable<T>> Stream<T>.max() : T? {
+public fun <T : Comparable<T>> Stream<T>.max(): T? {
     val iterator = iterator()
     if (!iterator.hasNext()) return null
-    
     var max = iterator.next()
     while (iterator.hasNext()) {
         val e = iterator.next()
         if (max < e) max = e
     }
     return max
-    
 }
 
 /**
  * Returns the largest element or null if there are no elements
  */
-public fun String.max() : Char? {
+public fun String.max(): Char? {
     val iterator = iterator()
     if (!iterator.hasNext()) return null
-    
     var max = iterator.next()
     while (iterator.hasNext()) {
         val e = iterator.next()
         if (max < e) max = e
     }
     return max
-    
 }
 
 /**
  * Returns the first element yielding the largest value of the given function or null if there are no elements
  */
-public inline fun <R: Comparable<R>, T: Any> Array<out T>.maxBy(f: (T) -> R) : T? {
+public inline fun <R : Comparable<R>, T : Any> Array<out T>.maxBy(f: (T) -> R): T? {
     if (isEmpty()) return null
-    
     var maxElem = this[0]
     var maxValue = f(maxElem)
     for (i in 1..lastIndex) {
         val e = this[i]
         val v = f(e)
         if (maxValue < v) {
-           maxElem = e
-           maxValue = v
+            maxElem = e
+            maxValue = v
         }
     }
     return maxElem
-    
 }
 
 /**
  * Returns the first element yielding the largest value of the given function or null if there are no elements
  */
-public inline fun <R: Comparable<R>> BooleanArray.maxBy(f: (Boolean) -> R) : Boolean? {
+public inline fun <R : Comparable<R>> BooleanArray.maxBy(f: (Boolean) -> R): Boolean? {
     if (isEmpty()) return null
-    
     var maxElem = this[0]
     var maxValue = f(maxElem)
     for (i in 1..lastIndex) {
         val e = this[i]
         val v = f(e)
         if (maxValue < v) {
-           maxElem = e
-           maxValue = v
+            maxElem = e
+            maxValue = v
         }
     }
     return maxElem
-    
 }
 
 /**
  * Returns the first element yielding the largest value of the given function or null if there are no elements
  */
-public inline fun <R: Comparable<R>> ByteArray.maxBy(f: (Byte) -> R) : Byte? {
+public inline fun <R : Comparable<R>> ByteArray.maxBy(f: (Byte) -> R): Byte? {
     if (isEmpty()) return null
-    
     var maxElem = this[0]
     var maxValue = f(maxElem)
     for (i in 1..lastIndex) {
         val e = this[i]
         val v = f(e)
         if (maxValue < v) {
-           maxElem = e
-           maxValue = v
+            maxElem = e
+            maxValue = v
         }
     }
     return maxElem
-    
 }
 
 /**
  * Returns the first element yielding the largest value of the given function or null if there are no elements
  */
-public inline fun <R: Comparable<R>> CharArray.maxBy(f: (Char) -> R) : Char? {
+public inline fun <R : Comparable<R>> CharArray.maxBy(f: (Char) -> R): Char? {
     if (isEmpty()) return null
-    
     var maxElem = this[0]
     var maxValue = f(maxElem)
     for (i in 1..lastIndex) {
         val e = this[i]
         val v = f(e)
         if (maxValue < v) {
-           maxElem = e
-           maxValue = v
+            maxElem = e
+            maxValue = v
         }
     }
     return maxElem
-    
 }
 
 /**
  * Returns the first element yielding the largest value of the given function or null if there are no elements
  */
-public inline fun <R: Comparable<R>> DoubleArray.maxBy(f: (Double) -> R) : Double? {
+public inline fun <R : Comparable<R>> DoubleArray.maxBy(f: (Double) -> R): Double? {
     if (isEmpty()) return null
-    
     var maxElem = this[0]
     var maxValue = f(maxElem)
     for (i in 1..lastIndex) {
         val e = this[i]
         val v = f(e)
         if (maxValue < v) {
-           maxElem = e
-           maxValue = v
+            maxElem = e
+            maxValue = v
         }
     }
     return maxElem
-    
 }
 
 /**
  * Returns the first element yielding the largest value of the given function or null if there are no elements
  */
-public inline fun <R: Comparable<R>> FloatArray.maxBy(f: (Float) -> R) : Float? {
+public inline fun <R : Comparable<R>> FloatArray.maxBy(f: (Float) -> R): Float? {
     if (isEmpty()) return null
-    
     var maxElem = this[0]
     var maxValue = f(maxElem)
     for (i in 1..lastIndex) {
         val e = this[i]
         val v = f(e)
         if (maxValue < v) {
-           maxElem = e
-           maxValue = v
+            maxElem = e
+            maxValue = v
         }
     }
     return maxElem
-    
 }
 
 /**
  * Returns the first element yielding the largest value of the given function or null if there are no elements
  */
-public inline fun <R: Comparable<R>> IntArray.maxBy(f: (Int) -> R) : Int? {
+public inline fun <R : Comparable<R>> IntArray.maxBy(f: (Int) -> R): Int? {
     if (isEmpty()) return null
-    
     var maxElem = this[0]
     var maxValue = f(maxElem)
     for (i in 1..lastIndex) {
         val e = this[i]
         val v = f(e)
         if (maxValue < v) {
-           maxElem = e
-           maxValue = v
+            maxElem = e
+            maxValue = v
         }
     }
     return maxElem
-    
 }
 
 /**
  * Returns the first element yielding the largest value of the given function or null if there are no elements
  */
-public inline fun <R: Comparable<R>> LongArray.maxBy(f: (Long) -> R) : Long? {
+public inline fun <R : Comparable<R>> LongArray.maxBy(f: (Long) -> R): Long? {
     if (isEmpty()) return null
-    
     var maxElem = this[0]
     var maxValue = f(maxElem)
     for (i in 1..lastIndex) {
         val e = this[i]
         val v = f(e)
         if (maxValue < v) {
-           maxElem = e
-           maxValue = v
+            maxElem = e
+            maxValue = v
         }
     }
     return maxElem
-    
 }
 
 /**
  * Returns the first element yielding the largest value of the given function or null if there are no elements
  */
-public inline fun <R: Comparable<R>> ShortArray.maxBy(f: (Short) -> R) : Short? {
+public inline fun <R : Comparable<R>> ShortArray.maxBy(f: (Short) -> R): Short? {
     if (isEmpty()) return null
-    
     var maxElem = this[0]
     var maxValue = f(maxElem)
     for (i in 1..lastIndex) {
         val e = this[i]
         val v = f(e)
         if (maxValue < v) {
-           maxElem = e
-           maxValue = v
+            maxElem = e
+            maxValue = v
         }
     }
     return maxElem
-    
 }
 
 /**
  * Returns the first element yielding the largest value of the given function or null if there are no elements
  */
-public inline fun <R: Comparable<R>, T: Any> Iterable<T>.maxBy(f: (T) -> R) : T? {
+public inline fun <R : Comparable<R>, T : Any> Iterable<T>.maxBy(f: (T) -> R): T? {
     val iterator = iterator()
     if (!iterator.hasNext()) return null
-    
     var maxElem = iterator.next()
     var maxValue = f(maxElem)
     while (iterator.hasNext()) {
         val e = iterator.next()
         val v = f(e)
         if (maxValue < v) {
-           maxElem = e
-           maxValue = v
+            maxElem = e
+            maxValue = v
         }
     }
     return maxElem
-    
 }
 
 /**
  * Returns the first element yielding the largest value of the given function or null if there are no elements
  */
-public inline fun <R: Comparable<R>, T: Any> Stream<T>.maxBy(f: (T) -> R) : T? {
+public inline fun <R : Comparable<R>, T : Any> Stream<T>.maxBy(f: (T) -> R): T? {
     val iterator = iterator()
     if (!iterator.hasNext()) return null
-    
     var maxElem = iterator.next()
     var maxValue = f(maxElem)
     while (iterator.hasNext()) {
         val e = iterator.next()
         val v = f(e)
         if (maxValue < v) {
-           maxElem = e
-           maxValue = v
+            maxElem = e
+            maxValue = v
         }
     }
     return maxElem
-    
 }
 
 /**
  * Returns the first element yielding the largest value of the given function or null if there are no elements
  */
-public inline fun <R: Comparable<R>> String.maxBy(f: (Char) -> R) : Char? {
+public inline fun <R : Comparable<R>> String.maxBy(f: (Char) -> R): Char? {
     val iterator = iterator()
     if (!iterator.hasNext()) return null
-    
     var maxElem = iterator.next()
     var maxValue = f(maxElem)
     while (iterator.hasNext()) {
         val e = iterator.next()
         val v = f(e)
         if (maxValue < v) {
-           maxElem = e
-           maxValue = v
+            maxElem = e
+            maxValue = v
         }
     }
     return maxElem
-    
 }
 
 /**
  * Returns the first element yielding the largest value of the given function or null if there are no elements
  */
-public inline fun <K, V, R: Comparable<R>> Map<K,V>.maxBy(f: (Map.Entry<K,V>) -> R) : Map.Entry<K,V>? {
+public inline fun <K, V, R : Comparable<R>> Map<K, V>.maxBy(f: (Map.Entry<K, V>) -> R): Map.Entry<K, V>? {
     val iterator = iterator()
     if (!iterator.hasNext()) return null
-    
     var maxElem = iterator.next()
     var maxValue = f(maxElem)
     while (iterator.hasNext()) {
         val e = iterator.next()
         val v = f(e)
         if (maxValue < v) {
-           maxElem = e
-           maxValue = v
+            maxElem = e
+            maxValue = v
         }
     }
     return maxElem
-    
 }
 
 /**
  * Returns the smallest element or null if there are no elements
  */
-public fun <T: Comparable<T>> Array<out T>.min() : T? {
+public fun <T : Comparable<T>> Array<out T>.min(): T? {
     if (isEmpty()) return null
     var min = this[0]
     for (i in 1..lastIndex) {
@@ -1402,13 +1264,12 @@ public fun <T: Comparable<T>> Array<out T>.min() : T? {
         if (min > e) min = e
     }
     return min
-    
 }
 
 /**
  * Returns the smallest element or null if there are no elements
  */
-public fun ByteArray.min() : Byte? {
+public fun ByteArray.min(): Byte? {
     if (isEmpty()) return null
     var min = this[0]
     for (i in 1..lastIndex) {
@@ -1416,13 +1277,12 @@ public fun ByteArray.min() : Byte? {
         if (min > e) min = e
     }
     return min
-    
 }
 
 /**
  * Returns the smallest element or null if there are no elements
  */
-public fun CharArray.min() : Char? {
+public fun CharArray.min(): Char? {
     if (isEmpty()) return null
     var min = this[0]
     for (i in 1..lastIndex) {
@@ -1430,13 +1290,12 @@ public fun CharArray.min() : Char? {
         if (min > e) min = e
     }
     return min
-    
 }
 
 /**
  * Returns the smallest element or null if there are no elements
  */
-public fun DoubleArray.min() : Double? {
+public fun DoubleArray.min(): Double? {
     if (isEmpty()) return null
     var min = this[0]
     for (i in 1..lastIndex) {
@@ -1444,13 +1303,12 @@ public fun DoubleArray.min() : Double? {
         if (min > e) min = e
     }
     return min
-    
 }
 
 /**
  * Returns the smallest element or null if there are no elements
  */
-public fun FloatArray.min() : Float? {
+public fun FloatArray.min(): Float? {
     if (isEmpty()) return null
     var min = this[0]
     for (i in 1..lastIndex) {
@@ -1458,13 +1316,12 @@ public fun FloatArray.min() : Float? {
         if (min > e) min = e
     }
     return min
-    
 }
 
 /**
  * Returns the smallest element or null if there are no elements
  */
-public fun IntArray.min() : Int? {
+public fun IntArray.min(): Int? {
     if (isEmpty()) return null
     var min = this[0]
     for (i in 1..lastIndex) {
@@ -1472,13 +1329,12 @@ public fun IntArray.min() : Int? {
         if (min > e) min = e
     }
     return min
-    
 }
 
 /**
  * Returns the smallest element or null if there are no elements
  */
-public fun LongArray.min() : Long? {
+public fun LongArray.min(): Long? {
     if (isEmpty()) return null
     var min = this[0]
     for (i in 1..lastIndex) {
@@ -1486,13 +1342,12 @@ public fun LongArray.min() : Long? {
         if (min > e) min = e
     }
     return min
-    
 }
 
 /**
  * Returns the smallest element or null if there are no elements
  */
-public fun ShortArray.min() : Short? {
+public fun ShortArray.min(): Short? {
     if (isEmpty()) return null
     var min = this[0]
     for (i in 1..lastIndex) {
@@ -1500,908 +1355,792 @@ public fun ShortArray.min() : Short? {
         if (min > e) min = e
     }
     return min
-    
 }
 
 /**
  * Returns the smallest element or null if there are no elements
  */
-public fun <T: Comparable<T>> Iterable<T>.min() : T? {
+public fun <T : Comparable<T>> Iterable<T>.min(): T? {
     val iterator = iterator()
     if (!iterator.hasNext()) return null
-    
     var min = iterator.next()
     while (iterator.hasNext()) {
         val e = iterator.next()
         if (min > e) min = e
     }
     return min
-    
 }
 
 /**
  * Returns the smallest element or null if there are no elements
  */
-public fun <T: Comparable<T>> Stream<T>.min() : T? {
+public fun <T : Comparable<T>> Stream<T>.min(): T? {
     val iterator = iterator()
     if (!iterator.hasNext()) return null
-    
     var min = iterator.next()
     while (iterator.hasNext()) {
         val e = iterator.next()
         if (min > e) min = e
     }
     return min
-    
 }
 
 /**
  * Returns the smallest element or null if there are no elements
  */
-public fun String.min() : Char? {
+public fun String.min(): Char? {
     val iterator = iterator()
     if (!iterator.hasNext()) return null
-    
     var min = iterator.next()
     while (iterator.hasNext()) {
         val e = iterator.next()
         if (min > e) min = e
     }
     return min
-    
 }
 
 /**
  * Returns the first element yielding the smallest value of the given function or null if there are no elements
  */
-public inline fun <R: Comparable<R>, T: Any> Array<out T>.minBy(f: (T) -> R) : T? {
+public inline fun <R : Comparable<R>, T : Any> Array<out T>.minBy(f: (T) -> R): T? {
     if (size == 0) return null
-    
     var minElem = this[0]
     var minValue = f(minElem)
     for (i in 1..lastIndex) {
         val e = this[i]
         val v = f(e)
         if (minValue > v) {
-           minElem = e
-           minValue = v
+            minElem = e
+            minValue = v
         }
     }
     return minElem
-    
 }
 
 /**
  * Returns the first element yielding the smallest value of the given function or null if there are no elements
  */
-public inline fun <R: Comparable<R>> BooleanArray.minBy(f: (Boolean) -> R) : Boolean? {
+public inline fun <R : Comparable<R>> BooleanArray.minBy(f: (Boolean) -> R): Boolean? {
     if (size == 0) return null
-    
     var minElem = this[0]
     var minValue = f(minElem)
     for (i in 1..lastIndex) {
         val e = this[i]
         val v = f(e)
         if (minValue > v) {
-           minElem = e
-           minValue = v
+            minElem = e
+            minValue = v
         }
     }
     return minElem
-    
 }
 
 /**
  * Returns the first element yielding the smallest value of the given function or null if there are no elements
  */
-public inline fun <R: Comparable<R>> ByteArray.minBy(f: (Byte) -> R) : Byte? {
+public inline fun <R : Comparable<R>> ByteArray.minBy(f: (Byte) -> R): Byte? {
     if (size == 0) return null
-    
     var minElem = this[0]
     var minValue = f(minElem)
     for (i in 1..lastIndex) {
         val e = this[i]
         val v = f(e)
         if (minValue > v) {
-           minElem = e
-           minValue = v
+            minElem = e
+            minValue = v
         }
     }
     return minElem
-    
 }
 
 /**
  * Returns the first element yielding the smallest value of the given function or null if there are no elements
  */
-public inline fun <R: Comparable<R>> CharArray.minBy(f: (Char) -> R) : Char? {
+public inline fun <R : Comparable<R>> CharArray.minBy(f: (Char) -> R): Char? {
     if (size == 0) return null
-    
     var minElem = this[0]
     var minValue = f(minElem)
     for (i in 1..lastIndex) {
         val e = this[i]
         val v = f(e)
         if (minValue > v) {
-           minElem = e
-           minValue = v
+            minElem = e
+            minValue = v
         }
     }
     return minElem
-    
 }
 
 /**
  * Returns the first element yielding the smallest value of the given function or null if there are no elements
  */
-public inline fun <R: Comparable<R>> DoubleArray.minBy(f: (Double) -> R) : Double? {
+public inline fun <R : Comparable<R>> DoubleArray.minBy(f: (Double) -> R): Double? {
     if (size == 0) return null
-    
     var minElem = this[0]
     var minValue = f(minElem)
     for (i in 1..lastIndex) {
         val e = this[i]
         val v = f(e)
         if (minValue > v) {
-           minElem = e
-           minValue = v
+            minElem = e
+            minValue = v
         }
     }
     return minElem
-    
 }
 
 /**
  * Returns the first element yielding the smallest value of the given function or null if there are no elements
  */
-public inline fun <R: Comparable<R>> FloatArray.minBy(f: (Float) -> R) : Float? {
+public inline fun <R : Comparable<R>> FloatArray.minBy(f: (Float) -> R): Float? {
     if (size == 0) return null
-    
     var minElem = this[0]
     var minValue = f(minElem)
     for (i in 1..lastIndex) {
         val e = this[i]
         val v = f(e)
         if (minValue > v) {
-           minElem = e
-           minValue = v
+            minElem = e
+            minValue = v
         }
     }
     return minElem
-    
 }
 
 /**
  * Returns the first element yielding the smallest value of the given function or null if there are no elements
  */
-public inline fun <R: Comparable<R>> IntArray.minBy(f: (Int) -> R) : Int? {
+public inline fun <R : Comparable<R>> IntArray.minBy(f: (Int) -> R): Int? {
     if (size == 0) return null
-    
     var minElem = this[0]
     var minValue = f(minElem)
     for (i in 1..lastIndex) {
         val e = this[i]
         val v = f(e)
         if (minValue > v) {
-           minElem = e
-           minValue = v
+            minElem = e
+            minValue = v
         }
     }
     return minElem
-    
 }
 
 /**
  * Returns the first element yielding the smallest value of the given function or null if there are no elements
  */
-public inline fun <R: Comparable<R>> LongArray.minBy(f: (Long) -> R) : Long? {
+public inline fun <R : Comparable<R>> LongArray.minBy(f: (Long) -> R): Long? {
     if (size == 0) return null
-    
     var minElem = this[0]
     var minValue = f(minElem)
     for (i in 1..lastIndex) {
         val e = this[i]
         val v = f(e)
         if (minValue > v) {
-           minElem = e
-           minValue = v
+            minElem = e
+            minValue = v
         }
     }
     return minElem
-    
 }
 
 /**
  * Returns the first element yielding the smallest value of the given function or null if there are no elements
  */
-public inline fun <R: Comparable<R>> ShortArray.minBy(f: (Short) -> R) : Short? {
+public inline fun <R : Comparable<R>> ShortArray.minBy(f: (Short) -> R): Short? {
     if (size == 0) return null
-    
     var minElem = this[0]
     var minValue = f(minElem)
     for (i in 1..lastIndex) {
         val e = this[i]
         val v = f(e)
         if (minValue > v) {
-           minElem = e
-           minValue = v
+            minElem = e
+            minValue = v
         }
     }
     return minElem
-    
 }
 
 /**
  * Returns the first element yielding the smallest value of the given function or null if there are no elements
  */
-public inline fun <R: Comparable<R>, T: Any> Iterable<T>.minBy(f: (T) -> R) : T? {
+public inline fun <R : Comparable<R>, T : Any> Iterable<T>.minBy(f: (T) -> R): T? {
     val iterator = iterator()
     if (!iterator.hasNext()) return null
-    
     var minElem = iterator.next()
     var minValue = f(minElem)
     while (iterator.hasNext()) {
         val e = iterator.next()
         val v = f(e)
         if (minValue > v) {
-           minElem = e
-           minValue = v
+            minElem = e
+            minValue = v
         }
     }
     return minElem
-    
 }
 
 /**
  * Returns the first element yielding the smallest value of the given function or null if there are no elements
  */
-public inline fun <R: Comparable<R>, T: Any> Stream<T>.minBy(f: (T) -> R) : T? {
+public inline fun <R : Comparable<R>, T : Any> Stream<T>.minBy(f: (T) -> R): T? {
     val iterator = iterator()
     if (!iterator.hasNext()) return null
-    
     var minElem = iterator.next()
     var minValue = f(minElem)
     while (iterator.hasNext()) {
         val e = iterator.next()
         val v = f(e)
         if (minValue > v) {
-           minElem = e
-           minValue = v
+            minElem = e
+            minValue = v
         }
     }
     return minElem
-    
 }
 
 /**
  * Returns the first element yielding the smallest value of the given function or null if there are no elements
  */
-public inline fun <R: Comparable<R>> String.minBy(f: (Char) -> R) : Char? {
+public inline fun <R : Comparable<R>> String.minBy(f: (Char) -> R): Char? {
     val iterator = iterator()
     if (!iterator.hasNext()) return null
-    
     var minElem = iterator.next()
     var minValue = f(minElem)
     while (iterator.hasNext()) {
         val e = iterator.next()
         val v = f(e)
         if (minValue > v) {
-           minElem = e
-           minValue = v
+            minElem = e
+            minValue = v
         }
     }
     return minElem
-    
 }
 
 /**
  * Returns the first element yielding the smallest value of the given function or null if there are no elements
  */
-public inline fun <K, V, R: Comparable<R>> Map<K,V>.minBy(f: (Map.Entry<K,V>) -> R) : Map.Entry<K,V>? {
+public inline fun <K, V, R : Comparable<R>> Map<K, V>.minBy(f: (Map.Entry<K, V>) -> R): Map.Entry<K, V>? {
     val iterator = iterator()
     if (!iterator.hasNext()) return null
-    
     var minElem = iterator.next()
     var minValue = f(minElem)
     while (iterator.hasNext()) {
         val e = iterator.next()
         val v = f(e)
         if (minValue > v) {
-           minElem = e
-           minValue = v
+            minElem = e
+            minValue = v
         }
     }
     return minElem
-    
 }
 
 /**
  * Returns *true* if collection has no elements
  */
-public fun <T> Array<out T>.none() : Boolean {
+public fun <T> Array<out T>.none(): Boolean {
     for (element in this) return false
     return true
-    
 }
 
 /**
  * Returns *true* if collection has no elements
  */
-public fun BooleanArray.none() : Boolean {
+public fun BooleanArray.none(): Boolean {
     for (element in this) return false
     return true
-    
 }
 
 /**
  * Returns *true* if collection has no elements
  */
-public fun ByteArray.none() : Boolean {
+public fun ByteArray.none(): Boolean {
     for (element in this) return false
     return true
-    
 }
 
 /**
  * Returns *true* if collection has no elements
  */
-public fun CharArray.none() : Boolean {
+public fun CharArray.none(): Boolean {
     for (element in this) return false
     return true
-    
 }
 
 /**
  * Returns *true* if collection has no elements
  */
-public fun DoubleArray.none() : Boolean {
+public fun DoubleArray.none(): Boolean {
     for (element in this) return false
     return true
-    
 }
 
 /**
  * Returns *true* if collection has no elements
  */
-public fun FloatArray.none() : Boolean {
+public fun FloatArray.none(): Boolean {
     for (element in this) return false
     return true
-    
 }
 
 /**
  * Returns *true* if collection has no elements
  */
-public fun IntArray.none() : Boolean {
+public fun IntArray.none(): Boolean {
     for (element in this) return false
     return true
-    
 }
 
 /**
  * Returns *true* if collection has no elements
  */
-public fun LongArray.none() : Boolean {
+public fun LongArray.none(): Boolean {
     for (element in this) return false
     return true
-    
 }
 
 /**
  * Returns *true* if collection has no elements
  */
-public fun ShortArray.none() : Boolean {
+public fun ShortArray.none(): Boolean {
     for (element in this) return false
     return true
-    
 }
 
 /**
  * Returns *true* if collection has no elements
  */
-public fun <T> Iterable<T>.none() : Boolean {
+public fun <T> Iterable<T>.none(): Boolean {
     for (element in this) return false
     return true
-    
 }
 
 /**
  * Returns *true* if collection has no elements
  */
-public fun <K, V> Map<K,V>.none() : Boolean {
+public fun <K, V> Map<K, V>.none(): Boolean {
     for (element in this) return false
     return true
-    
 }
 
 /**
  * Returns *true* if collection has no elements
  */
-public fun <T> Stream<T>.none() : Boolean {
+public fun <T> Stream<T>.none(): Boolean {
     for (element in this) return false
     return true
-    
 }
 
 /**
  * Returns *true* if collection has no elements
  */
-public fun String.none() : Boolean {
+public fun String.none(): Boolean {
     for (element in this) return false
     return true
-    
 }
 
 /**
  * Returns *true* if no elements match the given *predicate*
  */
-public inline fun <T> Array<out T>.none(predicate: (T) -> Boolean) : Boolean {
+public inline fun <T> Array<out T>.none(predicate: (T) -> Boolean): Boolean {
     for (element in this) if (predicate(element)) return false
     return true
-    
 }
 
 /**
  * Returns *true* if no elements match the given *predicate*
  */
-public inline fun BooleanArray.none(predicate: (Boolean) -> Boolean) : Boolean {
+public inline fun BooleanArray.none(predicate: (Boolean) -> Boolean): Boolean {
     for (element in this) if (predicate(element)) return false
     return true
-    
 }
 
 /**
  * Returns *true* if no elements match the given *predicate*
  */
-public inline fun ByteArray.none(predicate: (Byte) -> Boolean) : Boolean {
+public inline fun ByteArray.none(predicate: (Byte) -> Boolean): Boolean {
     for (element in this) if (predicate(element)) return false
     return true
-    
 }
 
 /**
  * Returns *true* if no elements match the given *predicate*
  */
-public inline fun CharArray.none(predicate: (Char) -> Boolean) : Boolean {
+public inline fun CharArray.none(predicate: (Char) -> Boolean): Boolean {
     for (element in this) if (predicate(element)) return false
     return true
-    
 }
 
 /**
  * Returns *true* if no elements match the given *predicate*
  */
-public inline fun DoubleArray.none(predicate: (Double) -> Boolean) : Boolean {
+public inline fun DoubleArray.none(predicate: (Double) -> Boolean): Boolean {
     for (element in this) if (predicate(element)) return false
     return true
-    
 }
 
 /**
  * Returns *true* if no elements match the given *predicate*
  */
-public inline fun FloatArray.none(predicate: (Float) -> Boolean) : Boolean {
+public inline fun FloatArray.none(predicate: (Float) -> Boolean): Boolean {
     for (element in this) if (predicate(element)) return false
     return true
-    
 }
 
 /**
  * Returns *true* if no elements match the given *predicate*
  */
-public inline fun IntArray.none(predicate: (Int) -> Boolean) : Boolean {
+public inline fun IntArray.none(predicate: (Int) -> Boolean): Boolean {
     for (element in this) if (predicate(element)) return false
     return true
-    
 }
 
 /**
  * Returns *true* if no elements match the given *predicate*
  */
-public inline fun LongArray.none(predicate: (Long) -> Boolean) : Boolean {
+public inline fun LongArray.none(predicate: (Long) -> Boolean): Boolean {
     for (element in this) if (predicate(element)) return false
     return true
-    
 }
 
 /**
  * Returns *true* if no elements match the given *predicate*
  */
-public inline fun ShortArray.none(predicate: (Short) -> Boolean) : Boolean {
+public inline fun ShortArray.none(predicate: (Short) -> Boolean): Boolean {
     for (element in this) if (predicate(element)) return false
     return true
-    
 }
 
 /**
  * Returns *true* if no elements match the given *predicate*
  */
-public inline fun <T> Iterable<T>.none(predicate: (T) -> Boolean) : Boolean {
+public inline fun <T> Iterable<T>.none(predicate: (T) -> Boolean): Boolean {
     for (element in this) if (predicate(element)) return false
     return true
-    
 }
 
 /**
  * Returns *true* if no elements match the given *predicate*
  */
-public inline fun <K, V> Map<K,V>.none(predicate: (Map.Entry<K,V>) -> Boolean) : Boolean {
+public inline fun <K, V> Map<K, V>.none(predicate: (Map.Entry<K, V>) -> Boolean): Boolean {
     for (element in this) if (predicate(element)) return false
     return true
-    
 }
 
 /**
  * Returns *true* if no elements match the given *predicate*
  */
-public inline fun <T> Stream<T>.none(predicate: (T) -> Boolean) : Boolean {
+public inline fun <T> Stream<T>.none(predicate: (T) -> Boolean): Boolean {
     for (element in this) if (predicate(element)) return false
     return true
-    
 }
 
 /**
  * Returns *true* if no elements match the given *predicate*
  */
-public inline fun String.none(predicate: (Char) -> Boolean) : Boolean {
+public inline fun String.none(predicate: (Char) -> Boolean): Boolean {
     for (element in this) if (predicate(element)) return false
     return true
-    
 }
 
 /**
  * Accumulates value starting with the first element and applying *operation* from left to right to current accumulator value and each element
  */
-public inline fun <T> Array<out T>.reduce(operation: (T, T) -> T) : T {
+public inline fun <T> Array<out T>.reduce(operation: (T, T) -> T): T {
     val iterator = this.iterator()
     if (!iterator.hasNext()) throw UnsupportedOperationException("Empty iterable can't be reduced")
-    
     var accumulator = iterator.next()
     while (iterator.hasNext()) {
         accumulator = operation(accumulator, iterator.next())
     }
     return accumulator
-    
 }
 
 /**
  * Accumulates value starting with the first element and applying *operation* from left to right to current accumulator value and each element
  */
-public inline fun BooleanArray.reduce(operation: (Boolean, Boolean) -> Boolean) : Boolean {
+public inline fun BooleanArray.reduce(operation: (Boolean, Boolean) -> Boolean): Boolean {
     val iterator = this.iterator()
     if (!iterator.hasNext()) throw UnsupportedOperationException("Empty iterable can't be reduced")
-    
     var accumulator = iterator.next()
     while (iterator.hasNext()) {
         accumulator = operation(accumulator, iterator.next())
     }
     return accumulator
-    
 }
 
 /**
  * Accumulates value starting with the first element and applying *operation* from left to right to current accumulator value and each element
  */
-public inline fun ByteArray.reduce(operation: (Byte, Byte) -> Byte) : Byte {
+public inline fun ByteArray.reduce(operation: (Byte, Byte) -> Byte): Byte {
     val iterator = this.iterator()
     if (!iterator.hasNext()) throw UnsupportedOperationException("Empty iterable can't be reduced")
-    
     var accumulator = iterator.next()
     while (iterator.hasNext()) {
         accumulator = operation(accumulator, iterator.next())
     }
     return accumulator
-    
 }
 
 /**
  * Accumulates value starting with the first element and applying *operation* from left to right to current accumulator value and each element
  */
-public inline fun CharArray.reduce(operation: (Char, Char) -> Char) : Char {
+public inline fun CharArray.reduce(operation: (Char, Char) -> Char): Char {
     val iterator = this.iterator()
     if (!iterator.hasNext()) throw UnsupportedOperationException("Empty iterable can't be reduced")
-    
     var accumulator = iterator.next()
     while (iterator.hasNext()) {
         accumulator = operation(accumulator, iterator.next())
     }
     return accumulator
-    
 }
 
 /**
  * Accumulates value starting with the first element and applying *operation* from left to right to current accumulator value and each element
  */
-public inline fun DoubleArray.reduce(operation: (Double, Double) -> Double) : Double {
+public inline fun DoubleArray.reduce(operation: (Double, Double) -> Double): Double {
     val iterator = this.iterator()
     if (!iterator.hasNext()) throw UnsupportedOperationException("Empty iterable can't be reduced")
-    
     var accumulator = iterator.next()
     while (iterator.hasNext()) {
         accumulator = operation(accumulator, iterator.next())
     }
     return accumulator
-    
 }
 
 /**
  * Accumulates value starting with the first element and applying *operation* from left to right to current accumulator value and each element
  */
-public inline fun FloatArray.reduce(operation: (Float, Float) -> Float) : Float {
+public inline fun FloatArray.reduce(operation: (Float, Float) -> Float): Float {
     val iterator = this.iterator()
     if (!iterator.hasNext()) throw UnsupportedOperationException("Empty iterable can't be reduced")
-    
     var accumulator = iterator.next()
     while (iterator.hasNext()) {
         accumulator = operation(accumulator, iterator.next())
     }
     return accumulator
-    
 }
 
 /**
  * Accumulates value starting with the first element and applying *operation* from left to right to current accumulator value and each element
  */
-public inline fun IntArray.reduce(operation: (Int, Int) -> Int) : Int {
+public inline fun IntArray.reduce(operation: (Int, Int) -> Int): Int {
     val iterator = this.iterator()
     if (!iterator.hasNext()) throw UnsupportedOperationException("Empty iterable can't be reduced")
-    
     var accumulator = iterator.next()
     while (iterator.hasNext()) {
         accumulator = operation(accumulator, iterator.next())
     }
     return accumulator
-    
 }
 
 /**
  * Accumulates value starting with the first element and applying *operation* from left to right to current accumulator value and each element
  */
-public inline fun LongArray.reduce(operation: (Long, Long) -> Long) : Long {
+public inline fun LongArray.reduce(operation: (Long, Long) -> Long): Long {
     val iterator = this.iterator()
     if (!iterator.hasNext()) throw UnsupportedOperationException("Empty iterable can't be reduced")
-    
     var accumulator = iterator.next()
     while (iterator.hasNext()) {
         accumulator = operation(accumulator, iterator.next())
     }
     return accumulator
-    
 }
 
 /**
  * Accumulates value starting with the first element and applying *operation* from left to right to current accumulator value and each element
  */
-public inline fun ShortArray.reduce(operation: (Short, Short) -> Short) : Short {
+public inline fun ShortArray.reduce(operation: (Short, Short) -> Short): Short {
     val iterator = this.iterator()
     if (!iterator.hasNext()) throw UnsupportedOperationException("Empty iterable can't be reduced")
-    
     var accumulator = iterator.next()
     while (iterator.hasNext()) {
         accumulator = operation(accumulator, iterator.next())
     }
     return accumulator
-    
 }
 
 /**
  * Accumulates value starting with the first element and applying *operation* from left to right to current accumulator value and each element
  */
-public inline fun <T> Iterable<T>.reduce(operation: (T, T) -> T) : T {
+public inline fun <T> Iterable<T>.reduce(operation: (T, T) -> T): T {
     val iterator = this.iterator()
     if (!iterator.hasNext()) throw UnsupportedOperationException("Empty iterable can't be reduced")
-    
     var accumulator = iterator.next()
     while (iterator.hasNext()) {
         accumulator = operation(accumulator, iterator.next())
     }
     return accumulator
-    
 }
 
 /**
  * Accumulates value starting with the first element and applying *operation* from left to right to current accumulator value and each element
  */
-public inline fun <T> Stream<T>.reduce(operation: (T, T) -> T) : T {
+public inline fun <T> Stream<T>.reduce(operation: (T, T) -> T): T {
     val iterator = this.iterator()
     if (!iterator.hasNext()) throw UnsupportedOperationException("Empty iterable can't be reduced")
-    
     var accumulator = iterator.next()
     while (iterator.hasNext()) {
         accumulator = operation(accumulator, iterator.next())
     }
     return accumulator
-    
 }
 
 /**
  * Accumulates value starting with the first element and applying *operation* from left to right to current accumulator value and each element
  */
-public inline fun String.reduce(operation: (Char, Char) -> Char) : Char {
+public inline fun String.reduce(operation: (Char, Char) -> Char): Char {
     val iterator = this.iterator()
     if (!iterator.hasNext()) throw UnsupportedOperationException("Empty iterable can't be reduced")
-    
     var accumulator = iterator.next()
     while (iterator.hasNext()) {
         accumulator = operation(accumulator, iterator.next())
     }
     return accumulator
-    
 }
 
 /**
  * Accumulates value starting with last element and applying *operation* from right to left to each element and current accumulator value
  */
-public inline fun <T> Array<out T>.reduceRight(operation: (T, T) -> T) : T {
+public inline fun <T> Array<out T>.reduceRight(operation: (T, T) -> T): T {
     var index = size - 1
     if (index < 0) throw UnsupportedOperationException("Empty iterable can't be reduced")
-    
     var accumulator = get(index--)
     while (index >= 0) {
         accumulator = operation(get(index--), accumulator)
     }
-    
     return accumulator
-    
 }
 
 /**
  * Accumulates value starting with last element and applying *operation* from right to left to each element and current accumulator value
  */
-public inline fun BooleanArray.reduceRight(operation: (Boolean, Boolean) -> Boolean) : Boolean {
+public inline fun BooleanArray.reduceRight(operation: (Boolean, Boolean) -> Boolean): Boolean {
     var index = size - 1
     if (index < 0) throw UnsupportedOperationException("Empty iterable can't be reduced")
-    
     var accumulator = get(index--)
     while (index >= 0) {
         accumulator = operation(get(index--), accumulator)
     }
-    
     return accumulator
-    
 }
 
 /**
  * Accumulates value starting with last element and applying *operation* from right to left to each element and current accumulator value
  */
-public inline fun ByteArray.reduceRight(operation: (Byte, Byte) -> Byte) : Byte {
+public inline fun ByteArray.reduceRight(operation: (Byte, Byte) -> Byte): Byte {
     var index = size - 1
     if (index < 0) throw UnsupportedOperationException("Empty iterable can't be reduced")
-    
     var accumulator = get(index--)
     while (index >= 0) {
         accumulator = operation(get(index--), accumulator)
     }
-    
     return accumulator
-    
 }
 
 /**
  * Accumulates value starting with last element and applying *operation* from right to left to each element and current accumulator value
  */
-public inline fun CharArray.reduceRight(operation: (Char, Char) -> Char) : Char {
+public inline fun CharArray.reduceRight(operation: (Char, Char) -> Char): Char {
     var index = size - 1
     if (index < 0) throw UnsupportedOperationException("Empty iterable can't be reduced")
-    
     var accumulator = get(index--)
     while (index >= 0) {
         accumulator = operation(get(index--), accumulator)
     }
-    
     return accumulator
-    
 }
 
 /**
  * Accumulates value starting with last element and applying *operation* from right to left to each element and current accumulator value
  */
-public inline fun DoubleArray.reduceRight(operation: (Double, Double) -> Double) : Double {
+public inline fun DoubleArray.reduceRight(operation: (Double, Double) -> Double): Double {
     var index = size - 1
     if (index < 0) throw UnsupportedOperationException("Empty iterable can't be reduced")
-    
     var accumulator = get(index--)
     while (index >= 0) {
         accumulator = operation(get(index--), accumulator)
     }
-    
     return accumulator
-    
 }
 
 /**
  * Accumulates value starting with last element and applying *operation* from right to left to each element and current accumulator value
  */
-public inline fun FloatArray.reduceRight(operation: (Float, Float) -> Float) : Float {
+public inline fun FloatArray.reduceRight(operation: (Float, Float) -> Float): Float {
     var index = size - 1
     if (index < 0) throw UnsupportedOperationException("Empty iterable can't be reduced")
-    
     var accumulator = get(index--)
     while (index >= 0) {
         accumulator = operation(get(index--), accumulator)
     }
-    
     return accumulator
-    
 }
 
 /**
  * Accumulates value starting with last element and applying *operation* from right to left to each element and current accumulator value
  */
-public inline fun IntArray.reduceRight(operation: (Int, Int) -> Int) : Int {
+public inline fun IntArray.reduceRight(operation: (Int, Int) -> Int): Int {
     var index = size - 1
     if (index < 0) throw UnsupportedOperationException("Empty iterable can't be reduced")
-    
     var accumulator = get(index--)
     while (index >= 0) {
         accumulator = operation(get(index--), accumulator)
     }
-    
     return accumulator
-    
 }
 
 /**
  * Accumulates value starting with last element and applying *operation* from right to left to each element and current accumulator value
  */
-public inline fun LongArray.reduceRight(operation: (Long, Long) -> Long) : Long {
+public inline fun LongArray.reduceRight(operation: (Long, Long) -> Long): Long {
     var index = size - 1
     if (index < 0) throw UnsupportedOperationException("Empty iterable can't be reduced")
-    
     var accumulator = get(index--)
     while (index >= 0) {
         accumulator = operation(get(index--), accumulator)
     }
-    
     return accumulator
-    
 }
 
 /**
  * Accumulates value starting with last element and applying *operation* from right to left to each element and current accumulator value
  */
-public inline fun ShortArray.reduceRight(operation: (Short, Short) -> Short) : Short {
+public inline fun ShortArray.reduceRight(operation: (Short, Short) -> Short): Short {
     var index = size - 1
     if (index < 0) throw UnsupportedOperationException("Empty iterable can't be reduced")
-    
     var accumulator = get(index--)
     while (index >= 0) {
         accumulator = operation(get(index--), accumulator)
     }
-    
     return accumulator
-    
 }
 
 /**
  * Accumulates value starting with last element and applying *operation* from right to left to each element and current accumulator value
  */
-public inline fun <T> List<T>.reduceRight(operation: (T, T) -> T) : T {
+public inline fun <T> List<T>.reduceRight(operation: (T, T) -> T): T {
     var index = size - 1
     if (index < 0) throw UnsupportedOperationException("Empty iterable can't be reduced")
-    
     var accumulator = get(index--)
     while (index >= 0) {
         accumulator = operation(get(index--), accumulator)
     }
-    
     return accumulator
-    
 }
 
 /**
  * Accumulates value starting with last element and applying *operation* from right to left to each element and current accumulator value
  */
-public inline fun String.reduceRight(operation: (Char, Char) -> Char) : Char {
+public inline fun String.reduceRight(operation: (Char, Char) -> Char): Char {
     var index = size - 1
     if (index < 0) throw UnsupportedOperationException("Empty iterable can't be reduced")
-    
     var accumulator = get(index--)
     while (index >= 0) {
         accumulator = operation(get(index--), accumulator)
     }
-    
     return accumulator
-    
 }
 
diff --git a/libraries/stdlib/src/generated/_Arrays.kt b/libraries/stdlib/src/generated/_Arrays.kt
index 982face439c..b5681a6658d 100644
--- a/libraries/stdlib/src/generated/_Arrays.kt
+++ b/libraries/stdlib/src/generated/_Arrays.kt
@@ -10,126 +10,126 @@ import java.util.*
 /**
  * Returns true if the array is empty
  */
-public fun <T> Array<out T>.isEmpty() : Boolean {
+public fun <T> Array<out T>.isEmpty(): Boolean {
     return size == 0
 }
 
 /**
  * Returns true if the array is empty
  */
-public fun BooleanArray.isEmpty() : Boolean {
+public fun BooleanArray.isEmpty(): Boolean {
     return size == 0
 }
 
 /**
  * Returns true if the array is empty
  */
-public fun ByteArray.isEmpty() : Boolean {
+public fun ByteArray.isEmpty(): Boolean {
     return size == 0
 }
 
 /**
  * Returns true if the array is empty
  */
-public fun CharArray.isEmpty() : Boolean {
+public fun CharArray.isEmpty(): Boolean {
     return size == 0
 }
 
 /**
  * Returns true if the array is empty
  */
-public fun DoubleArray.isEmpty() : Boolean {
+public fun DoubleArray.isEmpty(): Boolean {
     return size == 0
 }
 
 /**
  * Returns true if the array is empty
  */
-public fun FloatArray.isEmpty() : Boolean {
+public fun FloatArray.isEmpty(): Boolean {
     return size == 0
 }
 
 /**
  * Returns true if the array is empty
  */
-public fun IntArray.isEmpty() : Boolean {
+public fun IntArray.isEmpty(): Boolean {
     return size == 0
 }
 
 /**
  * Returns true if the array is empty
  */
-public fun LongArray.isEmpty() : Boolean {
+public fun LongArray.isEmpty(): Boolean {
     return size == 0
 }
 
 /**
  * Returns true if the array is empty
  */
-public fun ShortArray.isEmpty() : Boolean {
+public fun ShortArray.isEmpty(): Boolean {
     return size == 0
 }
 
 /**
  * Returns true if the array is not empty
  */
-public fun <T> Array<out T>.isNotEmpty() : Boolean {
+public fun <T> Array<out T>.isNotEmpty(): Boolean {
     return !isEmpty()
 }
 
 /**
  * Returns true if the array is not empty
  */
-public fun BooleanArray.isNotEmpty() : Boolean {
+public fun BooleanArray.isNotEmpty(): Boolean {
     return !isEmpty()
 }
 
 /**
  * Returns true if the array is not empty
  */
-public fun ByteArray.isNotEmpty() : Boolean {
+public fun ByteArray.isNotEmpty(): Boolean {
     return !isEmpty()
 }
 
 /**
  * Returns true if the array is not empty
  */
-public fun CharArray.isNotEmpty() : Boolean {
+public fun CharArray.isNotEmpty(): Boolean {
     return !isEmpty()
 }
 
 /**
  * Returns true if the array is not empty
  */
-public fun DoubleArray.isNotEmpty() : Boolean {
+public fun DoubleArray.isNotEmpty(): Boolean {
     return !isEmpty()
 }
 
 /**
  * Returns true if the array is not empty
  */
-public fun FloatArray.isNotEmpty() : Boolean {
+public fun FloatArray.isNotEmpty(): Boolean {
     return !isEmpty()
 }
 
 /**
  * Returns true if the array is not empty
  */
-public fun IntArray.isNotEmpty() : Boolean {
+public fun IntArray.isNotEmpty(): Boolean {
     return !isEmpty()
 }
 
 /**
  * Returns true if the array is not empty
  */
-public fun LongArray.isNotEmpty() : Boolean {
+public fun LongArray.isNotEmpty(): Boolean {
     return !isEmpty()
 }
 
 /**
  * Returns true if the array is not empty
  */
-public fun ShortArray.isNotEmpty() : Boolean {
+public fun ShortArray.isNotEmpty(): Boolean {
     return !isEmpty()
 }
 
diff --git a/libraries/stdlib/src/generated/_Elements.kt b/libraries/stdlib/src/generated/_Elements.kt
index ca2ca13e777..1020537b9a4 100644
--- a/libraries/stdlib/src/generated/_Elements.kt
+++ b/libraries/stdlib/src/generated/_Elements.kt
@@ -10,171 +10,151 @@ import java.util.*
 /**
  * Returns true if *element* is found in the collection
  */
-public fun <T> Array<out T>.contains(element: T) : Boolean {
+public fun <T> Array<out T>.contains(element: T): Boolean {
     return indexOf(element) >= 0
-    
 }
 
 /**
  * Returns true if *element* is found in the collection
  */
-public fun BooleanArray.contains(element: Boolean) : Boolean {
+public fun BooleanArray.contains(element: Boolean): Boolean {
     return indexOf(element) >= 0
-    
 }
 
 /**
  * Returns true if *element* is found in the collection
  */
-public fun ByteArray.contains(element: Byte) : Boolean {
+public fun ByteArray.contains(element: Byte): Boolean {
     return indexOf(element) >= 0
-    
 }
 
 /**
  * Returns true if *element* is found in the collection
  */
-public fun CharArray.contains(element: Char) : Boolean {
+public fun CharArray.contains(element: Char): Boolean {
     return indexOf(element) >= 0
-    
 }
 
 /**
  * Returns true if *element* is found in the collection
  */
-public fun DoubleArray.contains(element: Double) : Boolean {
+public fun DoubleArray.contains(element: Double): Boolean {
     return indexOf(element) >= 0
-    
 }
 
 /**
  * Returns true if *element* is found in the collection
  */
-public fun FloatArray.contains(element: Float) : Boolean {
+public fun FloatArray.contains(element: Float): Boolean {
     return indexOf(element) >= 0
-    
 }
 
 /**
  * Returns true if *element* is found in the collection
  */
-public fun IntArray.contains(element: Int) : Boolean {
+public fun IntArray.contains(element: Int): Boolean {
     return indexOf(element) >= 0
-    
 }
 
 /**
  * Returns true if *element* is found in the collection
  */
-public fun LongArray.contains(element: Long) : Boolean {
+public fun LongArray.contains(element: Long): Boolean {
     return indexOf(element) >= 0
-    
 }
 
 /**
  * Returns true if *element* is found in the collection
  */
-public fun ShortArray.contains(element: Short) : Boolean {
+public fun ShortArray.contains(element: Short): Boolean {
     return indexOf(element) >= 0
-    
 }
 
 /**
  * Returns true if *element* is found in the collection
  */
-public fun <T> Iterable<T>.contains(element: T) : Boolean {
+public fun <T> Iterable<T>.contains(element: T): Boolean {
     if (this is Collection<*>)
         return contains(element)
     return indexOf(element) >= 0
-    
 }
 
 /**
  * Returns true if *element* is found in the collection
  */
-public fun <T> Stream<T>.contains(element: T) : Boolean {
+public fun <T> Stream<T>.contains(element: T): Boolean {
     if (this is Collection<*>)
         return contains(element)
     return indexOf(element) >= 0
-    
 }
 
 /**
  * Returns element at given *index*
  */
-public fun <T> Array<out T>.elementAt(index : Int) : T {
+public fun <T> Array<out T>.elementAt(index: Int): T {
     return get(index)
-    
 }
 
 /**
  * Returns element at given *index*
  */
-public fun BooleanArray.elementAt(index : Int) : Boolean {
+public fun BooleanArray.elementAt(index: Int): Boolean {
     return get(index)
-    
 }
 
 /**
  * Returns element at given *index*
  */
-public fun ByteArray.elementAt(index : Int) : Byte {
+public fun ByteArray.elementAt(index: Int): Byte {
     return get(index)
-    
 }
 
 /**
  * Returns element at given *index*
  */
-public fun CharArray.elementAt(index : Int) : Char {
+public fun CharArray.elementAt(index: Int): Char {
     return get(index)
-    
 }
 
 /**
  * Returns element at given *index*
  */
-public fun DoubleArray.elementAt(index : Int) : Double {
+public fun DoubleArray.elementAt(index: Int): Double {
     return get(index)
-    
 }
 
 /**
  * Returns element at given *index*
  */
-public fun FloatArray.elementAt(index : Int) : Float {
+public fun FloatArray.elementAt(index: Int): Float {
     return get(index)
-    
 }
 
 /**
  * Returns element at given *index*
  */
-public fun IntArray.elementAt(index : Int) : Int {
+public fun IntArray.elementAt(index: Int): Int {
     return get(index)
-    
 }
 
 /**
  * Returns element at given *index*
  */
-public fun LongArray.elementAt(index : Int) : Long {
+public fun LongArray.elementAt(index: Int): Long {
     return get(index)
-    
 }
 
 /**
  * Returns element at given *index*
  */
-public fun ShortArray.elementAt(index : Int) : Short {
+public fun ShortArray.elementAt(index: Int): Short {
     return get(index)
-    
 }
 
 /**
  * Returns element at given *index*
  */
-public fun <T> Iterable<T>.elementAt(index : Int) : T {
+public fun <T> Iterable<T>.elementAt(index: Int): T {
     if (this is List<*>)
         return get(index) as T
     val iterator = iterator()
@@ -185,21 +165,19 @@ public fun <T> Iterable<T>.elementAt(index : Int) : T {
             return element
     }
     throw IndexOutOfBoundsException("Collection doesn't contain element at index")
-    
 }
 
 /**
  * Returns element at given *index*
  */
-public fun <T> List<T>.elementAt(index : Int) : T {
+public fun <T> List<T>.elementAt(index: Int): T {
     return get(index)
-    
 }
 
 /**
  * Returns element at given *index*
  */
-public fun <T> Stream<T>.elementAt(index : Int) : T {
+public fun <T> Stream<T>.elementAt(index: Int): T {
     val iterator = iterator()
     var count = 0
     while (iterator.hasNext()) {
@@ -208,105 +186,94 @@ public fun <T> Stream<T>.elementAt(index : Int) : T {
             return element
     }
     throw IndexOutOfBoundsException("Collection doesn't contain element at index")
-    
 }
 
 /**
  * Returns element at given *index*
  */
-public fun String.elementAt(index : Int) : Char {
+public fun String.elementAt(index: Int): Char {
     return get(index)
-    
 }
 
 /**
  * Returns first element
  */
-public fun <T> Array<out T>.first() : T {
+public fun <T> Array<out T>.first(): T {
     if (size == 0)
         throw IllegalArgumentException("Collection is empty")
     return this[0]
-    
 }
 
 /**
  * Returns first element
  */
-public fun BooleanArray.first() : Boolean {
+public fun BooleanArray.first(): Boolean {
     if (size == 0)
         throw IllegalArgumentException("Collection is empty")
     return this[0]
-    
 }
 
 /**
  * Returns first element
  */
-public fun ByteArray.first() : Byte {
+public fun ByteArray.first(): Byte {
     if (size == 0)
         throw IllegalArgumentException("Collection is empty")
     return this[0]
-    
 }
 
 /**
  * Returns first element
  */
-public fun CharArray.first() : Char {
+public fun CharArray.first(): Char {
     if (size == 0)
         throw IllegalArgumentException("Collection is empty")
     return this[0]
-    
 }
 
 /**
  * Returns first element
  */
-public fun DoubleArray.first() : Double {
+public fun DoubleArray.first(): Double {
     if (size == 0)
         throw IllegalArgumentException("Collection is empty")
     return this[0]
-    
 }
 
 /**
  * Returns first element
  */
-public fun FloatArray.first() : Float {
+public fun FloatArray.first(): Float {
     if (size == 0)
         throw IllegalArgumentException("Collection is empty")
     return this[0]
-    
 }
 
 /**
  * Returns first element
  */
-public fun IntArray.first() : Int {
+public fun IntArray.first(): Int {
     if (size == 0)
         throw IllegalArgumentException("Collection is empty")
     return this[0]
-    
 }
 
 /**
  * Returns first element
  */
-public fun LongArray.first() : Long {
+public fun LongArray.first(): Long {
     if (size == 0)
         throw IllegalArgumentException("Collection is empty")
     return this[0]
-    
 }
 
 /**
  * Returns first element
  */
-public fun ShortArray.first() : Short {
+public fun ShortArray.first(): Short {
     if (size == 0)
         throw IllegalArgumentException("Collection is empty")
     return this[0]
-    
 }
 
 /**
@@ -332,11 +299,10 @@ public fun <T> Iterable<T>.first(): T {
 /**
  * Returns first element
  */
-public fun <T> List<T>.first() : T {
+public fun <T> List<T>.first(): T {
     if (size == 0)
         throw IllegalArgumentException("Collection is empty")
     return this[0]
-    
 }
 
 /**
@@ -362,191 +328,169 @@ public fun <T> Stream<T>.first(): T {
 /**
  * Returns first element
  */
-public fun String.first() : Char {
+public fun String.first(): Char {
     if (size == 0)
         throw IllegalArgumentException("Collection is empty")
     return this[0]
-    
 }
 
 /**
  * Returns first element matching the given *predicate*
  */
-public inline fun <T> Array<out T>.first(predicate: (T) -> Boolean) : T {
+public inline fun <T> Array<out T>.first(predicate: (T) -> Boolean): T {
     for (element in this) if (predicate(element)) return element
     throw IllegalArgumentException("No element matching predicate was found")
-    
 }
 
 /**
  * Returns first element matching the given *predicate*
  */
-public inline fun BooleanArray.first(predicate: (Boolean) -> Boolean) : Boolean {
+public inline fun BooleanArray.first(predicate: (Boolean) -> Boolean): Boolean {
     for (element in this) if (predicate(element)) return element
     throw IllegalArgumentException("No element matching predicate was found")
-    
 }
 
 /**
  * Returns first element matching the given *predicate*
  */
-public inline fun ByteArray.first(predicate: (Byte) -> Boolean) : Byte {
+public inline fun ByteArray.first(predicate: (Byte) -> Boolean): Byte {
     for (element in this) if (predicate(element)) return element
     throw IllegalArgumentException("No element matching predicate was found")
-    
 }
 
 /**
  * Returns first element matching the given *predicate*
  */
-public inline fun CharArray.first(predicate: (Char) -> Boolean) : Char {
+public inline fun CharArray.first(predicate: (Char) -> Boolean): Char {
     for (element in this) if (predicate(element)) return element
     throw IllegalArgumentException("No element matching predicate was found")
-    
 }
 
 /**
  * Returns first element matching the given *predicate*
  */
-public inline fun DoubleArray.first(predicate: (Double) -> Boolean) : Double {
+public inline fun DoubleArray.first(predicate: (Double) -> Boolean): Double {
     for (element in this) if (predicate(element)) return element
     throw IllegalArgumentException("No element matching predicate was found")
-    
 }
 
 /**
  * Returns first element matching the given *predicate*
  */
-public inline fun FloatArray.first(predicate: (Float) -> Boolean) : Float {
+public inline fun FloatArray.first(predicate: (Float) -> Boolean): Float {
     for (element in this) if (predicate(element)) return element
     throw IllegalArgumentException("No element matching predicate was found")
-    
 }
 
 /**
  * Returns first element matching the given *predicate*
  */
-public inline fun IntArray.first(predicate: (Int) -> Boolean) : Int {
+public inline fun IntArray.first(predicate: (Int) -> Boolean): Int {
     for (element in this) if (predicate(element)) return element
     throw IllegalArgumentException("No element matching predicate was found")
-    
 }
 
 /**
  * Returns first element matching the given *predicate*
  */
-public inline fun LongArray.first(predicate: (Long) -> Boolean) : Long {
+public inline fun LongArray.first(predicate: (Long) -> Boolean): Long {
     for (element in this) if (predicate(element)) return element
     throw IllegalArgumentException("No element matching predicate was found")
-    
 }
 
 /**
  * Returns first element matching the given *predicate*
  */
-public inline fun ShortArray.first(predicate: (Short) -> Boolean) : Short {
+public inline fun ShortArray.first(predicate: (Short) -> Boolean): Short {
     for (element in this) if (predicate(element)) return element
     throw IllegalArgumentException("No element matching predicate was found")
-    
 }
 
 /**
  * Returns first element matching the given *predicate*
  */
-public inline fun <T> Iterable<T>.first(predicate: (T) -> Boolean) : T {
+public inline fun <T> Iterable<T>.first(predicate: (T) -> Boolean): T {
     for (element in this) if (predicate(element)) return element
     throw IllegalArgumentException("No element matching predicate was found")
-    
 }
 
 /**
  * Returns first element matching the given *predicate*
  */
-public inline fun <T> Stream<T>.first(predicate: (T) -> Boolean) : T {
+public inline fun <T> Stream<T>.first(predicate: (T) -> Boolean): T {
     for (element in this) if (predicate(element)) return element
     throw IllegalArgumentException("No element matching predicate was found")
-    
 }
 
 /**
  * Returns first element matching the given *predicate*
  */
-public inline fun String.first(predicate: (Char) -> Boolean) : Char {
+public inline fun String.first(predicate: (Char) -> Boolean): Char {
     for (element in this) if (predicate(element)) return element
     throw IllegalArgumentException("No element matching predicate was found")
-    
 }
 
 /**
  * Returns first elementm, or null if collection is empty
  */
-public fun <T> Array<out T>.firstOrNull() : T? {
+public fun <T> Array<out T>.firstOrNull(): T? {
     return if (size > 0) this[0] else null
-    
 }
 
 /**
  * Returns first elementm, or null if collection is empty
  */
-public fun BooleanArray.firstOrNull() : Boolean? {
+public fun BooleanArray.firstOrNull(): Boolean? {
     return if (size > 0) this[0] else null
-    
 }
 
 /**
  * Returns first elementm, or null if collection is empty
  */
-public fun ByteArray.firstOrNull() : Byte? {
+public fun ByteArray.firstOrNull(): Byte? {
     return if (size > 0) this[0] else null
-    
 }
 
 /**
  * Returns first elementm, or null if collection is empty
  */
-public fun CharArray.firstOrNull() : Char? {
+public fun CharArray.firstOrNull(): Char? {
     return if (size > 0) this[0] else null
-    
 }
 
 /**
  * Returns first elementm, or null if collection is empty
  */
-public fun DoubleArray.firstOrNull() : Double? {
+public fun DoubleArray.firstOrNull(): Double? {
     return if (size > 0) this[0] else null
-    
 }
 
 /**
  * Returns first elementm, or null if collection is empty
  */
-public fun FloatArray.firstOrNull() : Float? {
+public fun FloatArray.firstOrNull(): Float? {
     return if (size > 0) this[0] else null
-    
 }
 
 /**
  * Returns first elementm, or null if collection is empty
  */
-public fun IntArray.firstOrNull() : Int? {
+public fun IntArray.firstOrNull(): Int? {
     return if (size > 0) this[0] else null
-    
 }
 
 /**
  * Returns first elementm, or null if collection is empty
  */
-public fun LongArray.firstOrNull() : Long? {
+public fun LongArray.firstOrNull(): Long? {
     return if (size > 0) this[0] else null
-    
 }
 
 /**
  * Returns first elementm, or null if collection is empty
  */
-public fun ShortArray.firstOrNull() : Short? {
+public fun ShortArray.firstOrNull(): Short? {
     return if (size > 0) this[0] else null
-    
 }
 
 /**
@@ -572,9 +516,8 @@ public fun <T> Iterable<T>.firstOrNull(): T? {
 /**
  * Returns first elementm, or null if collection is empty
  */
-public fun <T> List<T>.firstOrNull() : T? {
+public fun <T> List<T>.firstOrNull(): T? {
     return if (size > 0) this[0] else null
-    
 }
 
 /**
@@ -600,123 +543,110 @@ public fun <T> Stream<T>.firstOrNull(): T? {
 /**
  * Returns first elementm, or null if collection is empty
  */
-public fun String.firstOrNull() : Char? {
+public fun String.firstOrNull(): Char? {
     return if (size > 0) this[0] else null
-    
 }
 
 /**
  * Returns first element matching the given *predicate*, or *null* if element was not found
  */
-public inline fun <T> Array<out T>.firstOrNull(predicate: (T) -> Boolean) : T? {
+public inline fun <T> Array<out T>.firstOrNull(predicate: (T) -> Boolean): T? {
     for (element in this) if (predicate(element)) return element
     return null
-    
 }
 
 /**
  * Returns first element matching the given *predicate*, or *null* if element was not found
  */
-public inline fun BooleanArray.firstOrNull(predicate: (Boolean) -> Boolean) : Boolean? {
+public inline fun BooleanArray.firstOrNull(predicate: (Boolean) -> Boolean): Boolean? {
     for (element in this) if (predicate(element)) return element
     return null
-    
 }
 
 /**
  * Returns first element matching the given *predicate*, or *null* if element was not found
  */
-public inline fun ByteArray.firstOrNull(predicate: (Byte) -> Boolean) : Byte? {
+public inline fun ByteArray.firstOrNull(predicate: (Byte) -> Boolean): Byte? {
     for (element in this) if (predicate(element)) return element
     return null
-    
 }
 
 /**
  * Returns first element matching the given *predicate*, or *null* if element was not found
  */
-public inline fun CharArray.firstOrNull(predicate: (Char) -> Boolean) : Char? {
+public inline fun CharArray.firstOrNull(predicate: (Char) -> Boolean): Char? {
     for (element in this) if (predicate(element)) return element
     return null
-    
 }
 
 /**
  * Returns first element matching the given *predicate*, or *null* if element was not found
  */
-public inline fun DoubleArray.firstOrNull(predicate: (Double) -> Boolean) : Double? {
+public inline fun DoubleArray.firstOrNull(predicate: (Double) -> Boolean): Double? {
     for (element in this) if (predicate(element)) return element
     return null
-    
 }
 
 /**
  * Returns first element matching the given *predicate*, or *null* if element was not found
  */
-public inline fun FloatArray.firstOrNull(predicate: (Float) -> Boolean) : Float? {
+public inline fun FloatArray.firstOrNull(predicate: (Float) -> Boolean): Float? {
     for (element in this) if (predicate(element)) return element
     return null
-    
 }
 
 /**
  * Returns first element matching the given *predicate*, or *null* if element was not found
  */
-public inline fun IntArray.firstOrNull(predicate: (Int) -> Boolean) : Int? {
+public inline fun IntArray.firstOrNull(predicate: (Int) -> Boolean): Int? {
     for (element in this) if (predicate(element)) return element
     return null
-    
 }
 
 /**
  * Returns first element matching the given *predicate*, or *null* if element was not found
  */
-public inline fun LongArray.firstOrNull(predicate: (Long) -> Boolean) : Long? {
+public inline fun LongArray.firstOrNull(predicate: (Long) -> Boolean): Long? {
     for (element in this) if (predicate(element)) return element
     return null
-    
 }
 
 /**
  * Returns first element matching the given *predicate*, or *null* if element was not found
  */
-public inline fun ShortArray.firstOrNull(predicate: (Short) -> Boolean) : Short? {
+public inline fun ShortArray.firstOrNull(predicate: (Short) -> Boolean): Short? {
     for (element in this) if (predicate(element)) return element
     return null
-    
 }
 
 /**
  * Returns first element matching the given *predicate*, or *null* if element was not found
  */
-public inline fun <T> Iterable<T>.firstOrNull(predicate: (T) -> Boolean) : T? {
+public inline fun <T> Iterable<T>.firstOrNull(predicate: (T) -> Boolean): T? {
     for (element in this) if (predicate(element)) return element
     return null
-    
 }
 
 /**
  * Returns first element matching the given *predicate*, or *null* if element was not found
  */
-public inline fun <T> Stream<T>.firstOrNull(predicate: (T) -> Boolean) : T? {
+public inline fun <T> Stream<T>.firstOrNull(predicate: (T) -> Boolean): T? {
     for (element in this) if (predicate(element)) return element
     return null
-    
 }
 
 /**
  * Returns first element matching the given *predicate*, or *null* if element was not found
  */
-public inline fun String.firstOrNull(predicate: (Char) -> Boolean) : Char? {
+public inline fun String.firstOrNull(predicate: (Char) -> Boolean): Char? {
     for (element in this) if (predicate(element)) return element
     return null
-    
 }
 
 /**
  * Returns first index of *element*, or -1 if the collection does not contain element
  */
-public fun <T> Array<out T>.indexOf(element: T) : Int {
+public fun <T> Array<out T>.indexOf(element: T): Int {
     if (element == null) {
         for (index in indices) {
             if (this[index] == null) {
@@ -731,117 +661,108 @@ public fun <T> Array<out T>.indexOf(element: T) : Int {
         }
     }
     return -1
-    
 }
 
 /**
  * Returns first index of *element*, or -1 if the collection does not contain element
  */
-public fun BooleanArray.indexOf(element: Boolean) : Int {
+public fun BooleanArray.indexOf(element: Boolean): Int {
     for (index in indices) {
         if (element == this[index]) {
             return index
         }
     }
     return -1
-    
 }
 
 /**
  * Returns first index of *element*, or -1 if the collection does not contain element
  */
-public fun ByteArray.indexOf(element: Byte) : Int {
+public fun ByteArray.indexOf(element: Byte): Int {
     for (index in indices) {
         if (element == this[index]) {
             return index
         }
     }
     return -1
-    
 }
 
 /**
  * Returns first index of *element*, or -1 if the collection does not contain element
  */
-public fun CharArray.indexOf(element: Char) : Int {
+public fun CharArray.indexOf(element: Char): Int {
     for (index in indices) {
         if (element == this[index]) {
             return index
         }
     }
     return -1
-    
 }
 
 /**
  * Returns first index of *element*, or -1 if the collection does not contain element
  */
-public fun DoubleArray.indexOf(element: Double) : Int {
+public fun DoubleArray.indexOf(element: Double): Int {
     for (index in indices) {
         if (element == this[index]) {
             return index
         }
     }
     return -1
-    
 }
 
 /**
  * Returns first index of *element*, or -1 if the collection does not contain element
  */
-public fun FloatArray.indexOf(element: Float) : Int {
+public fun FloatArray.indexOf(element: Float): Int {
     for (index in indices) {
         if (element == this[index]) {
             return index
         }
     }
     return -1
-    
 }
 
 /**
  * Returns first index of *element*, or -1 if the collection does not contain element
  */
-public fun IntArray.indexOf(element: Int) : Int {
+public fun IntArray.indexOf(element: Int): Int {
     for (index in indices) {
         if (element == this[index]) {
             return index
         }
     }
     return -1
-    
 }
 
 /**
  * Returns first index of *element*, or -1 if the collection does not contain element
  */
-public fun LongArray.indexOf(element: Long) : Int {
+public fun LongArray.indexOf(element: Long): Int {
     for (index in indices) {
         if (element == this[index]) {
             return index
         }
     }
     return -1
-    
 }
 
 /**
  * Returns first index of *element*, or -1 if the collection does not contain element
  */
-public fun ShortArray.indexOf(element: Short) : Int {
+public fun ShortArray.indexOf(element: Short): Int {
     for (index in indices) {
         if (element == this[index]) {
             return index
         }
     }
     return -1
-    
 }
 
 /**
  * Returns first index of *element*, or -1 if the collection does not contain element
  */
-public fun <T> Iterable<T>.indexOf(element: T) : Int {
+public fun <T> Iterable<T>.indexOf(element: T): Int {
     var index = 0
     for (item in this) {
         if (element == item)
@@ -849,13 +770,12 @@ public fun <T> Iterable<T>.indexOf(element: T) : Int {
         index++
     }
     return -1
-    
 }
 
 /**
  * Returns first index of *element*, or -1 if the collection does not contain element
  */
-public fun <T> Stream<T>.indexOf(element: T) : Int {
+public fun <T> Stream<T>.indexOf(element: T): Int {
     var index = 0
     for (item in this) {
         if (element == item)
@@ -863,108 +783,100 @@ public fun <T> Stream<T>.indexOf(element: T) : Int {
         index++
     }
     return -1
-    
 }
 
 /**
  * Returns last element
  */
-public fun <T> Array<out T>.last() : T {
+public fun <T> Array<out T>.last(): T {
     if (size == 0)
         throw IllegalArgumentException("Collection is empty")
     return this[size - 1]
-    
 }
 
 /**
  * Returns last element
  */
-public fun BooleanArray.last() : Boolean {
+public fun BooleanArray.last(): Boolean {
     if (size == 0)
         throw IllegalArgumentException("Collection is empty")
     return this[size - 1]
-    
 }
 
 /**
  * Returns last element
  */
-public fun ByteArray.last() : Byte {
+public fun ByteArray.last(): Byte {
     if (size == 0)
         throw IllegalArgumentException("Collection is empty")
     return this[size - 1]
-    
 }
 
 /**
  * Returns last element
  */
-public fun CharArray.last() : Char {
+public fun CharArray.last(): Char {
     if (size == 0)
         throw IllegalArgumentException("Collection is empty")
     return this[size - 1]
-    
 }
 
 /**
  * Returns last element
  */
-public fun DoubleArray.last() : Double {
+public fun DoubleArray.last(): Double {
     if (size == 0)
         throw IllegalArgumentException("Collection is empty")
     return this[size - 1]
-    
 }
 
 /**
  * Returns last element
  */
-public fun FloatArray.last() : Float {
+public fun FloatArray.last(): Float {
     if (size == 0)
         throw IllegalArgumentException("Collection is empty")
     return this[size - 1]
-    
 }
 
 /**
  * Returns last element
  */
-public fun IntArray.last() : Int {
+public fun IntArray.last(): Int {
     if (size == 0)
         throw IllegalArgumentException("Collection is empty")
     return this[size - 1]
-    
 }
 
 /**
  * Returns last element
  */
-public fun LongArray.last() : Long {
+public fun LongArray.last(): Long {
     if (size == 0)
         throw IllegalArgumentException("Collection is empty")
     return this[size - 1]
-    
 }
 
 /**
  * Returns last element
  */
-public fun ShortArray.last() : Short {
+public fun ShortArray.last(): Short {
     if (size == 0)
         throw IllegalArgumentException("Collection is empty")
     return this[size - 1]
-    
 }
 
 /**
  * Returns last element
  */
-public fun <T> Iterable<T>.last() : T {
+public fun <T> Iterable<T>.last(): T {
     when (this) {
-        is List<*> -> if (size == 0)
+        is List<*> -> {
+            if (size == 0)
                 throw IllegalArgumentException("Collection is empty")
             else
                 return this[size - 1] as T
+        }
         else -> {
             val iterator = iterator()
             if (!iterator.hasNext())
@@ -975,28 +887,28 @@ public fun <T> Iterable<T>.last() : T {
             return last
         }
     }
-    
 }
 
 /**
  * Returns last element
  */
-public fun <T> List<T>.last() : T {
+public fun <T> List<T>.last(): T {
     if (size == 0)
         throw IllegalArgumentException("Collection is empty")
     return this[size - 1]
-    
 }
 
 /**
  * Returns last element
  */
-public fun <T> Stream<T>.last() : T {
+public fun <T> Stream<T>.last(): T {
     when (this) {
-        is List<*> -> if (size == 0)
+        is List<*> -> {
+            if (size == 0)
                 throw IllegalArgumentException("Collection is empty")
             else
                 return this[size - 1] as T
+        }
         else -> {
             val iterator = iterator()
             if (!iterator.hasNext())
@@ -1007,23 +919,21 @@ public fun <T> Stream<T>.last() : T {
             return last
         }
     }
-    
 }
 
 /**
  * Returns last element
  */
-public fun String.last() : Char {
+public fun String.last(): Char {
     if (size == 0)
         throw IllegalArgumentException("Collection is empty")
     return this[size - 1]
-    
 }
 
 /**
  * Returns last element matching the given *predicate*
  */
-public inline fun <T> Array<out T>.last(predicate: (T) -> Boolean) : T {
+public inline fun <T> Array<out T>.last(predicate: (T) -> Boolean): T {
     var last: T? = null
     var found = false
     for (element in this) {
@@ -1034,13 +944,12 @@ public inline fun <T> Array<out T>.last(predicate: (T) -> Boolean) : T {
     }
     if (!found) throw IllegalArgumentException("Collection doesn't contain any element matching predicate")
     return last as T
-    
 }
 
 /**
  * Returns last element matching the given *predicate*
  */
-public inline fun BooleanArray.last(predicate: (Boolean) -> Boolean) : Boolean {
+public inline fun BooleanArray.last(predicate: (Boolean) -> Boolean): Boolean {
     var last: Boolean? = null
     var found = false
     for (element in this) {
@@ -1051,13 +960,12 @@ public inline fun BooleanArray.last(predicate: (Boolean) -> Boolean) : Boolean {
     }
     if (!found) throw IllegalArgumentException("Collection doesn't contain any element matching predicate")
     return last as Boolean
-    
 }
 
 /**
  * Returns last element matching the given *predicate*
  */
-public inline fun ByteArray.last(predicate: (Byte) -> Boolean) : Byte {
+public inline fun ByteArray.last(predicate: (Byte) -> Boolean): Byte {
     var last: Byte? = null
     var found = false
     for (element in this) {
@@ -1068,13 +976,12 @@ public inline fun ByteArray.last(predicate: (Byte) -> Boolean) : Byte {
     }
     if (!found) throw IllegalArgumentException("Collection doesn't contain any element matching predicate")
     return last as Byte
-    
 }
 
 /**
  * Returns last element matching the given *predicate*
  */
-public inline fun CharArray.last(predicate: (Char) -> Boolean) : Char {
+public inline fun CharArray.last(predicate: (Char) -> Boolean): Char {
     var last: Char? = null
     var found = false
     for (element in this) {
@@ -1085,13 +992,12 @@ public inline fun CharArray.last(predicate: (Char) -> Boolean) : Char {
     }
     if (!found) throw IllegalArgumentException("Collection doesn't contain any element matching predicate")
     return last as Char
-    
 }
 
 /**
  * Returns last element matching the given *predicate*
  */
-public inline fun DoubleArray.last(predicate: (Double) -> Boolean) : Double {
+public inline fun DoubleArray.last(predicate: (Double) -> Boolean): Double {
     var last: Double? = null
     var found = false
     for (element in this) {
@@ -1102,13 +1008,12 @@ public inline fun DoubleArray.last(predicate: (Double) -> Boolean) : Double {
     }
     if (!found) throw IllegalArgumentException("Collection doesn't contain any element matching predicate")
     return last as Double
-    
 }
 
 /**
  * Returns last element matching the given *predicate*
  */
-public inline fun FloatArray.last(predicate: (Float) -> Boolean) : Float {
+public inline fun FloatArray.last(predicate: (Float) -> Boolean): Float {
     var last: Float? = null
     var found = false
     for (element in this) {
@@ -1119,13 +1024,12 @@ public inline fun FloatArray.last(predicate: (Float) -> Boolean) : Float {
     }
     if (!found) throw IllegalArgumentException("Collection doesn't contain any element matching predicate")
     return last as Float
-    
 }
 
 /**
  * Returns last element matching the given *predicate*
  */
-public inline fun IntArray.last(predicate: (Int) -> Boolean) : Int {
+public inline fun IntArray.last(predicate: (Int) -> Boolean): Int {
     var last: Int? = null
     var found = false
     for (element in this) {
@@ -1136,13 +1040,12 @@ public inline fun IntArray.last(predicate: (Int) -> Boolean) : Int {
     }
     if (!found) throw IllegalArgumentException("Collection doesn't contain any element matching predicate")
     return last as Int
-    
 }
 
 /**
  * Returns last element matching the given *predicate*
  */
-public inline fun LongArray.last(predicate: (Long) -> Boolean) : Long {
+public inline fun LongArray.last(predicate: (Long) -> Boolean): Long {
     var last: Long? = null
     var found = false
     for (element in this) {
@@ -1153,13 +1056,12 @@ public inline fun LongArray.last(predicate: (Long) -> Boolean) : Long {
     }
     if (!found) throw IllegalArgumentException("Collection doesn't contain any element matching predicate")
     return last as Long
-    
 }
 
 /**
  * Returns last element matching the given *predicate*
  */
-public inline fun ShortArray.last(predicate: (Short) -> Boolean) : Short {
+public inline fun ShortArray.last(predicate: (Short) -> Boolean): Short {
     var last: Short? = null
     var found = false
     for (element in this) {
@@ -1170,13 +1072,12 @@ public inline fun ShortArray.last(predicate: (Short) -> Boolean) : Short {
     }
     if (!found) throw IllegalArgumentException("Collection doesn't contain any element matching predicate")
     return last as Short
-    
 }
 
 /**
  * Returns last element matching the given *predicate*
  */
-public inline fun <T> Iterable<T>.last(predicate: (T) -> Boolean) : T {
+public inline fun <T> Iterable<T>.last(predicate: (T) -> Boolean): T {
     var last: T? = null
     var found = false
     for (element in this) {
@@ -1187,13 +1088,12 @@ public inline fun <T> Iterable<T>.last(predicate: (T) -> Boolean) : T {
     }
     if (!found) throw IllegalArgumentException("Collection doesn't contain any element matching predicate")
     return last as T
-    
 }
 
 /**
  * Returns last element matching the given *predicate*
  */
-public inline fun <T> Stream<T>.last(predicate: (T) -> Boolean) : T {
+public inline fun <T> Stream<T>.last(predicate: (T) -> Boolean): T {
     var last: T? = null
     var found = false
     for (element in this) {
@@ -1204,13 +1104,12 @@ public inline fun <T> Stream<T>.last(predicate: (T) -> Boolean) : T {
     }
     if (!found) throw IllegalArgumentException("Collection doesn't contain any element matching predicate")
     return last as T
-    
 }
 
 /**
  * Returns last element matching the given *predicate*
  */
-public inline fun String.last(predicate: (Char) -> Boolean) : Char {
+public inline fun String.last(predicate: (Char) -> Boolean): Char {
     var last: Char? = null
     var found = false
     for (element in this) {
@@ -1221,13 +1120,12 @@ public inline fun String.last(predicate: (Char) -> Boolean) : Char {
     }
     if (!found) throw IllegalArgumentException("Collection doesn't contain any element matching predicate")
     return last as Char
-    
 }
 
 /**
  * Returns last index of *element*, or -1 if the collection does not contain element
  */
-public fun <T> Array<out T>.lastIndexOf(element: T) : Int {
+public fun <T> Array<out T>.lastIndexOf(element: T): Int {
     if (element == null) {
         for (index in indices.reverse()) {
             if (this[index] == null) {
@@ -1242,117 +1140,108 @@ public fun <T> Array<out T>.lastIndexOf(element: T) : Int {
         }
     }
     return -1
-    
 }
 
 /**
  * Returns last index of *element*, or -1 if the collection does not contain element
  */
-public fun BooleanArray.lastIndexOf(element: Boolean) : Int {
+public fun BooleanArray.lastIndexOf(element: Boolean): Int {
     for (index in indices.reverse()) {
         if (element == this[index]) {
             return index
         }
     }
     return -1
-    
 }
 
 /**
  * Returns last index of *element*, or -1 if the collection does not contain element
  */
-public fun ByteArray.lastIndexOf(element: Byte) : Int {
+public fun ByteArray.lastIndexOf(element: Byte): Int {
     for (index in indices.reverse()) {
         if (element == this[index]) {
             return index
         }
     }
     return -1
-    
 }
 
 /**
  * Returns last index of *element*, or -1 if the collection does not contain element
  */
-public fun CharArray.lastIndexOf(element: Char) : Int {
+public fun CharArray.lastIndexOf(element: Char): Int {
     for (index in indices.reverse()) {
         if (element == this[index]) {
             return index
         }
     }
     return -1
-    
 }
 
 /**
  * Returns last index of *element*, or -1 if the collection does not contain element
  */
-public fun DoubleArray.lastIndexOf(element: Double) : Int {
+public fun DoubleArray.lastIndexOf(element: Double): Int {
     for (index in indices.reverse()) {
         if (element == this[index]) {
             return index
         }
     }
     return -1
-    
 }
 
 /**
  * Returns last index of *element*, or -1 if the collection does not contain element
  */
-public fun FloatArray.lastIndexOf(element: Float) : Int {
+public fun FloatArray.lastIndexOf(element: Float): Int {
     for (index in indices.reverse()) {
         if (element == this[index]) {
             return index
         }
     }
     return -1
-    
 }
 
 /**
  * Returns last index of *element*, or -1 if the collection does not contain element
  */
-public fun IntArray.lastIndexOf(element: Int) : Int {
+public fun IntArray.lastIndexOf(element: Int): Int {
     for (index in indices.reverse()) {
         if (element == this[index]) {
             return index
         }
     }
     return -1
-    
 }
 
 /**
  * Returns last index of *element*, or -1 if the collection does not contain element
  */
-public fun LongArray.lastIndexOf(element: Long) : Int {
+public fun LongArray.lastIndexOf(element: Long): Int {
     for (index in indices.reverse()) {
         if (element == this[index]) {
             return index
         }
     }
     return -1
-    
 }
 
 /**
  * Returns last index of *element*, or -1 if the collection does not contain element
  */
-public fun ShortArray.lastIndexOf(element: Short) : Int {
+public fun ShortArray.lastIndexOf(element: Short): Int {
     for (index in indices.reverse()) {
         if (element == this[index]) {
             return index
         }
     }
     return -1
-    
 }
 
 /**
  * Returns last index of *element*, or -1 if the collection does not contain element
  */
-public fun <T> Iterable<T>.lastIndexOf(element: T) : Int {
+public fun <T> Iterable<T>.lastIndexOf(element: T): Int {
     var lastIndex = -1
     var index = 0
     for (item in this) {
@@ -1361,13 +1250,12 @@ public fun <T> Iterable<T>.lastIndexOf(element: T) : Int {
         index++
     }
     return lastIndex
-    
 }
 
 /**
  * Returns last index of *element*, or -1 if the collection does not contain element
  */
-public fun <T> List<T>.lastIndexOf(element: T) : Int {
+public fun <T> List<T>.lastIndexOf(element: T): Int {
     if (element == null) {
         for (index in indices.reverse()) {
             if (this[index] == null) {
@@ -1382,13 +1270,12 @@ public fun <T> List<T>.lastIndexOf(element: T) : Int {
         }
     }
     return -1
-    
 }
 
 /**
  * Returns last index of *element*, or -1 if the collection does not contain element
  */
-public fun <T> Stream<T>.lastIndexOf(element: T) : Int {
+public fun <T> Stream<T>.lastIndexOf(element: T): Int {
     var lastIndex = -1
     var index = 0
     for (item in this) {
@@ -1397,85 +1284,75 @@ public fun <T> Stream<T>.lastIndexOf(element: T) : Int {
         index++
     }
     return lastIndex
-    
 }
 
 /**
  * Returns last element, or null if collection is empty
  */
-public fun <T> Array<out T>.lastOrNull() : T? {
+public fun <T> Array<out T>.lastOrNull(): T? {
     return if (size > 0) this[size - 1] else null
-    
 }
 
 /**
  * Returns last element, or null if collection is empty
  */
-public fun BooleanArray.lastOrNull() : Boolean? {
+public fun BooleanArray.lastOrNull(): Boolean? {
     return if (size > 0) this[size - 1] else null
-    
 }
 
 /**
  * Returns last element, or null if collection is empty
  */
-public fun ByteArray.lastOrNull() : Byte? {
+public fun ByteArray.lastOrNull(): Byte? {
     return if (size > 0) this[size - 1] else null
-    
 }
 
 /**
  * Returns last element, or null if collection is empty
  */
-public fun CharArray.lastOrNull() : Char? {
+public fun CharArray.lastOrNull(): Char? {
     return if (size > 0) this[size - 1] else null
-    
 }
 
 /**
  * Returns last element, or null if collection is empty
  */
-public fun DoubleArray.lastOrNull() : Double? {
+public fun DoubleArray.lastOrNull(): Double? {
     return if (size > 0) this[size - 1] else null
-    
 }
 
 /**
  * Returns last element, or null if collection is empty
  */
-public fun FloatArray.lastOrNull() : Float? {
+public fun FloatArray.lastOrNull(): Float? {
     return if (size > 0) this[size - 1] else null
-    
 }
 
 /**
  * Returns last element, or null if collection is empty
  */
-public fun IntArray.lastOrNull() : Int? {
+public fun IntArray.lastOrNull(): Int? {
     return if (size > 0) this[size - 1] else null
-    
 }
 
 /**
  * Returns last element, or null if collection is empty
  */
-public fun LongArray.lastOrNull() : Long? {
+public fun LongArray.lastOrNull(): Long? {
     return if (size > 0) this[size - 1] else null
-    
 }
 
 /**
  * Returns last element, or null if collection is empty
  */
-public fun ShortArray.lastOrNull() : Short? {
+public fun ShortArray.lastOrNull(): Short? {
     return if (size > 0) this[size - 1] else null
-    
 }
 
 /**
  * Returns last element, or null if collection is empty
  */
-public fun <T> Iterable<T>.lastOrNull() : T? {
+public fun <T> Iterable<T>.lastOrNull(): T? {
     when (this) {
         is List<*> -> return if (size > 0) this[size - 1] as T else null
         else -> {
@@ -1488,21 +1365,19 @@ public fun <T> Iterable<T>.lastOrNull() : T? {
             return last
         }
     }
-    
 }
 
 /**
  * Returns last element, or null if collection is empty
  */
-public fun <T> List<T>.lastOrNull() : T? {
+public fun <T> List<T>.lastOrNull(): T? {
     return if (size > 0) this[size - 1] else null
-    
 }
 
 /**
  * Returns last element, or null if collection is empty
  */
-public fun <T> Stream<T>.lastOrNull() : T? {
+public fun <T> Stream<T>.lastOrNull(): T? {
     when (this) {
         is List<*> -> return if (size > 0) this[size - 1] as T else null
         else -> {
@@ -1515,21 +1390,19 @@ public fun <T> Stream<T>.lastOrNull() : T? {
             return last
         }
     }
-    
 }
 
 /**
  * Returns last element, or null if collection is empty
  */
-public fun String.lastOrNull() : Char? {
+public fun String.lastOrNull(): Char? {
     return if (size > 0) this[size - 1] else null
-    
 }
 
 /**
  * Returns last element matching the given *predicate*, or null if element was not found
  */
-public inline fun <T> Array<out T>.lastOrNull(predicate: (T) -> Boolean) : T? {
+public inline fun <T> Array<out T>.lastOrNull(predicate: (T) -> Boolean): T? {
     var last: T? = null
     for (element in this) {
         if (predicate(element)) {
@@ -1537,13 +1410,12 @@ public inline fun <T> Array<out T>.lastOrNull(predicate: (T) -> Boolean) : T? {
         }
     }
     return last
-    
 }
 
 /**
  * Returns last element matching the given *predicate*, or null if element was not found
  */
-public inline fun BooleanArray.lastOrNull(predicate: (Boolean) -> Boolean) : Boolean? {
+public inline fun BooleanArray.lastOrNull(predicate: (Boolean) -> Boolean): Boolean? {
     var last: Boolean? = null
     for (element in this) {
         if (predicate(element)) {
@@ -1551,13 +1423,12 @@ public inline fun BooleanArray.lastOrNull(predicate: (Boolean) -> Boolean) : Boo
         }
     }
     return last
-    
 }
 
 /**
  * Returns last element matching the given *predicate*, or null if element was not found
  */
-public inline fun ByteArray.lastOrNull(predicate: (Byte) -> Boolean) : Byte? {
+public inline fun ByteArray.lastOrNull(predicate: (Byte) -> Boolean): Byte? {
     var last: Byte? = null
     for (element in this) {
         if (predicate(element)) {
@@ -1565,13 +1436,12 @@ public inline fun ByteArray.lastOrNull(predicate: (Byte) -> Boolean) : Byte? {
         }
     }
     return last
-    
 }
 
 /**
  * Returns last element matching the given *predicate*, or null if element was not found
  */
-public inline fun CharArray.lastOrNull(predicate: (Char) -> Boolean) : Char? {
+public inline fun CharArray.lastOrNull(predicate: (Char) -> Boolean): Char? {
     var last: Char? = null
     for (element in this) {
         if (predicate(element)) {
@@ -1579,13 +1449,12 @@ public inline fun CharArray.lastOrNull(predicate: (Char) -> Boolean) : Char? {
         }
     }
     return last
-    
 }
 
 /**
  * Returns last element matching the given *predicate*, or null if element was not found
  */
-public inline fun DoubleArray.lastOrNull(predicate: (Double) -> Boolean) : Double? {
+public inline fun DoubleArray.lastOrNull(predicate: (Double) -> Boolean): Double? {
     var last: Double? = null
     for (element in this) {
         if (predicate(element)) {
@@ -1593,13 +1462,12 @@ public inline fun DoubleArray.lastOrNull(predicate: (Double) -> Boolean) : Doubl
         }
     }
     return last
-    
 }
 
 /**
  * Returns last element matching the given *predicate*, or null if element was not found
  */
-public inline fun FloatArray.lastOrNull(predicate: (Float) -> Boolean) : Float? {
+public inline fun FloatArray.lastOrNull(predicate: (Float) -> Boolean): Float? {
     var last: Float? = null
     for (element in this) {
         if (predicate(element)) {
@@ -1607,13 +1475,12 @@ public inline fun FloatArray.lastOrNull(predicate: (Float) -> Boolean) : Float?
         }
     }
     return last
-    
 }
 
 /**
  * Returns last element matching the given *predicate*, or null if element was not found
  */
-public inline fun IntArray.lastOrNull(predicate: (Int) -> Boolean) : Int? {
+public inline fun IntArray.lastOrNull(predicate: (Int) -> Boolean): Int? {
     var last: Int? = null
     for (element in this) {
         if (predicate(element)) {
@@ -1621,13 +1488,12 @@ public inline fun IntArray.lastOrNull(predicate: (Int) -> Boolean) : Int? {
         }
     }
     return last
-    
 }
 
 /**
  * Returns last element matching the given *predicate*, or null if element was not found
  */
-public inline fun LongArray.lastOrNull(predicate: (Long) -> Boolean) : Long? {
+public inline fun LongArray.lastOrNull(predicate: (Long) -> Boolean): Long? {
     var last: Long? = null
     for (element in this) {
         if (predicate(element)) {
@@ -1635,13 +1501,12 @@ public inline fun LongArray.lastOrNull(predicate: (Long) -> Boolean) : Long? {
         }
     }
     return last
-    
 }
 
 /**
  * Returns last element matching the given *predicate*, or null if element was not found
  */
-public inline fun ShortArray.lastOrNull(predicate: (Short) -> Boolean) : Short? {
+public inline fun ShortArray.lastOrNull(predicate: (Short) -> Boolean): Short? {
     var last: Short? = null
     for (element in this) {
         if (predicate(element)) {
@@ -1649,13 +1514,12 @@ public inline fun ShortArray.lastOrNull(predicate: (Short) -> Boolean) : Short?
         }
     }
     return last
-    
 }
 
 /**
  * Returns last element matching the given *predicate*, or null if element was not found
  */
-public inline fun <T> Iterable<T>.lastOrNull(predicate: (T) -> Boolean) : T? {
+public inline fun <T> Iterable<T>.lastOrNull(predicate: (T) -> Boolean): T? {
     var last: T? = null
     for (element in this) {
         if (predicate(element)) {
@@ -1663,13 +1527,12 @@ public inline fun <T> Iterable<T>.lastOrNull(predicate: (T) -> Boolean) : T? {
         }
     }
     return last
-    
 }
 
 /**
  * Returns last element matching the given *predicate*, or null if element was not found
  */
-public inline fun <T> Stream<T>.lastOrNull(predicate: (T) -> Boolean) : T? {
+public inline fun <T> Stream<T>.lastOrNull(predicate: (T) -> Boolean): T? {
     var last: T? = null
     for (element in this) {
         if (predicate(element)) {
@@ -1677,13 +1540,12 @@ public inline fun <T> Stream<T>.lastOrNull(predicate: (T) -> Boolean) : T? {
         }
     }
     return last
-    
 }
 
 /**
  * Returns last element matching the given *predicate*, or null if element was not found
  */
-public inline fun String.lastOrNull(predicate: (Char) -> Boolean) : Char? {
+public inline fun String.lastOrNull(predicate: (Char) -> Boolean): Char? {
     var last: Char? = null
     for (element in this) {
         if (predicate(element)) {
@@ -1691,103 +1553,93 @@ public inline fun String.lastOrNull(predicate: (Char) -> Boolean) : Char? {
         }
     }
     return last
-    
 }
 
 /**
  * Returns single element, or throws exception if there is no or more than one element
  */
-public fun <T> Array<out T>.single() : T {
+public fun <T> Array<out T>.single(): T {
     if (size != 1)
         throw IllegalArgumentException("Collection has $size elements")
     return this[0]
-    
 }
 
 /**
  * Returns single element, or throws exception if there is no or more than one element
  */
-public fun BooleanArray.single() : Boolean {
+public fun BooleanArray.single(): Boolean {
     if (size != 1)
         throw IllegalArgumentException("Collection has $size elements")
     return this[0]
-    
 }
 
 /**
  * Returns single element, or throws exception if there is no or more than one element
  */
-public fun ByteArray.single() : Byte {
+public fun ByteArray.single(): Byte {
     if (size != 1)
         throw IllegalArgumentException("Collection has $size elements")
     return this[0]
-    
 }
 
 /**
  * Returns single element, or throws exception if there is no or more than one element
  */
-public fun CharArray.single() : Char {
+public fun CharArray.single(): Char {
     if (size != 1)
         throw IllegalArgumentException("Collection has $size elements")
     return this[0]
-    
 }
 
 /**
  * Returns single element, or throws exception if there is no or more than one element
  */
-public fun DoubleArray.single() : Double {
+public fun DoubleArray.single(): Double {
     if (size != 1)
         throw IllegalArgumentException("Collection has $size elements")
     return this[0]
-    
 }
 
 /**
  * Returns single element, or throws exception if there is no or more than one element
  */
-public fun FloatArray.single() : Float {
+public fun FloatArray.single(): Float {
     if (size != 1)
         throw IllegalArgumentException("Collection has $size elements")
     return this[0]
-    
 }
 
 /**
  * Returns single element, or throws exception if there is no or more than one element
  */
-public fun IntArray.single() : Int {
+public fun IntArray.single(): Int {
     if (size != 1)
         throw IllegalArgumentException("Collection has $size elements")
     return this[0]
-    
 }
 
 /**
  * Returns single element, or throws exception if there is no or more than one element
  */
-public fun LongArray.single() : Long {
+public fun LongArray.single(): Long {
     if (size != 1)
         throw IllegalArgumentException("Collection has $size elements")
     return this[0]
-    
 }
 
 /**
  * Returns single element, or throws exception if there is no or more than one element
  */
-public fun ShortArray.single() : Short {
+public fun ShortArray.single(): Short {
     if (size != 1)
         throw IllegalArgumentException("Collection has $size elements")
     return this[0]
-    
 }
 
 /**
  * Returns single element, or throws exception if there is no or more than one element
  */
-public fun <T> Iterable<T>.single() : T {
+public fun <T> Iterable<T>.single(): T {
     when (this) {
         is List<*> -> return if (size == 1) this[0] as T else throw IllegalArgumentException("Collection has $size elements")
         else -> {
@@ -1800,23 +1652,21 @@ public fun <T> Iterable<T>.single() : T {
             return single
         }
     }
-    
 }
 
 /**
  * Returns single element, or throws exception if there is no or more than one element
  */
-public fun <T> List<T>.single() : T {
+public fun <T> List<T>.single(): T {
     if (size != 1)
         throw IllegalArgumentException("Collection has $size elements")
     return this[0]
-    
 }
 
 /**
  * Returns single element, or throws exception if there is no or more than one element
  */
-public fun <T> Stream<T>.single() : T {
+public fun <T> Stream<T>.single(): T {
     when (this) {
         is List<*> -> return if (size == 1) this[0] as T else throw IllegalArgumentException("Collection has $size elements")
         else -> {
@@ -1829,23 +1679,21 @@ public fun <T> Stream<T>.single() : T {
             return single
         }
     }
-    
 }
 
 /**
  * Returns single element, or throws exception if there is no or more than one element
  */
-public fun String.single() : Char {
+public fun String.single(): Char {
     if (size != 1)
         throw IllegalArgumentException("Collection has $size elements")
     return this[0]
-    
 }
 
 /**
  * Returns single element matching the given *predicate*, or throws exception if there is no or more than one element
  */
-public inline fun <T> Array<out T>.single(predicate: (T) -> Boolean) : T {
+public inline fun <T> Array<out T>.single(predicate: (T) -> Boolean): T {
     var single: T? = null
     var found = false
     for (element in this) {
@@ -1857,13 +1705,12 @@ public inline fun <T> Array<out T>.single(predicate: (T) -> Boolean) : T {
     }
     if (!found) throw IllegalArgumentException("Collection doesn't contain any element matching predicate")
     return single as T
-    
 }
 
 /**
  * Returns single element matching the given *predicate*, or throws exception if there is no or more than one element
  */
-public inline fun BooleanArray.single(predicate: (Boolean) -> Boolean) : Boolean {
+public inline fun BooleanArray.single(predicate: (Boolean) -> Boolean): Boolean {
     var single: Boolean? = null
     var found = false
     for (element in this) {
@@ -1875,13 +1722,12 @@ public inline fun BooleanArray.single(predicate: (Boolean) -> Boolean) : Boolean
     }
     if (!found) throw IllegalArgumentException("Collection doesn't contain any element matching predicate")
     return single as Boolean
-    
 }
 
 /**
  * Returns single element matching the given *predicate*, or throws exception if there is no or more than one element
  */
-public inline fun ByteArray.single(predicate: (Byte) -> Boolean) : Byte {
+public inline fun ByteArray.single(predicate: (Byte) -> Boolean): Byte {
     var single: Byte? = null
     var found = false
     for (element in this) {
@@ -1893,13 +1739,12 @@ public inline fun ByteArray.single(predicate: (Byte) -> Boolean) : Byte {
     }
     if (!found) throw IllegalArgumentException("Collection doesn't contain any element matching predicate")
     return single as Byte
-    
 }
 
 /**
  * Returns single element matching the given *predicate*, or throws exception if there is no or more than one element
  */
-public inline fun CharArray.single(predicate: (Char) -> Boolean) : Char {
+public inline fun CharArray.single(predicate: (Char) -> Boolean): Char {
     var single: Char? = null
     var found = false
     for (element in this) {
@@ -1911,13 +1756,12 @@ public inline fun CharArray.single(predicate: (Char) -> Boolean) : Char {
     }
     if (!found) throw IllegalArgumentException("Collection doesn't contain any element matching predicate")
     return single as Char
-    
 }
 
 /**
  * Returns single element matching the given *predicate*, or throws exception if there is no or more than one element
  */
-public inline fun DoubleArray.single(predicate: (Double) -> Boolean) : Double {
+public inline fun DoubleArray.single(predicate: (Double) -> Boolean): Double {
     var single: Double? = null
     var found = false
     for (element in this) {
@@ -1929,13 +1773,12 @@ public inline fun DoubleArray.single(predicate: (Double) -> Boolean) : Double {
     }
     if (!found) throw IllegalArgumentException("Collection doesn't contain any element matching predicate")
     return single as Double
-    
 }
 
 /**
  * Returns single element matching the given *predicate*, or throws exception if there is no or more than one element
  */
-public inline fun FloatArray.single(predicate: (Float) -> Boolean) : Float {
+public inline fun FloatArray.single(predicate: (Float) -> Boolean): Float {
     var single: Float? = null
     var found = false
     for (element in this) {
@@ -1947,13 +1790,12 @@ public inline fun FloatArray.single(predicate: (Float) -> Boolean) : Float {
     }
     if (!found) throw IllegalArgumentException("Collection doesn't contain any element matching predicate")
     return single as Float
-    
 }
 
 /**
  * Returns single element matching the given *predicate*, or throws exception if there is no or more than one element
  */
-public inline fun IntArray.single(predicate: (Int) -> Boolean) : Int {
+public inline fun IntArray.single(predicate: (Int) -> Boolean): Int {
     var single: Int? = null
     var found = false
     for (element in this) {
@@ -1965,13 +1807,12 @@ public inline fun IntArray.single(predicate: (Int) -> Boolean) : Int {
     }
     if (!found) throw IllegalArgumentException("Collection doesn't contain any element matching predicate")
     return single as Int
-    
 }
 
 /**
  * Returns single element matching the given *predicate*, or throws exception if there is no or more than one element
  */
-public inline fun LongArray.single(predicate: (Long) -> Boolean) : Long {
+public inline fun LongArray.single(predicate: (Long) -> Boolean): Long {
     var single: Long? = null
     var found = false
     for (element in this) {
@@ -1983,13 +1824,12 @@ public inline fun LongArray.single(predicate: (Long) -> Boolean) : Long {
     }
     if (!found) throw IllegalArgumentException("Collection doesn't contain any element matching predicate")
     return single as Long
-    
 }
 
 /**
  * Returns single element matching the given *predicate*, or throws exception if there is no or more than one element
  */
-public inline fun ShortArray.single(predicate: (Short) -> Boolean) : Short {
+public inline fun ShortArray.single(predicate: (Short) -> Boolean): Short {
     var single: Short? = null
     var found = false
     for (element in this) {
@@ -2001,13 +1841,12 @@ public inline fun ShortArray.single(predicate: (Short) -> Boolean) : Short {
     }
     if (!found) throw IllegalArgumentException("Collection doesn't contain any element matching predicate")
     return single as Short
-    
 }
 
 /**
  * Returns single element matching the given *predicate*, or throws exception if there is no or more than one element
  */
-public inline fun <T> Iterable<T>.single(predicate: (T) -> Boolean) : T {
+public inline fun <T> Iterable<T>.single(predicate: (T) -> Boolean): T {
     var single: T? = null
     var found = false
     for (element in this) {
@@ -2019,13 +1858,12 @@ public inline fun <T> Iterable<T>.single(predicate: (T) -> Boolean) : T {
     }
     if (!found) throw IllegalArgumentException("Collection doesn't contain any element matching predicate")
     return single as T
-    
 }
 
 /**
  * Returns single element matching the given *predicate*, or throws exception if there is no or more than one element
  */
-public inline fun <T> Stream<T>.single(predicate: (T) -> Boolean) : T {
+public inline fun <T> Stream<T>.single(predicate: (T) -> Boolean): T {
     var single: T? = null
     var found = false
     for (element in this) {
@@ -2037,13 +1875,12 @@ public inline fun <T> Stream<T>.single(predicate: (T) -> Boolean) : T {
     }
     if (!found) throw IllegalArgumentException("Collection doesn't contain any element matching predicate")
     return single as T
-    
 }
 
 /**
  * Returns single element matching the given *predicate*, or throws exception if there is no or more than one element
  */
-public inline fun String.single(predicate: (Char) -> Boolean) : Char {
+public inline fun String.single(predicate: (Char) -> Boolean): Char {
     var single: Char? = null
     var found = false
     for (element in this) {
@@ -2055,121 +1892,111 @@ public inline fun String.single(predicate: (Char) -> Boolean) : Char {
     }
     if (!found) throw IllegalArgumentException("Collection doesn't contain any element matching predicate")
     return single as Char
-    
 }
 
 /**
  * Returns single element, or null if collection is empty, or throws exception if there is more than one element
  */
-public fun <T> Array<out T>.singleOrNull() : T? {
+public fun <T> Array<out T>.singleOrNull(): T? {
     if (size == 0)
         return null
     if (size != 1)
         throw IllegalArgumentException("Collection has $size elements")
     return this[0]
-    
 }
 
 /**
  * Returns single element, or null if collection is empty, or throws exception if there is more than one element
  */
-public fun BooleanArray.singleOrNull() : Boolean? {
+public fun BooleanArray.singleOrNull(): Boolean? {
     if (size == 0)
         return null
     if (size != 1)
         throw IllegalArgumentException("Collection has $size elements")
     return this[0]
-    
 }
 
 /**
  * Returns single element, or null if collection is empty, or throws exception if there is more than one element
  */
-public fun ByteArray.singleOrNull() : Byte? {
+public fun ByteArray.singleOrNull(): Byte? {
     if (size == 0)
         return null
     if (size != 1)
         throw IllegalArgumentException("Collection has $size elements")
     return this[0]
-    
 }
 
 /**
  * Returns single element, or null if collection is empty, or throws exception if there is more than one element
  */
-public fun CharArray.singleOrNull() : Char? {
+public fun CharArray.singleOrNull(): Char? {
     if (size == 0)
         return null
     if (size != 1)
         throw IllegalArgumentException("Collection has $size elements")
     return this[0]
-    
 }
 
 /**
  * Returns single element, or null if collection is empty, or throws exception if there is more than one element
  */
-public fun DoubleArray.singleOrNull() : Double? {
+public fun DoubleArray.singleOrNull(): Double? {
     if (size == 0)
         return null
     if (size != 1)
         throw IllegalArgumentException("Collection has $size elements")
     return this[0]
-    
 }
 
 /**
  * Returns single element, or null if collection is empty, or throws exception if there is more than one element
  */
-public fun FloatArray.singleOrNull() : Float? {
+public fun FloatArray.singleOrNull(): Float? {
     if (size == 0)
         return null
     if (size != 1)
         throw IllegalArgumentException("Collection has $size elements")
     return this[0]
-    
 }
 
 /**
  * Returns single element, or null if collection is empty, or throws exception if there is more than one element
  */
-public fun IntArray.singleOrNull() : Int? {
+public fun IntArray.singleOrNull(): Int? {
     if (size == 0)
         return null
     if (size != 1)
         throw IllegalArgumentException("Collection has $size elements")
     return this[0]
-    
 }
 
 /**
  * Returns single element, or null if collection is empty, or throws exception if there is more than one element
  */
-public fun LongArray.singleOrNull() : Long? {
+public fun LongArray.singleOrNull(): Long? {
     if (size == 0)
         return null
     if (size != 1)
         throw IllegalArgumentException("Collection has $size elements")
     return this[0]
-    
 }
 
 /**
  * Returns single element, or null if collection is empty, or throws exception if there is more than one element
  */
-public fun ShortArray.singleOrNull() : Short? {
+public fun ShortArray.singleOrNull(): Short? {
     if (size == 0)
         return null
     if (size != 1)
         throw IllegalArgumentException("Collection has $size elements")
     return this[0]
-    
 }
 
 /**
  * Returns single element, or null if collection is empty, or throws exception if there is more than one element
  */
-public fun <T> Iterable<T>.singleOrNull() : T? {
+public fun <T> Iterable<T>.singleOrNull(): T? {
     when (this) {
         is List<*> -> return if (size == 1) this[0] as T else if (size == 0) null else throw IllegalArgumentException("Collection has $size elements")
         else -> {
@@ -2182,25 +2009,23 @@ public fun <T> Iterable<T>.singleOrNull() : T? {
             return single
         }
     }
-    
 }
 
 /**
  * Returns single element, or null if collection is empty, or throws exception if there is more than one element
  */
-public fun <T> List<T>.singleOrNull() : T? {
+public fun <T> List<T>.singleOrNull(): T? {
     if (size == 0)
         return null
     if (size != 1)
         throw IllegalArgumentException("Collection has $size elements")
     return this[0]
-    
 }
 
 /**
  * Returns single element, or null if collection is empty, or throws exception if there is more than one element
  */
-public fun <T> Stream<T>.singleOrNull() : T? {
+public fun <T> Stream<T>.singleOrNull(): T? {
     when (this) {
         is List<*> -> return if (size == 1) this[0] as T else if (size == 0) null else throw IllegalArgumentException("Collection has $size elements")
         else -> {
@@ -2213,25 +2038,23 @@ public fun <T> Stream<T>.singleOrNull() : T? {
             return single
         }
     }
-    
 }
 
 /**
  * Returns single element, or null if collection is empty, or throws exception if there is more than one element
  */
-public fun String.singleOrNull() : Char? {
+public fun String.singleOrNull(): Char? {
     if (size == 0)
         return null
     if (size != 1)
         throw IllegalArgumentException("Collection has $size elements")
     return this[0]
-    
 }
 
 /**
  * Returns single element matching the given *predicate*, or null if element was not found or more than one elements were found
  */
-public inline fun <T> Array<out T>.singleOrNull(predicate: (T) -> Boolean) : T? {
+public inline fun <T> Array<out T>.singleOrNull(predicate: (T) -> Boolean): T? {
     var single: T? = null
     var found = false
     for (element in this) {
@@ -2243,13 +2066,12 @@ public inline fun <T> Array<out T>.singleOrNull(predicate: (T) -> Boolean) : T?
     }
     if (!found) return null
     return single
-    
 }
 
 /**
  * Returns single element matching the given *predicate*, or null if element was not found or more than one elements were found
  */
-public inline fun BooleanArray.singleOrNull(predicate: (Boolean) -> Boolean) : Boolean? {
+public inline fun BooleanArray.singleOrNull(predicate: (Boolean) -> Boolean): Boolean? {
     var single: Boolean? = null
     var found = false
     for (element in this) {
@@ -2261,13 +2083,12 @@ public inline fun BooleanArray.singleOrNull(predicate: (Boolean) -> Boolean) : B
     }
     if (!found) return null
     return single
-    
 }
 
 /**
  * Returns single element matching the given *predicate*, or null if element was not found or more than one elements were found
  */
-public inline fun ByteArray.singleOrNull(predicate: (Byte) -> Boolean) : Byte? {
+public inline fun ByteArray.singleOrNull(predicate: (Byte) -> Boolean): Byte? {
     var single: Byte? = null
     var found = false
     for (element in this) {
@@ -2279,13 +2100,12 @@ public inline fun ByteArray.singleOrNull(predicate: (Byte) -> Boolean) : Byte? {
     }
     if (!found) return null
     return single
-    
 }
 
 /**
  * Returns single element matching the given *predicate*, or null if element was not found or more than one elements were found
  */
-public inline fun CharArray.singleOrNull(predicate: (Char) -> Boolean) : Char? {
+public inline fun CharArray.singleOrNull(predicate: (Char) -> Boolean): Char? {
     var single: Char? = null
     var found = false
     for (element in this) {
@@ -2297,13 +2117,12 @@ public inline fun CharArray.singleOrNull(predicate: (Char) -> Boolean) : Char? {
     }
     if (!found) return null
     return single
-    
 }
 
 /**
  * Returns single element matching the given *predicate*, or null if element was not found or more than one elements were found
  */
-public inline fun DoubleArray.singleOrNull(predicate: (Double) -> Boolean) : Double? {
+public inline fun DoubleArray.singleOrNull(predicate: (Double) -> Boolean): Double? {
     var single: Double? = null
     var found = false
     for (element in this) {
@@ -2315,13 +2134,12 @@ public inline fun DoubleArray.singleOrNull(predicate: (Double) -> Boolean) : Dou
     }
     if (!found) return null
     return single
-    
 }
 
 /**
  * Returns single element matching the given *predicate*, or null if element was not found or more than one elements were found
  */
-public inline fun FloatArray.singleOrNull(predicate: (Float) -> Boolean) : Float? {
+public inline fun FloatArray.singleOrNull(predicate: (Float) -> Boolean): Float? {
     var single: Float? = null
     var found = false
     for (element in this) {
@@ -2333,13 +2151,12 @@ public inline fun FloatArray.singleOrNull(predicate: (Float) -> Boolean) : Float
     }
     if (!found) return null
     return single
-    
 }
 
 /**
  * Returns single element matching the given *predicate*, or null if element was not found or more than one elements were found
  */
-public inline fun IntArray.singleOrNull(predicate: (Int) -> Boolean) : Int? {
+public inline fun IntArray.singleOrNull(predicate: (Int) -> Boolean): Int? {
     var single: Int? = null
     var found = false
     for (element in this) {
@@ -2351,13 +2168,12 @@ public inline fun IntArray.singleOrNull(predicate: (Int) -> Boolean) : Int? {
     }
     if (!found) return null
     return single
-    
 }
 
 /**
  * Returns single element matching the given *predicate*, or null if element was not found or more than one elements were found
  */
-public inline fun LongArray.singleOrNull(predicate: (Long) -> Boolean) : Long? {
+public inline fun LongArray.singleOrNull(predicate: (Long) -> Boolean): Long? {
     var single: Long? = null
     var found = false
     for (element in this) {
@@ -2369,13 +2185,12 @@ public inline fun LongArray.singleOrNull(predicate: (Long) -> Boolean) : Long? {
     }
     if (!found) return null
     return single
-    
 }
 
 /**
  * Returns single element matching the given *predicate*, or null if element was not found or more than one elements were found
  */
-public inline fun ShortArray.singleOrNull(predicate: (Short) -> Boolean) : Short? {
+public inline fun ShortArray.singleOrNull(predicate: (Short) -> Boolean): Short? {
     var single: Short? = null
     var found = false
     for (element in this) {
@@ -2387,13 +2202,12 @@ public inline fun ShortArray.singleOrNull(predicate: (Short) -> Boolean) : Short
     }
     if (!found) return null
     return single
-    
 }
 
 /**
  * Returns single element matching the given *predicate*, or null if element was not found or more than one elements were found
  */
-public inline fun <T> Iterable<T>.singleOrNull(predicate: (T) -> Boolean) : T? {
+public inline fun <T> Iterable<T>.singleOrNull(predicate: (T) -> Boolean): T? {
     var single: T? = null
     var found = false
     for (element in this) {
@@ -2405,13 +2219,12 @@ public inline fun <T> Iterable<T>.singleOrNull(predicate: (T) -> Boolean) : T? {
     }
     if (!found) return null
     return single
-    
 }
 
 /**
  * Returns single element matching the given *predicate*, or null if element was not found or more than one elements were found
  */
-public inline fun <T> Stream<T>.singleOrNull(predicate: (T) -> Boolean) : T? {
+public inline fun <T> Stream<T>.singleOrNull(predicate: (T) -> Boolean): T? {
     var single: T? = null
     var found = false
     for (element in this) {
@@ -2423,13 +2236,12 @@ public inline fun <T> Stream<T>.singleOrNull(predicate: (T) -> Boolean) : T? {
     }
     if (!found) return null
     return single
-    
 }
 
 /**
  * Returns single element matching the given *predicate*, or null if element was not found or more than one elements were found
  */
-public inline fun String.singleOrNull(predicate: (Char) -> Boolean) : Char? {
+public inline fun String.singleOrNull(predicate: (Char) -> Boolean): Char? {
     var single: Char? = null
     var found = false
     for (element in this) {
@@ -2441,6 +2253,5 @@ public inline fun String.singleOrNull(predicate: (Char) -> Boolean) : Char? {
     }
     if (!found) return null
     return single
-    
 }
 
diff --git a/libraries/stdlib/src/generated/_Filtering.kt b/libraries/stdlib/src/generated/_Filtering.kt
index 2d0ba33ecd5..80c99b6ba71 100644
--- a/libraries/stdlib/src/generated/_Filtering.kt
+++ b/libraries/stdlib/src/generated/_Filtering.kt
@@ -10,377 +10,344 @@ import java.util.*
 /**
  * Returns a list containing all elements except first *n* elements
  */
-public fun <T> Array<out T>.drop(n: Int) : List<T> {
+public fun <T> Array<out T>.drop(n: Int): List<T> {
     if (n >= size)
         return ArrayList<T>()
-    
     var count = 0
     val list = ArrayList<T>(size - n)
     for (item in this) {
         if (count++ >= n) list.add(item)
     }
     return list
-    
 }
 
 /**
  * Returns a list containing all elements except first *n* elements
  */
-public fun BooleanArray.drop(n: Int) : List<Boolean> {
+public fun BooleanArray.drop(n: Int): List<Boolean> {
     if (n >= size)
         return ArrayList<Boolean>()
-    
     var count = 0
     val list = ArrayList<Boolean>(size - n)
     for (item in this) {
         if (count++ >= n) list.add(item)
     }
     return list
-    
 }
 
 /**
  * Returns a list containing all elements except first *n* elements
  */
-public fun ByteArray.drop(n: Int) : List<Byte> {
+public fun ByteArray.drop(n: Int): List<Byte> {
     if (n >= size)
         return ArrayList<Byte>()
-    
     var count = 0
     val list = ArrayList<Byte>(size - n)
     for (item in this) {
         if (count++ >= n) list.add(item)
     }
     return list
-    
 }
 
 /**
  * Returns a list containing all elements except first *n* elements
  */
-public fun CharArray.drop(n: Int) : List<Char> {
+public fun CharArray.drop(n: Int): List<Char> {
     if (n >= size)
         return ArrayList<Char>()
-    
     var count = 0
     val list = ArrayList<Char>(size - n)
     for (item in this) {
         if (count++ >= n) list.add(item)
     }
     return list
-    
 }
 
 /**
  * Returns a list containing all elements except first *n* elements
  */
-public fun DoubleArray.drop(n: Int) : List<Double> {
+public fun DoubleArray.drop(n: Int): List<Double> {
     if (n >= size)
         return ArrayList<Double>()
-    
     var count = 0
     val list = ArrayList<Double>(size - n)
     for (item in this) {
         if (count++ >= n) list.add(item)
     }
     return list
-    
 }
 
 /**
  * Returns a list containing all elements except first *n* elements
  */
-public fun FloatArray.drop(n: Int) : List<Float> {
+public fun FloatArray.drop(n: Int): List<Float> {
     if (n >= size)
         return ArrayList<Float>()
-    
     var count = 0
     val list = ArrayList<Float>(size - n)
     for (item in this) {
         if (count++ >= n) list.add(item)
     }
     return list
-    
 }
 
 /**
  * Returns a list containing all elements except first *n* elements
  */
-public fun IntArray.drop(n: Int) : List<Int> {
+public fun IntArray.drop(n: Int): List<Int> {
     if (n >= size)
         return ArrayList<Int>()
-    
     var count = 0
     val list = ArrayList<Int>(size - n)
     for (item in this) {
         if (count++ >= n) list.add(item)
     }
     return list
-    
 }
 
 /**
  * Returns a list containing all elements except first *n* elements
  */
-public fun LongArray.drop(n: Int) : List<Long> {
+public fun LongArray.drop(n: Int): List<Long> {
     if (n >= size)
         return ArrayList<Long>()
-    
     var count = 0
     val list = ArrayList<Long>(size - n)
     for (item in this) {
         if (count++ >= n) list.add(item)
     }
     return list
-    
 }
 
 /**
  * Returns a list containing all elements except first *n* elements
  */
-public fun ShortArray.drop(n: Int) : List<Short> {
+public fun ShortArray.drop(n: Int): List<Short> {
     if (n >= size)
         return ArrayList<Short>()
-    
     var count = 0
     val list = ArrayList<Short>(size - n)
     for (item in this) {
         if (count++ >= n) list.add(item)
     }
     return list
-    
 }
 
 /**
  * Returns a list containing all elements except first *n* elements
  */
-public fun <T> Collection<T>.drop(n: Int) : List<T> {
+public fun <T> Collection<T>.drop(n: Int): List<T> {
     if (n >= size)
         return ArrayList<T>()
-    
     var count = 0
     val list = ArrayList<T>(size - n)
     for (item in this) {
         if (count++ >= n) list.add(item)
     }
     return list
-    
 }
 
 /**
  * Returns a list containing all elements except first *n* elements
  */
-public fun <T> Iterable<T>.drop(n: Int) : List<T> {
+public fun <T> Iterable<T>.drop(n: Int): List<T> {
     var count = 0
     val list = ArrayList<T>()
     for (item in this) {
         if (count++ >= n) list.add(item)
     }
     return list
-    
 }
 
 /**
  * Returns a stream containing all elements except first *n* elements
  */
-public fun <T> Stream<T>.drop(n: Int) : Stream<T> {
+public fun <T> Stream<T>.drop(n: Int): Stream<T> {
     var count = 0;
     return FilteringStream(this) { count++ >= n }
-    
 }
 
 /**
  * Returns a list containing all elements except first *n* elements
  */
-public fun String.drop(n: Int) : String {
+public fun String.drop(n: Int): String {
     return substring(Math.min(n, size))
 }
 
 /**
  * Returns a list containing all elements except first elements that satisfy the given *predicate*
  */
-public inline fun <T> Array<out T>.dropWhile(predicate: (T)->Boolean) : List<T> {
+public inline fun <T> Array<out T>.dropWhile(predicate: (T) -> Boolean): List<T> {
     var yielding = false
     val list = ArrayList<T>()
     for (item in this)
         if (yielding)
             list.add(item)
-        else if(!predicate(item)) {
+        else if (!predicate(item)) {
             list.add(item)
             yielding = true
         }
     return list
-    
 }
 
 /**
  * Returns a list containing all elements except first elements that satisfy the given *predicate*
  */
-public inline fun BooleanArray.dropWhile(predicate: (Boolean)->Boolean) : List<Boolean> {
+public inline fun BooleanArray.dropWhile(predicate: (Boolean) -> Boolean): List<Boolean> {
     var yielding = false
     val list = ArrayList<Boolean>()
     for (item in this)
         if (yielding)
             list.add(item)
-        else if(!predicate(item)) {
+        else if (!predicate(item)) {
             list.add(item)
             yielding = true
         }
     return list
-    
 }
 
 /**
  * Returns a list containing all elements except first elements that satisfy the given *predicate*
  */
-public inline fun ByteArray.dropWhile(predicate: (Byte)->Boolean) : List<Byte> {
+public inline fun ByteArray.dropWhile(predicate: (Byte) -> Boolean): List<Byte> {
     var yielding = false
     val list = ArrayList<Byte>()
     for (item in this)
         if (yielding)
             list.add(item)
-        else if(!predicate(item)) {
+        else if (!predicate(item)) {
             list.add(item)
             yielding = true
         }
     return list
-    
 }
 
 /**
  * Returns a list containing all elements except first elements that satisfy the given *predicate*
  */
-public inline fun CharArray.dropWhile(predicate: (Char)->Boolean) : List<Char> {
+public inline fun CharArray.dropWhile(predicate: (Char) -> Boolean): List<Char> {
     var yielding = false
     val list = ArrayList<Char>()
     for (item in this)
         if (yielding)
             list.add(item)
-        else if(!predicate(item)) {
+        else if (!predicate(item)) {
             list.add(item)
             yielding = true
         }
     return list
-    
 }
 
 /**
  * Returns a list containing all elements except first elements that satisfy the given *predicate*
  */
-public inline fun DoubleArray.dropWhile(predicate: (Double)->Boolean) : List<Double> {
+public inline fun DoubleArray.dropWhile(predicate: (Double) -> Boolean): List<Double> {
     var yielding = false
     val list = ArrayList<Double>()
     for (item in this)
         if (yielding)
             list.add(item)
-        else if(!predicate(item)) {
+        else if (!predicate(item)) {
             list.add(item)
             yielding = true
         }
     return list
-    
 }
 
 /**
  * Returns a list containing all elements except first elements that satisfy the given *predicate*
  */
-public inline fun FloatArray.dropWhile(predicate: (Float)->Boolean) : List<Float> {
+public inline fun FloatArray.dropWhile(predicate: (Float) -> Boolean): List<Float> {
     var yielding = false
     val list = ArrayList<Float>()
     for (item in this)
         if (yielding)
             list.add(item)
-        else if(!predicate(item)) {
+        else if (!predicate(item)) {
             list.add(item)
             yielding = true
         }
     return list
-    
 }
 
 /**
  * Returns a list containing all elements except first elements that satisfy the given *predicate*
  */
-public inline fun IntArray.dropWhile(predicate: (Int)->Boolean) : List<Int> {
+public inline fun IntArray.dropWhile(predicate: (Int) -> Boolean): List<Int> {
     var yielding = false
     val list = ArrayList<Int>()
     for (item in this)
         if (yielding)
             list.add(item)
-        else if(!predicate(item)) {
+        else if (!predicate(item)) {
             list.add(item)
             yielding = true
         }
     return list
-    
 }
 
 /**
  * Returns a list containing all elements except first elements that satisfy the given *predicate*
  */
-public inline fun LongArray.dropWhile(predicate: (Long)->Boolean) : List<Long> {
+public inline fun LongArray.dropWhile(predicate: (Long) -> Boolean): List<Long> {
     var yielding = false
     val list = ArrayList<Long>()
     for (item in this)
         if (yielding)
             list.add(item)
-        else if(!predicate(item)) {
+        else if (!predicate(item)) {
             list.add(item)
             yielding = true
         }
     return list
-    
 }
 
 /**
  * Returns a list containing all elements except first elements that satisfy the given *predicate*
  */
-public inline fun ShortArray.dropWhile(predicate: (Short)->Boolean) : List<Short> {
+public inline fun ShortArray.dropWhile(predicate: (Short) -> Boolean): List<Short> {
     var yielding = false
     val list = ArrayList<Short>()
     for (item in this)
         if (yielding)
             list.add(item)
-        else if(!predicate(item)) {
+        else if (!predicate(item)) {
             list.add(item)
             yielding = true
         }
     return list
-    
 }
 
 /**
  * Returns a list containing all elements except first elements that satisfy the given *predicate*
  */
-public inline fun <T> Iterable<T>.dropWhile(predicate: (T)->Boolean) : List<T> {
+public inline fun <T> Iterable<T>.dropWhile(predicate: (T) -> Boolean): List<T> {
     var yielding = false
     val list = ArrayList<T>()
     for (item in this)
         if (yielding)
             list.add(item)
-        else if(!predicate(item)) {
+        else if (!predicate(item)) {
             list.add(item)
             yielding = true
         }
     return list
-    
 }
 
 /**
  * Returns a stream containing all elements except first elements that satisfy the given *predicate*
  */
-public fun <T> Stream<T>.dropWhile(predicate: (T)->Boolean) : Stream<T> {
+public fun <T> Stream<T>.dropWhile(predicate: (T) -> Boolean): Stream<T> {
     var yielding = false
     return FilteringStream(this) {
-                if (yielding)
-                    true
-                else if (!predicate(it)) {
-                    yielding = true
-                    true
-                } else
-                    false
-            }
-    
+        if (yielding)
+            true
+        else if (!predicate(it)) {
+            yielding = true
+            true
+        } else
+            false
+    }
 }
 
 /**
@@ -392,491 +359,433 @@ public inline fun String.dropWhile(predicate: (Char) -> Boolean): String {
             return substring(index)
         }
     return ""
-    
 }
 
 /**
  * Returns a list containing all elements matching the given *predicate*
  */
-public inline fun <T> Array<out T>.filter(predicate: (T)->Boolean) : List<T> {
+public inline fun <T> Array<out T>.filter(predicate: (T) -> Boolean): List<T> {
     return filterTo(ArrayList<T>(), predicate)
-    
 }
 
 /**
  * Returns a list containing all elements matching the given *predicate*
  */
-public inline fun BooleanArray.filter(predicate: (Boolean)->Boolean) : List<Boolean> {
+public inline fun BooleanArray.filter(predicate: (Boolean) -> Boolean): List<Boolean> {
     return filterTo(ArrayList<Boolean>(), predicate)
-    
 }
 
 /**
  * Returns a list containing all elements matching the given *predicate*
  */
-public inline fun ByteArray.filter(predicate: (Byte)->Boolean) : List<Byte> {
+public inline fun ByteArray.filter(predicate: (Byte) -> Boolean): List<Byte> {
     return filterTo(ArrayList<Byte>(), predicate)
-    
 }
 
 /**
  * Returns a list containing all elements matching the given *predicate*
  */
-public inline fun CharArray.filter(predicate: (Char)->Boolean) : List<Char> {
+public inline fun CharArray.filter(predicate: (Char) -> Boolean): List<Char> {
     return filterTo(ArrayList<Char>(), predicate)
-    
 }
 
 /**
  * Returns a list containing all elements matching the given *predicate*
  */
-public inline fun DoubleArray.filter(predicate: (Double)->Boolean) : List<Double> {
+public inline fun DoubleArray.filter(predicate: (Double) -> Boolean): List<Double> {
     return filterTo(ArrayList<Double>(), predicate)
-    
 }
 
 /**
  * Returns a list containing all elements matching the given *predicate*
  */
-public inline fun FloatArray.filter(predicate: (Float)->Boolean) : List<Float> {
+public inline fun FloatArray.filter(predicate: (Float) -> Boolean): List<Float> {
     return filterTo(ArrayList<Float>(), predicate)
-    
 }
 
 /**
  * Returns a list containing all elements matching the given *predicate*
  */
-public inline fun IntArray.filter(predicate: (Int)->Boolean) : List<Int> {
+public inline fun IntArray.filter(predicate: (Int) -> Boolean): List<Int> {
     return filterTo(ArrayList<Int>(), predicate)
-    
 }
 
 /**
  * Returns a list containing all elements matching the given *predicate*
  */
-public inline fun LongArray.filter(predicate: (Long)->Boolean) : List<Long> {
+public inline fun LongArray.filter(predicate: (Long) -> Boolean): List<Long> {
     return filterTo(ArrayList<Long>(), predicate)
-    
 }
 
 /**
  * Returns a list containing all elements matching the given *predicate*
  */
-public inline fun ShortArray.filter(predicate: (Short)->Boolean) : List<Short> {
+public inline fun ShortArray.filter(predicate: (Short) -> Boolean): List<Short> {
     return filterTo(ArrayList<Short>(), predicate)
-    
 }
 
 /**
  * Returns a list containing all elements matching the given *predicate*
  */
-public inline fun <T> Iterable<T>.filter(predicate: (T)->Boolean) : List<T> {
+public inline fun <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T> {
     return filterTo(ArrayList<T>(), predicate)
-    
 }
 
 /**
  * Returns a list containing all elements matching the given *predicate*
  */
-public inline fun <K, V> Map<K,V>.filter(predicate: (Map.Entry<K,V>)->Boolean) : List<Map.Entry<K,V>> {
-    return filterTo(ArrayList<Map.Entry<K,V>>(), predicate)
-    
+public inline fun <K, V> Map<K, V>.filter(predicate: (Map.Entry<K, V>) -> Boolean): List<Map.Entry<K, V>> {
+    return filterTo(ArrayList<Map.Entry<K, V>>(), predicate)
 }
 
 /**
  * Returns a stream containing all elements matching the given *predicate*
  */
-public fun <T> Stream<T>.filter(predicate: (T)->Boolean) : Stream<T> {
+public fun <T> Stream<T>.filter(predicate: (T) -> Boolean): Stream<T> {
     return FilteringStream(this, true, predicate)
-    
 }
 
 /**
  * Returns a list containing all elements matching the given *predicate*
  */
-public inline fun String.filter(predicate: (Char)->Boolean) : String {
+public inline fun String.filter(predicate: (Char) -> Boolean): String {
     return filterTo(StringBuilder(), predicate).toString()
-    
 }
 
 /**
  * Returns a list containing all elements not matching the given *predicate*
  */
-public inline fun <T> Array<out T>.filterNot(predicate: (T)->Boolean) : List<T> {
+public inline fun <T> Array<out T>.filterNot(predicate: (T) -> Boolean): List<T> {
     return filterNotTo(ArrayList<T>(), predicate)
-    
 }
 
 /**
  * Returns a list containing all elements not matching the given *predicate*
  */
-public inline fun BooleanArray.filterNot(predicate: (Boolean)->Boolean) : List<Boolean> {
+public inline fun BooleanArray.filterNot(predicate: (Boolean) -> Boolean): List<Boolean> {
     return filterNotTo(ArrayList<Boolean>(), predicate)
-    
 }
 
 /**
  * Returns a list containing all elements not matching the given *predicate*
  */
-public inline fun ByteArray.filterNot(predicate: (Byte)->Boolean) : List<Byte> {
+public inline fun ByteArray.filterNot(predicate: (Byte) -> Boolean): List<Byte> {
     return filterNotTo(ArrayList<Byte>(), predicate)
-    
 }
 
 /**
  * Returns a list containing all elements not matching the given *predicate*
  */
-public inline fun CharArray.filterNot(predicate: (Char)->Boolean) : List<Char> {
+public inline fun CharArray.filterNot(predicate: (Char) -> Boolean): List<Char> {
     return filterNotTo(ArrayList<Char>(), predicate)
-    
 }
 
 /**
  * Returns a list containing all elements not matching the given *predicate*
  */
-public inline fun DoubleArray.filterNot(predicate: (Double)->Boolean) : List<Double> {
+public inline fun DoubleArray.filterNot(predicate: (Double) -> Boolean): List<Double> {
     return filterNotTo(ArrayList<Double>(), predicate)
-    
 }
 
 /**
  * Returns a list containing all elements not matching the given *predicate*
  */
-public inline fun FloatArray.filterNot(predicate: (Float)->Boolean) : List<Float> {
+public inline fun FloatArray.filterNot(predicate: (Float) -> Boolean): List<Float> {
     return filterNotTo(ArrayList<Float>(), predicate)
-    
 }
 
 /**
  * Returns a list containing all elements not matching the given *predicate*
  */
-public inline fun IntArray.filterNot(predicate: (Int)->Boolean) : List<Int> {
+public inline fun IntArray.filterNot(predicate: (Int) -> Boolean): List<Int> {
     return filterNotTo(ArrayList<Int>(), predicate)
-    
 }
 
 /**
  * Returns a list containing all elements not matching the given *predicate*
  */
-public inline fun LongArray.filterNot(predicate: (Long)->Boolean) : List<Long> {
+public inline fun LongArray.filterNot(predicate: (Long) -> Boolean): List<Long> {
     return filterNotTo(ArrayList<Long>(), predicate)
-    
 }
 
 /**
  * Returns a list containing all elements not matching the given *predicate*
  */
-public inline fun ShortArray.filterNot(predicate: (Short)->Boolean) : List<Short> {
+public inline fun ShortArray.filterNot(predicate: (Short) -> Boolean): List<Short> {
     return filterNotTo(ArrayList<Short>(), predicate)
-    
 }
 
 /**
  * Returns a list containing all elements not matching the given *predicate*
  */
-public inline fun <T> Iterable<T>.filterNot(predicate: (T)->Boolean) : List<T> {
+public inline fun <T> Iterable<T>.filterNot(predicate: (T) -> Boolean): List<T> {
     return filterNotTo(ArrayList<T>(), predicate)
-    
 }
 
 /**
  * Returns a list containing all elements not matching the given *predicate*
  */
-public inline fun <K, V> Map<K,V>.filterNot(predicate: (Map.Entry<K,V>)->Boolean) : List<Map.Entry<K,V>> {
-    return filterNotTo(ArrayList<Map.Entry<K,V>>(), predicate)
-    
+public inline fun <K, V> Map<K, V>.filterNot(predicate: (Map.Entry<K, V>) -> Boolean): List<Map.Entry<K, V>> {
+    return filterNotTo(ArrayList<Map.Entry<K, V>>(), predicate)
 }
 
 /**
  * Returns a stream containing all elements not matching the given *predicate*
  */
-public fun <T> Stream<T>.filterNot(predicate: (T)->Boolean) : Stream<T> {
+public fun <T> Stream<T>.filterNot(predicate: (T) -> Boolean): Stream<T> {
     return FilteringStream(this, false, predicate)
-    
 }
 
 /**
  * Returns a list containing all elements not matching the given *predicate*
  */
-public inline fun String.filterNot(predicate: (Char)->Boolean) : String {
+public inline fun String.filterNot(predicate: (Char) -> Boolean): String {
     return filterNotTo(StringBuilder(), predicate).toString()
-    
 }
 
 /**
  * Returns a list containing all elements that are not null
  */
-public fun <T: Any> Array<T?>.filterNotNull() : List<T> {
+public fun <T : Any> Array<T?>.filterNotNull(): List<T> {
     return filterNotNullTo(ArrayList<T>())
-    
 }
 
 /**
  * Returns a list containing all elements that are not null
  */
-public fun <T: Any> Iterable<T?>.filterNotNull() : List<T> {
+public fun <T : Any> Iterable<T?>.filterNotNull(): List<T> {
     return filterNotNullTo(ArrayList<T>())
-    
 }
 
 /**
  * Returns a stream containing all elements that are not null
  */
-public fun <T: Any> Stream<T?>.filterNotNull() : Stream<T> {
+public fun <T : Any> Stream<T?>.filterNotNull(): Stream<T> {
     return FilteringStream(this, false, { it != null }) as Stream<T>
-    
 }
 
 /**
  * Appends all elements that are not null to the given *collection*
  */
-public fun <C: MutableCollection<in T>, T: Any> Array<T?>.filterNotNullTo(collection: C) : C {
+public fun <C : MutableCollection<in T>, T : Any> Array<T?>.filterNotNullTo(collection: C): C {
     for (element in this) if (element != null) collection.add(element)
     return collection
-    
 }
 
 /**
  * Appends all elements that are not null to the given *collection*
  */
-public fun <C: MutableCollection<in T>, T: Any> Iterable<T?>.filterNotNullTo(collection: C) : C {
+public fun <C : MutableCollection<in T>, T : Any> Iterable<T?>.filterNotNullTo(collection: C): C {
     for (element in this) if (element != null) collection.add(element)
     return collection
-    
 }
 
 /**
  * Appends all elements that are not null to the given *collection*
  */
-public fun <C: MutableCollection<in T>, T: Any> Stream<T?>.filterNotNullTo(collection: C) : C {
+public fun <C : MutableCollection<in T>, T : Any> Stream<T?>.filterNotNullTo(collection: C): C {
     for (element in this) if (element != null) collection.add(element)
     return collection
-    
 }
 
 /**
  * Appends all elements not matching the given *predicate* to the given *collection*
  */
-public inline fun <T, C: MutableCollection<in T>> Array<out T>.filterNotTo(collection: C, predicate: (T) -> Boolean) : C {
+public inline fun <T, C : MutableCollection<in T>> Array<out T>.filterNotTo(collection: C, predicate: (T) -> Boolean): C {
     for (element in this) if (!predicate(element)) collection.add(element)
     return collection
-    
 }
 
 /**
  * Appends all elements not matching the given *predicate* to the given *collection*
  */
-public inline fun <C: MutableCollection<in Boolean>> BooleanArray.filterNotTo(collection: C, predicate: (Boolean) -> Boolean) : C {
+public inline fun <C : MutableCollection<in Boolean>> BooleanArray.filterNotTo(collection: C, predicate: (Boolean) -> Boolean): C {
     for (element in this) if (!predicate(element)) collection.add(element)
     return collection
-    
 }
 
 /**
  * Appends all elements not matching the given *predicate* to the given *collection*
  */
-public inline fun <C: MutableCollection<in Byte>> ByteArray.filterNotTo(collection: C, predicate: (Byte) -> Boolean) : C {
+public inline fun <C : MutableCollection<in Byte>> ByteArray.filterNotTo(collection: C, predicate: (Byte) -> Boolean): C {
     for (element in this) if (!predicate(element)) collection.add(element)
     return collection
-    
 }
 
 /**
  * Appends all elements not matching the given *predicate* to the given *collection*
  */
-public inline fun <C: MutableCollection<in Char>> CharArray.filterNotTo(collection: C, predicate: (Char) -> Boolean) : C {
+public inline fun <C : MutableCollection<in Char>> CharArray.filterNotTo(collection: C, predicate: (Char) -> Boolean): C {
     for (element in this) if (!predicate(element)) collection.add(element)
     return collection
-    
 }
 
 /**
  * Appends all elements not matching the given *predicate* to the given *collection*
  */
-public inline fun <C: MutableCollection<in Double>> DoubleArray.filterNotTo(collection: C, predicate: (Double) -> Boolean) : C {
+public inline fun <C : MutableCollection<in Double>> DoubleArray.filterNotTo(collection: C, predicate: (Double) -> Boolean): C {
     for (element in this) if (!predicate(element)) collection.add(element)
     return collection
-    
 }
 
 /**
  * Appends all elements not matching the given *predicate* to the given *collection*
  */
-public inline fun <C: MutableCollection<in Float>> FloatArray.filterNotTo(collection: C, predicate: (Float) -> Boolean) : C {
+public inline fun <C : MutableCollection<in Float>> FloatArray.filterNotTo(collection: C, predicate: (Float) -> Boolean): C {
     for (element in this) if (!predicate(element)) collection.add(element)
     return collection
-    
 }
 
 /**
  * Appends all elements not matching the given *predicate* to the given *collection*
  */
-public inline fun <C: MutableCollection<in Int>> IntArray.filterNotTo(collection: C, predicate: (Int) -> Boolean) : C {
+public inline fun <C : MutableCollection<in Int>> IntArray.filterNotTo(collection: C, predicate: (Int) -> Boolean): C {
     for (element in this) if (!predicate(element)) collection.add(element)
     return collection
-    
 }
 
 /**
  * Appends all elements not matching the given *predicate* to the given *collection*
  */
-public inline fun <C: MutableCollection<in Long>> LongArray.filterNotTo(collection: C, predicate: (Long) -> Boolean) : C {
+public inline fun <C : MutableCollection<in Long>> LongArray.filterNotTo(collection: C, predicate: (Long) -> Boolean): C {
     for (element in this) if (!predicate(element)) collection.add(element)
     return collection
-    
 }
 
 /**
  * Appends all elements not matching the given *predicate* to the given *collection*
  */
-public inline fun <C: MutableCollection<in Short>> ShortArray.filterNotTo(collection: C, predicate: (Short) -> Boolean) : C {
+public inline fun <C : MutableCollection<in Short>> ShortArray.filterNotTo(collection: C, predicate: (Short) -> Boolean): C {
     for (element in this) if (!predicate(element)) collection.add(element)
     return collection
-    
 }
 
 /**
  * Appends all elements not matching the given *predicate* to the given *collection*
  */
-public inline fun <T, C: MutableCollection<in T>> Iterable<T>.filterNotTo(collection: C, predicate: (T) -> Boolean) : C {
+public inline fun <T, C : MutableCollection<in T>> Iterable<T>.filterNotTo(collection: C, predicate: (T) -> Boolean): C {
     for (element in this) if (!predicate(element)) collection.add(element)
     return collection
-    
 }
 
 /**
  * Appends all elements not matching the given *predicate* to the given *collection*
  */
-public inline fun <K, V, C: MutableCollection<in Map.Entry<K,V>>> Map<K,V>.filterNotTo(collection: C, predicate: (Map.Entry<K,V>) -> Boolean) : C {
+public inline fun <K, V, C : MutableCollection<in Map.Entry<K, V>>> Map<K, V>.filterNotTo(collection: C, predicate: (Map.Entry<K, V>) -> Boolean): C {
     for (element in this) if (!predicate(element)) collection.add(element)
     return collection
-    
 }
 
 /**
  * Appends all elements not matching the given *predicate* to the given *collection*
  */
-public inline fun <T, C: MutableCollection<in T>> Stream<T>.filterNotTo(collection: C, predicate: (T) -> Boolean) : C {
+public inline fun <T, C : MutableCollection<in T>> Stream<T>.filterNotTo(collection: C, predicate: (T) -> Boolean): C {
     for (element in this) if (!predicate(element)) collection.add(element)
     return collection
-    
 }
 
 /**
  * Appends all characters not matching the given *predicate* to the given *collection*
  */
-public inline fun <C: Appendable> String.filterNotTo(collection: C, predicate: (Char) -> Boolean) : C {
+public inline fun <C : Appendable> String.filterNotTo(collection: C, predicate: (Char) -> Boolean): C {
     for (element in this) if (!predicate(element)) collection.append(element)
     return collection
-    
 }
 
 /**
  * Appends all elements matching the given *predicate* into the given *collection*
  */
-public inline fun <T, C: MutableCollection<in T>> Array<out T>.filterTo(collection: C, predicate: (T) -> Boolean) : C {
+public inline fun <T, C : MutableCollection<in T>> Array<out T>.filterTo(collection: C, predicate: (T) -> Boolean): C {
     for (element in this) if (predicate(element)) collection.add(element)
     return collection
-    
 }
 
 /**
  * Appends all elements matching the given *predicate* into the given *collection*
  */
-public inline fun <C: MutableCollection<in Boolean>> BooleanArray.filterTo(collection: C, predicate: (Boolean) -> Boolean) : C {
+public inline fun <C : MutableCollection<in Boolean>> BooleanArray.filterTo(collection: C, predicate: (Boolean) -> Boolean): C {
     for (element in this) if (predicate(element)) collection.add(element)
     return collection
-    
 }
 
 /**
  * Appends all elements matching the given *predicate* into the given *collection*
  */
-public inline fun <C: MutableCollection<in Byte>> ByteArray.filterTo(collection: C, predicate: (Byte) -> Boolean) : C {
+public inline fun <C : MutableCollection<in Byte>> ByteArray.filterTo(collection: C, predicate: (Byte) -> Boolean): C {
     for (element in this) if (predicate(element)) collection.add(element)
     return collection
-    
 }
 
 /**
  * Appends all elements matching the given *predicate* into the given *collection*
  */
-public inline fun <C: MutableCollection<in Char>> CharArray.filterTo(collection: C, predicate: (Char) -> Boolean) : C {
+public inline fun <C : MutableCollection<in Char>> CharArray.filterTo(collection: C, predicate: (Char) -> Boolean): C {
     for (element in this) if (predicate(element)) collection.add(element)
     return collection
-    
 }
 
 /**
  * Appends all elements matching the given *predicate* into the given *collection*
  */
-public inline fun <C: MutableCollection<in Double>> DoubleArray.filterTo(collection: C, predicate: (Double) -> Boolean) : C {
+public inline fun <C : MutableCollection<in Double>> DoubleArray.filterTo(collection: C, predicate: (Double) -> Boolean): C {
     for (element in this) if (predicate(element)) collection.add(element)
     return collection
-    
 }
 
 /**
  * Appends all elements matching the given *predicate* into the given *collection*
  */
-public inline fun <C: MutableCollection<in Float>> FloatArray.filterTo(collection: C, predicate: (Float) -> Boolean) : C {
+public inline fun <C : MutableCollection<in Float>> FloatArray.filterTo(collection: C, predicate: (Float) -> Boolean): C {
     for (element in this) if (predicate(element)) collection.add(element)
     return collection
-    
 }
 
 /**
  * Appends all elements matching the given *predicate* into the given *collection*
  */
-public inline fun <C: MutableCollection<in Int>> IntArray.filterTo(collection: C, predicate: (Int) -> Boolean) : C {
+public inline fun <C : MutableCollection<in Int>> IntArray.filterTo(collection: C, predicate: (Int) -> Boolean): C {
     for (element in this) if (predicate(element)) collection.add(element)
     return collection
-    
 }
 
 /**
  * Appends all elements matching the given *predicate* into the given *collection*
  */
-public inline fun <C: MutableCollection<in Long>> LongArray.filterTo(collection: C, predicate: (Long) -> Boolean) : C {
+public inline fun <C : MutableCollection<in Long>> LongArray.filterTo(collection: C, predicate: (Long) -> Boolean): C {
     for (element in this) if (predicate(element)) collection.add(element)
     return collection
-    
 }
 
 /**
  * Appends all elements matching the given *predicate* into the given *collection*
  */
-public inline fun <C: MutableCollection<in Short>> ShortArray.filterTo(collection: C, predicate: (Short) -> Boolean) : C {
+public inline fun <C : MutableCollection<in Short>> ShortArray.filterTo(collection: C, predicate: (Short) -> Boolean): C {
     for (element in this) if (predicate(element)) collection.add(element)
     return collection
-    
 }
 
 /**
  * Appends all elements matching the given *predicate* into the given *collection*
  */
-public inline fun <T, C: MutableCollection<in T>> Iterable<T>.filterTo(collection: C, predicate: (T) -> Boolean) : C {
+public inline fun <T, C : MutableCollection<in T>> Iterable<T>.filterTo(collection: C, predicate: (T) -> Boolean): C {
     for (element in this) if (predicate(element)) collection.add(element)
     return collection
-    
 }
 
 /**
  * Appends all elements matching the given *predicate* into the given *collection*
  */
-public inline fun <K, V, C: MutableCollection<in Map.Entry<K,V>>> Map<K,V>.filterTo(collection: C, predicate: (Map.Entry<K,V>) -> Boolean) : C {
+public inline fun <K, V, C : MutableCollection<in Map.Entry<K, V>>> Map<K, V>.filterTo(collection: C, predicate: (Map.Entry<K, V>) -> Boolean): C {
     for (element in this) if (predicate(element)) collection.add(element)
     return collection
-    
 }
 
 /**
  * Appends all elements matching the given *predicate* into the given *collection*
  */
-public inline fun <T, C: MutableCollection<in T>> Stream<T>.filterTo(collection: C, predicate: (T) -> Boolean) : C {
+public inline fun <T, C : MutableCollection<in T>> Stream<T>.filterTo(collection: C, predicate: (T) -> Boolean): C {
     for (element in this) if (predicate(element)) collection.add(element)
     return collection
-    
 }
 
 /**
@@ -893,139 +802,128 @@ public inline fun <C : Appendable> String.filterTo(destination: C, predicate: (C
 /**
  * Returns a list containing elements at specified positions
  */
-public fun <T> Array<out T>.slice(indices: Iterable<Int>) : List<T> {
+public fun <T> Array<out T>.slice(indices: Iterable<Int>): List<T> {
     val list = ArrayList<T>()
     for (index in indices) {
         list.add(get(index))
     }
     return list
-    
 }
 
 /**
  * Returns a list containing elements at specified positions
  */
-public fun BooleanArray.slice(indices: Iterable<Int>) : List<Boolean> {
+public fun BooleanArray.slice(indices: Iterable<Int>): List<Boolean> {
     val list = ArrayList<Boolean>()
     for (index in indices) {
         list.add(get(index))
     }
     return list
-    
 }
 
 /**
  * Returns a list containing elements at specified positions
  */
-public fun ByteArray.slice(indices: Iterable<Int>) : List<Byte> {
+public fun ByteArray.slice(indices: Iterable<Int>): List<Byte> {
     val list = ArrayList<Byte>()
     for (index in indices) {
         list.add(get(index))
     }
     return list
-    
 }
 
 /**
  * Returns a list containing elements at specified positions
  */
-public fun CharArray.slice(indices: Iterable<Int>) : List<Char> {
+public fun CharArray.slice(indices: Iterable<Int>): List<Char> {
     val list = ArrayList<Char>()
     for (index in indices) {
         list.add(get(index))
     }
     return list
-    
 }
 
 /**
  * Returns a list containing elements at specified positions
  */
-public fun DoubleArray.slice(indices: Iterable<Int>) : List<Double> {
+public fun DoubleArray.slice(indices: Iterable<Int>): List<Double> {
     val list = ArrayList<Double>()
     for (index in indices) {
         list.add(get(index))
     }
     return list
-    
 }
 
 /**
  * Returns a list containing elements at specified positions
  */
-public fun FloatArray.slice(indices: Iterable<Int>) : List<Float> {
+public fun FloatArray.slice(indices: Iterable<Int>): List<Float> {
     val list = ArrayList<Float>()
     for (index in indices) {
         list.add(get(index))
     }
     return list
-    
 }
 
 /**
  * Returns a list containing elements at specified positions
  */
-public fun IntArray.slice(indices: Iterable<Int>) : List<Int> {
+public fun IntArray.slice(indices: Iterable<Int>): List<Int> {
     val list = ArrayList<Int>()
     for (index in indices) {
         list.add(get(index))
     }
     return list
-    
 }
 
 /**
  * Returns a list containing elements at specified positions
  */
-public fun LongArray.slice(indices: Iterable<Int>) : List<Long> {
+public fun LongArray.slice(indices: Iterable<Int>): List<Long> {
     val list = ArrayList<Long>()
     for (index in indices) {
         list.add(get(index))
     }
     return list
-    
 }
 
 /**
  * Returns a list containing elements at specified positions
  */
-public fun ShortArray.slice(indices: Iterable<Int>) : List<Short> {
+public fun ShortArray.slice(indices: Iterable<Int>): List<Short> {
     val list = ArrayList<Short>()
     for (index in indices) {
         list.add(get(index))
     }
     return list
-    
 }
 
 /**
  * Returns a list containing elements at specified positions
  */
-public fun <T> List<T>.slice(indices: Iterable<Int>) : List<T> {
+public fun <T> List<T>.slice(indices: Iterable<Int>): List<T> {
     val list = ArrayList<T>()
     for (index in indices) {
         list.add(get(index))
     }
     return list
-    
 }
 
 /**
  * Returns a list containing elements at specified positions
  */
-public fun String.slice(indices: Iterable<Int>) : String {
+public fun String.slice(indices: Iterable<Int>): String {
     val result = StringBuilder()
     for (i in indices) {
         result.append(get(i))
     }
     return result.toString()
-    
 }
 
 /**
  * Returns a list containing first *n* elements
  */
-public fun <T> Array<out T>.take(n: Int) : List<T> {
+public fun <T> Array<out T>.take(n: Int): List<T> {
     var count = 0
     val realN = if (n > size) size else n
     val list = ArrayList<T>(realN)
@@ -1035,13 +933,12 @@ public fun <T> Array<out T>.take(n: Int) : List<T> {
         list.add(item)
     }
     return list
-    
 }
 
 /**
  * Returns a list containing first *n* elements
  */
-public fun BooleanArray.take(n: Int) : List<Boolean> {
+public fun BooleanArray.take(n: Int): List<Boolean> {
     var count = 0
     val realN = if (n > size) size else n
     val list = ArrayList<Boolean>(realN)
@@ -1051,13 +948,12 @@ public fun BooleanArray.take(n: Int) : List<Boolean> {
         list.add(item)
     }
     return list
-    
 }
 
 /**
  * Returns a list containing first *n* elements
  */
-public fun ByteArray.take(n: Int) : List<Byte> {
+public fun ByteArray.take(n: Int): List<Byte> {
     var count = 0
     val realN = if (n > size) size else n
     val list = ArrayList<Byte>(realN)
@@ -1067,13 +963,12 @@ public fun ByteArray.take(n: Int) : List<Byte> {
         list.add(item)
     }
     return list
-    
 }
 
 /**
  * Returns a list containing first *n* elements
  */
-public fun CharArray.take(n: Int) : List<Char> {
+public fun CharArray.take(n: Int): List<Char> {
     var count = 0
     val realN = if (n > size) size else n
     val list = ArrayList<Char>(realN)
@@ -1083,13 +978,12 @@ public fun CharArray.take(n: Int) : List<Char> {
         list.add(item)
     }
     return list
-    
 }
 
 /**
  * Returns a list containing first *n* elements
  */
-public fun DoubleArray.take(n: Int) : List<Double> {
+public fun DoubleArray.take(n: Int): List<Double> {
     var count = 0
     val realN = if (n > size) size else n
     val list = ArrayList<Double>(realN)
@@ -1099,13 +993,12 @@ public fun DoubleArray.take(n: Int) : List<Double> {
         list.add(item)
     }
     return list
-    
 }
 
 /**
  * Returns a list containing first *n* elements
  */
-public fun FloatArray.take(n: Int) : List<Float> {
+public fun FloatArray.take(n: Int): List<Float> {
     var count = 0
     val realN = if (n > size) size else n
     val list = ArrayList<Float>(realN)
@@ -1115,13 +1008,12 @@ public fun FloatArray.take(n: Int) : List<Float> {
         list.add(item)
     }
     return list
-    
 }
 
 /**
  * Returns a list containing first *n* elements
  */
-public fun IntArray.take(n: Int) : List<Int> {
+public fun IntArray.take(n: Int): List<Int> {
     var count = 0
     val realN = if (n > size) size else n
     val list = ArrayList<Int>(realN)
@@ -1131,13 +1023,12 @@ public fun IntArray.take(n: Int) : List<Int> {
         list.add(item)
     }
     return list
-    
 }
 
 /**
  * Returns a list containing first *n* elements
  */
-public fun LongArray.take(n: Int) : List<Long> {
+public fun LongArray.take(n: Int): List<Long> {
     var count = 0
     val realN = if (n > size) size else n
     val list = ArrayList<Long>(realN)
@@ -1147,13 +1038,12 @@ public fun LongArray.take(n: Int) : List<Long> {
         list.add(item)
     }
     return list
-    
 }
 
 /**
  * Returns a list containing first *n* elements
  */
-public fun ShortArray.take(n: Int) : List<Short> {
+public fun ShortArray.take(n: Int): List<Short> {
     var count = 0
     val realN = if (n > size) size else n
     val list = ArrayList<Short>(realN)
@@ -1163,13 +1053,12 @@ public fun ShortArray.take(n: Int) : List<Short> {
         list.add(item)
     }
     return list
-    
 }
 
 /**
  * Returns a list containing first *n* elements
  */
-public fun <T> Collection<T>.take(n: Int) : List<T> {
+public fun <T> Collection<T>.take(n: Int): List<T> {
     var count = 0
     val realN = if (n > size) size else n
     val list = ArrayList<T>(realN)
@@ -1179,13 +1068,12 @@ public fun <T> Collection<T>.take(n: Int) : List<T> {
         list.add(item)
     }
     return list
-    
 }
 
 /**
  * Returns a list containing first *n* elements
  */
-public fun <T> Iterable<T>.take(n: Int) : List<T> {
+public fun <T> Iterable<T>.take(n: Int): List<T> {
     var count = 0
     val list = ArrayList<T>(n)
     for (item in this) {
@@ -1194,171 +1082,158 @@ public fun <T> Iterable<T>.take(n: Int) : List<T> {
         list.add(item)
     }
     return list
-    
 }
 
 /**
  * Returns a stream containing first *n* elements
  */
-public fun <T> Stream<T>.take(n: Int) : Stream<T> {
+public fun <T> Stream<T>.take(n: Int): Stream<T> {
     var count = 0
     return LimitedStream(this) { count++ == n }
-    
 }
 
 /**
  * Returns a list containing first *n* elements
  */
-public fun String.take(n: Int) : String {
+public fun String.take(n: Int): String {
     return substring(0, Math.min(n, size))
 }
 
 /**
  * Returns a list containing first elements satisfying the given *predicate*
  */
-public inline fun <T> Array<out T>.takeWhile(predicate: (T)->Boolean) : List<T> {
+public inline fun <T> Array<out T>.takeWhile(predicate: (T) -> Boolean): List<T> {
     val list = ArrayList<T>()
     for (item in this) {
-         if(!predicate(item))
+        if (!predicate(item))
             break;
-         list.add(item)
+        list.add(item)
     }
     return list
-    
 }
 
 /**
  * Returns a list containing first elements satisfying the given *predicate*
  */
-public inline fun BooleanArray.takeWhile(predicate: (Boolean)->Boolean) : List<Boolean> {
+public inline fun BooleanArray.takeWhile(predicate: (Boolean) -> Boolean): List<Boolean> {
     val list = ArrayList<Boolean>()
     for (item in this) {
-         if(!predicate(item))
+        if (!predicate(item))
             break;
-         list.add(item)
+        list.add(item)
     }
     return list
-    
 }
 
 /**
  * Returns a list containing first elements satisfying the given *predicate*
  */
-public inline fun ByteArray.takeWhile(predicate: (Byte)->Boolean) : List<Byte> {
+public inline fun ByteArray.takeWhile(predicate: (Byte) -> Boolean): List<Byte> {
     val list = ArrayList<Byte>()
     for (item in this) {
-         if(!predicate(item))
+        if (!predicate(item))
             break;
-         list.add(item)
+        list.add(item)
     }
     return list
-    
 }
 
 /**
  * Returns a list containing first elements satisfying the given *predicate*
  */
-public inline fun CharArray.takeWhile(predicate: (Char)->Boolean) : List<Char> {
+public inline fun CharArray.takeWhile(predicate: (Char) -> Boolean): List<Char> {
     val list = ArrayList<Char>()
     for (item in this) {
-         if(!predicate(item))
+        if (!predicate(item))
             break;
-         list.add(item)
+        list.add(item)
     }
     return list
-    
 }
 
 /**
  * Returns a list containing first elements satisfying the given *predicate*
  */
-public inline fun DoubleArray.takeWhile(predicate: (Double)->Boolean) : List<Double> {
+public inline fun DoubleArray.takeWhile(predicate: (Double) -> Boolean): List<Double> {
     val list = ArrayList<Double>()
     for (item in this) {
-         if(!predicate(item))
+        if (!predicate(item))
             break;
-         list.add(item)
+        list.add(item)
     }
     return list
-    
 }
 
 /**
  * Returns a list containing first elements satisfying the given *predicate*
  */
-public inline fun FloatArray.takeWhile(predicate: (Float)->Boolean) : List<Float> {
+public inline fun FloatArray.takeWhile(predicate: (Float) -> Boolean): List<Float> {
     val list = ArrayList<Float>()
     for (item in this) {
-         if(!predicate(item))
+        if (!predicate(item))
             break;
-         list.add(item)
+        list.add(item)
     }
     return list
-    
 }
 
 /**
  * Returns a list containing first elements satisfying the given *predicate*
  */
-public inline fun IntArray.takeWhile(predicate: (Int)->Boolean) : List<Int> {
+public inline fun IntArray.takeWhile(predicate: (Int) -> Boolean): List<Int> {
     val list = ArrayList<Int>()
     for (item in this) {
-         if(!predicate(item))
+        if (!predicate(item))
             break;
-         list.add(item)
+        list.add(item)
     }
     return list
-    
 }
 
 /**
  * Returns a list containing first elements satisfying the given *predicate*
  */
-public inline fun LongArray.takeWhile(predicate: (Long)->Boolean) : List<Long> {
+public inline fun LongArray.takeWhile(predicate: (Long) -> Boolean): List<Long> {
     val list = ArrayList<Long>()
     for (item in this) {
-         if(!predicate(item))
+        if (!predicate(item))
             break;
-         list.add(item)
+        list.add(item)
     }
     return list
-    
 }
 
 /**
  * Returns a list containing first elements satisfying the given *predicate*
  */
-public inline fun ShortArray.takeWhile(predicate: (Short)->Boolean) : List<Short> {
+public inline fun ShortArray.takeWhile(predicate: (Short) -> Boolean): List<Short> {
     val list = ArrayList<Short>()
     for (item in this) {
-         if(!predicate(item))
+        if (!predicate(item))
             break;
-         list.add(item)
+        list.add(item)
     }
     return list
-    
 }
 
 /**
  * Returns a list containing first elements satisfying the given *predicate*
  */
-public inline fun <T> Iterable<T>.takeWhile(predicate: (T)->Boolean) : List<T> {
+public inline fun <T> Iterable<T>.takeWhile(predicate: (T) -> Boolean): List<T> {
     val list = ArrayList<T>()
     for (item in this) {
-         if(!predicate(item))
+        if (!predicate(item))
             break;
-         list.add(item)
+        list.add(item)
     }
     return list
-    
 }
 
 /**
  * Returns a stream containing first elements satisfying the given *predicate*
  */
-public fun <T> Stream<T>.takeWhile(predicate: (T)->Boolean) : Stream<T> {
+public fun <T> Stream<T>.takeWhile(predicate: (T) -> Boolean): Stream<T> {
     return LimitedStream(this, false, predicate)
-    
 }
 
 /**
@@ -1370,6 +1245,5 @@ public inline fun String.takeWhile(predicate: (Char) -> Boolean): String {
             return substring(0, index)
         }
     return ""
-    
 }
 
diff --git a/libraries/stdlib/src/generated/_Generators.kt b/libraries/stdlib/src/generated/_Generators.kt
index 4d63d414119..5bdebb21b70 100644
--- a/libraries/stdlib/src/generated/_Generators.kt
+++ b/libraries/stdlib/src/generated/_Generators.kt
@@ -12,7 +12,7 @@ import java.util.*
  * where *first* collection contains elements for which predicate yielded *true*,
  * while *second* collection contains elements for which predicate yielded *false*
  */
-public inline fun <T> Array<out T>.partition(predicate: (T) -> Boolean) : Pair<List<T>, List<T>> {
+public inline fun <T> Array<out T>.partition(predicate: (T) -> Boolean): Pair<List<T>, List<T>> {
     val first = ArrayList<T>()
     val second = ArrayList<T>()
     for (element in this) {
@@ -23,7 +23,6 @@ public inline fun <T> Array<out T>.partition(predicate: (T) -> Boolean) : Pair<L
         }
     }
     return Pair(first, second)
-    
 }
 
 /**
@@ -31,7 +30,7 @@ public inline fun <T> Array<out T>.partition(predicate: (T) -> Boolean) : Pair<L
  * where *first* collection contains elements for which predicate yielded *true*,
  * while *second* collection contains elements for which predicate yielded *false*
  */
-public inline fun BooleanArray.partition(predicate: (Boolean) -> Boolean) : Pair<List<Boolean>, List<Boolean>> {
+public inline fun BooleanArray.partition(predicate: (Boolean) -> Boolean): Pair<List<Boolean>, List<Boolean>> {
     val first = ArrayList<Boolean>()
     val second = ArrayList<Boolean>()
     for (element in this) {
@@ -42,7 +41,6 @@ public inline fun BooleanArray.partition(predicate: (Boolean) -> Boolean) : Pair
         }
     }
     return Pair(first, second)
-    
 }
 
 /**
@@ -50,7 +48,7 @@ public inline fun BooleanArray.partition(predicate: (Boolean) -> Boolean) : Pair
  * where *first* collection contains elements for which predicate yielded *true*,
  * while *second* collection contains elements for which predicate yielded *false*
  */
-public inline fun ByteArray.partition(predicate: (Byte) -> Boolean) : Pair<List<Byte>, List<Byte>> {
+public inline fun ByteArray.partition(predicate: (Byte) -> Boolean): Pair<List<Byte>, List<Byte>> {
     val first = ArrayList<Byte>()
     val second = ArrayList<Byte>()
     for (element in this) {
@@ -61,7 +59,6 @@ public inline fun ByteArray.partition(predicate: (Byte) -> Boolean) : Pair<List<
         }
     }
     return Pair(first, second)
-    
 }
 
 /**
@@ -69,7 +66,7 @@ public inline fun ByteArray.partition(predicate: (Byte) -> Boolean) : Pair<List<
  * where *first* collection contains elements for which predicate yielded *true*,
  * while *second* collection contains elements for which predicate yielded *false*
  */
-public inline fun CharArray.partition(predicate: (Char) -> Boolean) : Pair<List<Char>, List<Char>> {
+public inline fun CharArray.partition(predicate: (Char) -> Boolean): Pair<List<Char>, List<Char>> {
     val first = ArrayList<Char>()
     val second = ArrayList<Char>()
     for (element in this) {
@@ -80,7 +77,6 @@ public inline fun CharArray.partition(predicate: (Char) -> Boolean) : Pair<List<
         }
     }
     return Pair(first, second)
-    
 }
 
 /**
@@ -88,7 +84,7 @@ public inline fun CharArray.partition(predicate: (Char) -> Boolean) : Pair<List<
  * where *first* collection contains elements for which predicate yielded *true*,
  * while *second* collection contains elements for which predicate yielded *false*
  */
-public inline fun DoubleArray.partition(predicate: (Double) -> Boolean) : Pair<List<Double>, List<Double>> {
+public inline fun DoubleArray.partition(predicate: (Double) -> Boolean): Pair<List<Double>, List<Double>> {
     val first = ArrayList<Double>()
     val second = ArrayList<Double>()
     for (element in this) {
@@ -99,7 +95,6 @@ public inline fun DoubleArray.partition(predicate: (Double) -> Boolean) : Pair<L
         }
     }
     return Pair(first, second)
-    
 }
 
 /**
@@ -107,7 +102,7 @@ public inline fun DoubleArray.partition(predicate: (Double) -> Boolean) : Pair<L
  * where *first* collection contains elements for which predicate yielded *true*,
  * while *second* collection contains elements for which predicate yielded *false*
  */
-public inline fun FloatArray.partition(predicate: (Float) -> Boolean) : Pair<List<Float>, List<Float>> {
+public inline fun FloatArray.partition(predicate: (Float) -> Boolean): Pair<List<Float>, List<Float>> {
     val first = ArrayList<Float>()
     val second = ArrayList<Float>()
     for (element in this) {
@@ -118,7 +113,6 @@ public inline fun FloatArray.partition(predicate: (Float) -> Boolean) : Pair<Lis
         }
     }
     return Pair(first, second)
-    
 }
 
 /**
@@ -126,7 +120,7 @@ public inline fun FloatArray.partition(predicate: (Float) -> Boolean) : Pair<Lis
  * where *first* collection contains elements for which predicate yielded *true*,
  * while *second* collection contains elements for which predicate yielded *false*
  */
-public inline fun IntArray.partition(predicate: (Int) -> Boolean) : Pair<List<Int>, List<Int>> {
+public inline fun IntArray.partition(predicate: (Int) -> Boolean): Pair<List<Int>, List<Int>> {
     val first = ArrayList<Int>()
     val second = ArrayList<Int>()
     for (element in this) {
@@ -137,7 +131,6 @@ public inline fun IntArray.partition(predicate: (Int) -> Boolean) : Pair<List<In
         }
     }
     return Pair(first, second)
-    
 }
 
 /**
@@ -145,7 +138,7 @@ public inline fun IntArray.partition(predicate: (Int) -> Boolean) : Pair<List<In
  * where *first* collection contains elements for which predicate yielded *true*,
  * while *second* collection contains elements for which predicate yielded *false*
  */
-public inline fun LongArray.partition(predicate: (Long) -> Boolean) : Pair<List<Long>, List<Long>> {
+public inline fun LongArray.partition(predicate: (Long) -> Boolean): Pair<List<Long>, List<Long>> {
     val first = ArrayList<Long>()
     val second = ArrayList<Long>()
     for (element in this) {
@@ -156,7 +149,6 @@ public inline fun LongArray.partition(predicate: (Long) -> Boolean) : Pair<List<
         }
     }
     return Pair(first, second)
-    
 }
 
 /**
@@ -164,7 +156,7 @@ public inline fun LongArray.partition(predicate: (Long) -> Boolean) : Pair<List<
  * where *first* collection contains elements for which predicate yielded *true*,
  * while *second* collection contains elements for which predicate yielded *false*
  */
-public inline fun ShortArray.partition(predicate: (Short) -> Boolean) : Pair<List<Short>, List<Short>> {
+public inline fun ShortArray.partition(predicate: (Short) -> Boolean): Pair<List<Short>, List<Short>> {
     val first = ArrayList<Short>()
     val second = ArrayList<Short>()
     for (element in this) {
@@ -175,7 +167,6 @@ public inline fun ShortArray.partition(predicate: (Short) -> Boolean) : Pair<Lis
         }
     }
     return Pair(first, second)
-    
 }
 
 /**
@@ -183,7 +174,7 @@ public inline fun ShortArray.partition(predicate: (Short) -> Boolean) : Pair<Lis
  * where *first* collection contains elements for which predicate yielded *true*,
  * while *second* collection contains elements for which predicate yielded *false*
  */
-public inline fun <T> Iterable<T>.partition(predicate: (T) -> Boolean) : Pair<List<T>, List<T>> {
+public inline fun <T> Iterable<T>.partition(predicate: (T) -> Boolean): Pair<List<T>, List<T>> {
     val first = ArrayList<T>()
     val second = ArrayList<T>()
     for (element in this) {
@@ -194,7 +185,6 @@ public inline fun <T> Iterable<T>.partition(predicate: (T) -> Boolean) : Pair<Li
         }
     }
     return Pair(first, second)
-    
 }
 
 /**
@@ -202,7 +192,7 @@ public inline fun <T> Iterable<T>.partition(predicate: (T) -> Boolean) : Pair<Li
  * where *first* collection contains elements for which predicate yielded *true*,
  * while *second* collection contains elements for which predicate yielded *false*
  */
-public inline fun <T> Stream<T>.partition(predicate: (T) -> Boolean) : Pair<List<T>, List<T>> {
+public inline fun <T> Stream<T>.partition(predicate: (T) -> Boolean): Pair<List<T>, List<T>> {
     val first = ArrayList<T>()
     val second = ArrayList<T>()
     for (element in this) {
@@ -213,7 +203,6 @@ public inline fun <T> Stream<T>.partition(predicate: (T) -> Boolean) : Pair<List
         }
     }
     return Pair(first, second)
-    
 }
 
 /**
@@ -221,7 +210,7 @@ public inline fun <T> Stream<T>.partition(predicate: (T) -> Boolean) : Pair<List
  * where *first* collection contains elements for which predicate yielded *true*,
  * while *second* collection contains elements for which predicate yielded *false*
  */
-public inline fun String.partition(predicate: (Char) -> Boolean) : Pair<String, String> {
+public inline fun String.partition(predicate: (Char) -> Boolean): Pair<String, String> {
     val first = StringBuilder()
     val second = StringBuilder()
     for (element in this) {
@@ -232,660 +221,602 @@ public inline fun String.partition(predicate: (Char) -> Boolean) : Pair<String,
         }
     }
     return Pair(first.toString(), second.toString())
-    
 }
 
 /**
  * Returns a list containing all elements of original collection and then all elements of the given *collection*
  */
-public fun <T> Array<out T>.plus(array: Array<T>) : List<T> {
+public fun <T> Array<out T>.plus(array: Array<T>): List<T> {
     val answer = toArrayList()
     answer.addAll(array)
     return answer
-    
 }
 
 /**
  * Returns a list containing all elements of original collection and then all elements of the given *collection*
  */
-public fun BooleanArray.plus(array: Array<Boolean>) : List<Boolean> {
+public fun BooleanArray.plus(array: Array<Boolean>): List<Boolean> {
     val answer = toArrayList()
     answer.addAll(array)
     return answer
-    
 }
 
 /**
  * Returns a list containing all elements of original collection and then all elements of the given *collection*
  */
-public fun ByteArray.plus(array: Array<Byte>) : List<Byte> {
+public fun ByteArray.plus(array: Array<Byte>): List<Byte> {
     val answer = toArrayList()
     answer.addAll(array)
     return answer
-    
 }
 
 /**
  * Returns a list containing all elements of original collection and then all elements of the given *collection*
  */
-public fun CharArray.plus(array: Array<Char>) : List<Char> {
+public fun CharArray.plus(array: Array<Char>): List<Char> {
     val answer = toArrayList()
     answer.addAll(array)
     return answer
-    
 }
 
 /**
  * Returns a list containing all elements of original collection and then all elements of the given *collection*
  */
-public fun DoubleArray.plus(array: Array<Double>) : List<Double> {
+public fun DoubleArray.plus(array: Array<Double>): List<Double> {
     val answer = toArrayList()
     answer.addAll(array)
     return answer
-    
 }
 
 /**
  * Returns a list containing all elements of original collection and then all elements of the given *collection*
  */
-public fun FloatArray.plus(array: Array<Float>) : List<Float> {
+public fun FloatArray.plus(array: Array<Float>): List<Float> {
     val answer = toArrayList()
     answer.addAll(array)
     return answer
-    
 }
 
 /**
  * Returns a list containing all elements of original collection and then all elements of the given *collection*
  */
-public fun IntArray.plus(array: Array<Int>) : List<Int> {
+public fun IntArray.plus(array: Array<Int>): List<Int> {
     val answer = toArrayList()
     answer.addAll(array)
     return answer
-    
 }
 
 /**
  * Returns a list containing all elements of original collection and then all elements of the given *collection*
  */
-public fun LongArray.plus(array: Array<Long>) : List<Long> {
+public fun LongArray.plus(array: Array<Long>): List<Long> {
     val answer = toArrayList()
     answer.addAll(array)
     return answer
-    
 }
 
 /**
  * Returns a list containing all elements of original collection and then all elements of the given *collection*
  */
-public fun ShortArray.plus(array: Array<Short>) : List<Short> {
+public fun ShortArray.plus(array: Array<Short>): List<Short> {
     val answer = toArrayList()
     answer.addAll(array)
     return answer
-    
 }
 
 /**
  * Returns a list containing all elements of original collection and then all elements of the given *collection*
  */
-public fun <T> Iterable<T>.plus(array: Array<T>) : List<T> {
+public fun <T> Iterable<T>.plus(array: Array<T>): List<T> {
     val answer = toArrayList()
     answer.addAll(array)
     return answer
-    
 }
 
 /**
  * Returns a list containing all elements of original collection and then all elements of the given *collection*
  */
-public fun <T> Array<out T>.plus(collection: Iterable<T>) : List<T> {
+public fun <T> Array<out T>.plus(collection: Iterable<T>): List<T> {
     val answer = toArrayList()
     answer.addAll(collection)
     return answer
-    
 }
 
 /**
  * Returns a list containing all elements of original collection and then all elements of the given *collection*
  */
-public fun BooleanArray.plus(collection: Iterable<Boolean>) : List<Boolean> {
+public fun BooleanArray.plus(collection: Iterable<Boolean>): List<Boolean> {
     val answer = toArrayList()
     answer.addAll(collection)
     return answer
-    
 }
 
 /**
  * Returns a list containing all elements of original collection and then all elements of the given *collection*
  */
-public fun ByteArray.plus(collection: Iterable<Byte>) : List<Byte> {
+public fun ByteArray.plus(collection: Iterable<Byte>): List<Byte> {
     val answer = toArrayList()
     answer.addAll(collection)
     return answer
-    
 }
 
 /**
  * Returns a list containing all elements of original collection and then all elements of the given *collection*
  */
-public fun CharArray.plus(collection: Iterable<Char>) : List<Char> {
+public fun CharArray.plus(collection: Iterable<Char>): List<Char> {
     val answer = toArrayList()
     answer.addAll(collection)
     return answer
-    
 }
 
 /**
  * Returns a list containing all elements of original collection and then all elements of the given *collection*
  */
-public fun DoubleArray.plus(collection: Iterable<Double>) : List<Double> {
+public fun DoubleArray.plus(collection: Iterable<Double>): List<Double> {
     val answer = toArrayList()
     answer.addAll(collection)
     return answer
-    
 }
 
 /**
  * Returns a list containing all elements of original collection and then all elements of the given *collection*
  */
-public fun FloatArray.plus(collection: Iterable<Float>) : List<Float> {
+public fun FloatArray.plus(collection: Iterable<Float>): List<Float> {
     val answer = toArrayList()
     answer.addAll(collection)
     return answer
-    
 }
 
 /**
  * Returns a list containing all elements of original collection and then all elements of the given *collection*
  */
-public fun IntArray.plus(collection: Iterable<Int>) : List<Int> {
+public fun IntArray.plus(collection: Iterable<Int>): List<Int> {
     val answer = toArrayList()
     answer.addAll(collection)
     return answer
-    
 }
 
 /**
  * Returns a list containing all elements of original collection and then all elements of the given *collection*
  */
-public fun LongArray.plus(collection: Iterable<Long>) : List<Long> {
+public fun LongArray.plus(collection: Iterable<Long>): List<Long> {
     val answer = toArrayList()
     answer.addAll(collection)
     return answer
-    
 }
 
 /**
  * Returns a list containing all elements of original collection and then all elements of the given *collection*
  */
-public fun ShortArray.plus(collection: Iterable<Short>) : List<Short> {
+public fun ShortArray.plus(collection: Iterable<Short>): List<Short> {
     val answer = toArrayList()
     answer.addAll(collection)
     return answer
-    
 }
 
 /**
  * Returns a list containing all elements of original collection and then all elements of the given *collection*
  */
-public fun <T> Iterable<T>.plus(collection: Iterable<T>) : List<T> {
+public fun <T> Iterable<T>.plus(collection: Iterable<T>): List<T> {
     val answer = toArrayList()
     answer.addAll(collection)
     return answer
-    
 }
 
 /**
  * Returns a stream containing all elements of original stream and then all elements of the given *collection*
  */
-public fun <T> Stream<T>.plus(collection: Iterable<T>) : Stream<T> {
+public fun <T> Stream<T>.plus(collection: Iterable<T>): Stream<T> {
     return Multistream(streamOf(this, collection.stream()))
-    
 }
 
 /**
  * Returns a list containing all elements of original collection and then the given element
  */
-public fun <T> Array<out T>.plus(element: T) : List<T> {
+public fun <T> Array<out T>.plus(element: T): List<T> {
     val answer = toArrayList()
     answer.add(element)
     return answer
-    
 }
 
 /**
  * Returns a list containing all elements of original collection and then the given element
  */
-public fun BooleanArray.plus(element: Boolean) : List<Boolean> {
+public fun BooleanArray.plus(element: Boolean): List<Boolean> {
     val answer = toArrayList()
     answer.add(element)
     return answer
-    
 }
 
 /**
  * Returns a list containing all elements of original collection and then the given element
  */
-public fun ByteArray.plus(element: Byte) : List<Byte> {
+public fun ByteArray.plus(element: Byte): List<Byte> {
     val answer = toArrayList()
     answer.add(element)
     return answer
-    
 }
 
 /**
  * Returns a list containing all elements of original collection and then the given element
  */
-public fun CharArray.plus(element: Char) : List<Char> {
+public fun CharArray.plus(element: Char): List<Char> {
     val answer = toArrayList()
     answer.add(element)
     return answer
-    
 }
 
 /**
  * Returns a list containing all elements of original collection and then the given element
  */
-public fun DoubleArray.plus(element: Double) : List<Double> {
+public fun DoubleArray.plus(element: Double): List<Double> {
     val answer = toArrayList()
     answer.add(element)
     return answer
-    
 }
 
 /**
  * Returns a list containing all elements of original collection and then the given element
  */
-public fun FloatArray.plus(element: Float) : List<Float> {
+public fun FloatArray.plus(element: Float): List<Float> {
     val answer = toArrayList()
     answer.add(element)
     return answer
-    
 }
 
 /**
  * Returns a list containing all elements of original collection and then the given element
  */
-public fun IntArray.plus(element: Int) : List<Int> {
+public fun IntArray.plus(element: Int): List<Int> {
     val answer = toArrayList()
     answer.add(element)
     return answer
-    
 }
 
 /**
  * Returns a list containing all elements of original collection and then the given element
  */
-public fun LongArray.plus(element: Long) : List<Long> {
+public fun LongArray.plus(element: Long): List<Long> {
     val answer = toArrayList()
     answer.add(element)
     return answer
-    
 }
 
 /**
  * Returns a list containing all elements of original collection and then the given element
  */
-public fun ShortArray.plus(element: Short) : List<Short> {
+public fun ShortArray.plus(element: Short): List<Short> {
     val answer = toArrayList()
     answer.add(element)
     return answer
-    
 }
 
 /**
  * Returns a list containing all elements of original collection and then the given element
  */
-public fun <T> Iterable<T>.plus(element: T) : List<T> {
+public fun <T> Iterable<T>.plus(element: T): List<T> {
     val answer = toArrayList()
     answer.add(element)
     return answer
-    
 }
 
 /**
  * Returns a stream containing all elements of original stream and then the given element
  */
-public fun <T> Stream<T>.plus(element: T) : Stream<T> {
+public fun <T> Stream<T>.plus(element: T): Stream<T> {
     return Multistream(streamOf(this, streamOf(element)))
-    
 }
 
 /**
  * Returns a stream containing all elements of original stream and then all elements of the given *stream*
  */
-public fun <T> Stream<T>.plus(stream: Stream<T>) : Stream<T> {
+public fun <T> Stream<T>.plus(stream: Stream<T>): Stream<T> {
     return Multistream(streamOf(this, stream))
-    
 }
 
 /**
  * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
  */
-public fun <T, R> Array<out T>.zip(array: Array<R>) : List<Pair<T,R>> {
+public fun <T, R> Array<out T>.zip(array: Array<R>): List<Pair<T, R>> {
     val first = iterator()
     val second = array.iterator()
-    val list = ArrayList<Pair<T,R>>()
+    val list = ArrayList<Pair<T, R>>()
     while (first.hasNext() && second.hasNext()) {
         list.add(first.next() to second.next())
     }
     return list
-    
 }
 
 /**
  * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
  */
-public fun <R> BooleanArray.zip(array: Array<R>) : List<Pair<Boolean,R>> {
+public fun <R> BooleanArray.zip(array: Array<R>): List<Pair<Boolean, R>> {
     val first = iterator()
     val second = array.iterator()
-    val list = ArrayList<Pair<Boolean,R>>()
+    val list = ArrayList<Pair<Boolean, R>>()
     while (first.hasNext() && second.hasNext()) {
         list.add(first.next() to second.next())
     }
     return list
-    
 }
 
 /**
  * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
  */
-public fun <R> ByteArray.zip(array: Array<R>) : List<Pair<Byte,R>> {
+public fun <R> ByteArray.zip(array: Array<R>): List<Pair<Byte, R>> {
     val first = iterator()
     val second = array.iterator()
-    val list = ArrayList<Pair<Byte,R>>()
+    val list = ArrayList<Pair<Byte, R>>()
     while (first.hasNext() && second.hasNext()) {
         list.add(first.next() to second.next())
     }
     return list
-    
 }
 
 /**
  * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
  */
-public fun <R> CharArray.zip(array: Array<R>) : List<Pair<Char,R>> {
+public fun <R> CharArray.zip(array: Array<R>): List<Pair<Char, R>> {
     val first = iterator()
     val second = array.iterator()
-    val list = ArrayList<Pair<Char,R>>()
+    val list = ArrayList<Pair<Char, R>>()
     while (first.hasNext() && second.hasNext()) {
         list.add(first.next() to second.next())
     }
     return list
-    
 }
 
 /**
  * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
  */
-public fun <R> DoubleArray.zip(array: Array<R>) : List<Pair<Double,R>> {
+public fun <R> DoubleArray.zip(array: Array<R>): List<Pair<Double, R>> {
     val first = iterator()
     val second = array.iterator()
-    val list = ArrayList<Pair<Double,R>>()
+    val list = ArrayList<Pair<Double, R>>()
     while (first.hasNext() && second.hasNext()) {
         list.add(first.next() to second.next())
     }
     return list
-    
 }
 
 /**
  * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
  */
-public fun <R> FloatArray.zip(array: Array<R>) : List<Pair<Float,R>> {
+public fun <R> FloatArray.zip(array: Array<R>): List<Pair<Float, R>> {
     val first = iterator()
     val second = array.iterator()
-    val list = ArrayList<Pair<Float,R>>()
+    val list = ArrayList<Pair<Float, R>>()
     while (first.hasNext() && second.hasNext()) {
         list.add(first.next() to second.next())
     }
     return list
-    
 }
 
 /**
  * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
  */
-public fun <R> IntArray.zip(array: Array<R>) : List<Pair<Int,R>> {
+public fun <R> IntArray.zip(array: Array<R>): List<Pair<Int, R>> {
     val first = iterator()
     val second = array.iterator()
-    val list = ArrayList<Pair<Int,R>>()
+    val list = ArrayList<Pair<Int, R>>()
     while (first.hasNext() && second.hasNext()) {
         list.add(first.next() to second.next())
     }
     return list
-    
 }
 
 /**
  * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
  */
-public fun <R> LongArray.zip(array: Array<R>) : List<Pair<Long,R>> {
+public fun <R> LongArray.zip(array: Array<R>): List<Pair<Long, R>> {
     val first = iterator()
     val second = array.iterator()
-    val list = ArrayList<Pair<Long,R>>()
+    val list = ArrayList<Pair<Long, R>>()
     while (first.hasNext() && second.hasNext()) {
         list.add(first.next() to second.next())
     }
     return list
-    
 }
 
 /**
  * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
  */
-public fun <R> ShortArray.zip(array: Array<R>) : List<Pair<Short,R>> {
+public fun <R> ShortArray.zip(array: Array<R>): List<Pair<Short, R>> {
     val first = iterator()
     val second = array.iterator()
-    val list = ArrayList<Pair<Short,R>>()
+    val list = ArrayList<Pair<Short, R>>()
     while (first.hasNext() && second.hasNext()) {
         list.add(first.next() to second.next())
     }
     return list
-    
 }
 
 /**
  * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
  */
-public fun <T, R> Iterable<T>.zip(array: Array<R>) : List<Pair<T,R>> {
+public fun <T, R> Iterable<T>.zip(array: Array<R>): List<Pair<T, R>> {
     val first = iterator()
     val second = array.iterator()
-    val list = ArrayList<Pair<T,R>>()
+    val list = ArrayList<Pair<T, R>>()
     while (first.hasNext() && second.hasNext()) {
         list.add(first.next() to second.next())
     }
     return list
-    
 }
 
 /**
  * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
  */
-public fun <R> String.zip(array: Array<R>) : List<Pair<Char,R>> {
+public fun <R> String.zip(array: Array<R>): List<Pair<Char, R>> {
     val first = iterator()
     val second = array.iterator()
-    val list = ArrayList<Pair<Char,R>>()
+    val list = ArrayList<Pair<Char, R>>()
+    while (first.hasNext() && second.hasNext()) {
+        list.add(first.next() to second.next())
+    }
+    return list
+}
+
+/**
+ * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
+ */
+public fun <T, R> Array<out T>.zip(other: Iterable<R>): List<Pair<T, R>> {
+    val first = iterator()
+    val second = other.iterator()
+    val list = ArrayList<Pair<T, R>>()
+    while (first.hasNext() && second.hasNext()) {
+        list.add(first.next() to second.next())
+    }
+    return list
+}
+
+/**
+ * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
+ */
+public fun <R> BooleanArray.zip(other: Iterable<R>): List<Pair<Boolean, R>> {
+    val first = iterator()
+    val second = other.iterator()
+    val list = ArrayList<Pair<Boolean, R>>()
+    while (first.hasNext() && second.hasNext()) {
+        list.add(first.next() to second.next())
+    }
+    return list
+}
+
+/**
+ * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
+ */
+public fun <R> ByteArray.zip(other: Iterable<R>): List<Pair<Byte, R>> {
+    val first = iterator()
+    val second = other.iterator()
+    val list = ArrayList<Pair<Byte, R>>()
+    while (first.hasNext() && second.hasNext()) {
+        list.add(first.next() to second.next())
+    }
+    return list
+}
+
+/**
+ * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
+ */
+public fun <R> CharArray.zip(other: Iterable<R>): List<Pair<Char, R>> {
+    val first = iterator()
+    val second = other.iterator()
+    val list = ArrayList<Pair<Char, R>>()
+    while (first.hasNext() && second.hasNext()) {
+        list.add(first.next() to second.next())
+    }
+    return list
+}
+
+/**
+ * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
+ */
+public fun <R> DoubleArray.zip(other: Iterable<R>): List<Pair<Double, R>> {
+    val first = iterator()
+    val second = other.iterator()
+    val list = ArrayList<Pair<Double, R>>()
+    while (first.hasNext() && second.hasNext()) {
+        list.add(first.next() to second.next())
+    }
+    return list
+}
+
+/**
+ * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
+ */
+public fun <R> FloatArray.zip(other: Iterable<R>): List<Pair<Float, R>> {
+    val first = iterator()
+    val second = other.iterator()
+    val list = ArrayList<Pair<Float, R>>()
+    while (first.hasNext() && second.hasNext()) {
+        list.add(first.next() to second.next())
+    }
+    return list
+}
+
+/**
+ * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
+ */
+public fun <R> IntArray.zip(other: Iterable<R>): List<Pair<Int, R>> {
+    val first = iterator()
+    val second = other.iterator()
+    val list = ArrayList<Pair<Int, R>>()
+    while (first.hasNext() && second.hasNext()) {
+        list.add(first.next() to second.next())
+    }
+    return list
+}
+
+/**
+ * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
+ */
+public fun <R> LongArray.zip(other: Iterable<R>): List<Pair<Long, R>> {
+    val first = iterator()
+    val second = other.iterator()
+    val list = ArrayList<Pair<Long, R>>()
+    while (first.hasNext() && second.hasNext()) {
+        list.add(first.next() to second.next())
+    }
+    return list
+}
+
+/**
+ * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
+ */
+public fun <R> ShortArray.zip(other: Iterable<R>): List<Pair<Short, R>> {
+    val first = iterator()
+    val second = other.iterator()
+    val list = ArrayList<Pair<Short, R>>()
+    while (first.hasNext() && second.hasNext()) {
+        list.add(first.next() to second.next())
+    }
+    return list
+}
+
+/**
+ * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
+ */
+public fun <T, R> Iterable<T>.zip(other: Iterable<R>): List<Pair<T, R>> {
+    val first = iterator()
+    val second = other.iterator()
+    val list = ArrayList<Pair<T, R>>()
+    while (first.hasNext() && second.hasNext()) {
+        list.add(first.next() to second.next())
+    }
+    return list
+}
+
+/**
+ * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
+ */
+public fun <R> String.zip(other: Iterable<R>): List<Pair<Char, R>> {
+    val first = iterator()
+    val second = other.iterator()
+    val list = ArrayList<Pair<Char, R>>()
     while (first.hasNext() && second.hasNext()) {
         list.add(first.next() to second.next())
     }
     return list
-    
 }
 
 /**
  * Returns a list of pairs built from characters of both strings with same indexes. List has length of shortest collection.
  */
-public fun String.zip(other : String) : List<Pair<Char,Char>> {
+public fun String.zip(other: String): List<Pair<Char, Char>> {
     val first = iterator()
     val second = other.iterator()
-    val list = ArrayList<Pair<Char,Char>>()
+    val list = ArrayList<Pair<Char, Char>>()
     while (first.hasNext() && second.hasNext()) {
         list.add(first.next() to second.next())
     }
     return list
-    
-}
-
-/**
- * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
- */
-public fun <T, R> Array<out T>.zip(other: Iterable<R>) : List<Pair<T,R>> {
-    val first = iterator()
-    val second = other.iterator()
-    val list = ArrayList<Pair<T,R>>()
-    while (first.hasNext() && second.hasNext()) {
-        list.add(first.next() to second.next())
-    }
-    return list
-    
-}
-
-/**
- * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
- */
-public fun <R> BooleanArray.zip(other: Iterable<R>) : List<Pair<Boolean,R>> {
-    val first = iterator()
-    val second = other.iterator()
-    val list = ArrayList<Pair<Boolean,R>>()
-    while (first.hasNext() && second.hasNext()) {
-        list.add(first.next() to second.next())
-    }
-    return list
-    
-}
-
-/**
- * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
- */
-public fun <R> ByteArray.zip(other: Iterable<R>) : List<Pair<Byte,R>> {
-    val first = iterator()
-    val second = other.iterator()
-    val list = ArrayList<Pair<Byte,R>>()
-    while (first.hasNext() && second.hasNext()) {
-        list.add(first.next() to second.next())
-    }
-    return list
-    
-}
-
-/**
- * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
- */
-public fun <R> CharArray.zip(other: Iterable<R>) : List<Pair<Char,R>> {
-    val first = iterator()
-    val second = other.iterator()
-    val list = ArrayList<Pair<Char,R>>()
-    while (first.hasNext() && second.hasNext()) {
-        list.add(first.next() to second.next())
-    }
-    return list
-    
-}
-
-/**
- * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
- */
-public fun <R> DoubleArray.zip(other: Iterable<R>) : List<Pair<Double,R>> {
-    val first = iterator()
-    val second = other.iterator()
-    val list = ArrayList<Pair<Double,R>>()
-    while (first.hasNext() && second.hasNext()) {
-        list.add(first.next() to second.next())
-    }
-    return list
-    
-}
-
-/**
- * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
- */
-public fun <R> FloatArray.zip(other: Iterable<R>) : List<Pair<Float,R>> {
-    val first = iterator()
-    val second = other.iterator()
-    val list = ArrayList<Pair<Float,R>>()
-    while (first.hasNext() && second.hasNext()) {
-        list.add(first.next() to second.next())
-    }
-    return list
-    
-}
-
-/**
- * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
- */
-public fun <R> IntArray.zip(other: Iterable<R>) : List<Pair<Int,R>> {
-    val first = iterator()
-    val second = other.iterator()
-    val list = ArrayList<Pair<Int,R>>()
-    while (first.hasNext() && second.hasNext()) {
-        list.add(first.next() to second.next())
-    }
-    return list
-    
-}
-
-/**
- * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
- */
-public fun <R> LongArray.zip(other: Iterable<R>) : List<Pair<Long,R>> {
-    val first = iterator()
-    val second = other.iterator()
-    val list = ArrayList<Pair<Long,R>>()
-    while (first.hasNext() && second.hasNext()) {
-        list.add(first.next() to second.next())
-    }
-    return list
-    
-}
-
-/**
- * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
- */
-public fun <R> ShortArray.zip(other: Iterable<R>) : List<Pair<Short,R>> {
-    val first = iterator()
-    val second = other.iterator()
-    val list = ArrayList<Pair<Short,R>>()
-    while (first.hasNext() && second.hasNext()) {
-        list.add(first.next() to second.next())
-    }
-    return list
-    
-}
-
-/**
- * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
- */
-public fun <T, R> Iterable<T>.zip(other: Iterable<R>) : List<Pair<T,R>> {
-    val first = iterator()
-    val second = other.iterator()
-    val list = ArrayList<Pair<T,R>>()
-    while (first.hasNext() && second.hasNext()) {
-        list.add(first.next() to second.next())
-    }
-    return list
-    
-}
-
-/**
- * Returns a list of pairs built from elements of both collections with same indexes. List has length of shortest collection.
- */
-public fun <R> String.zip(other: Iterable<R>) : List<Pair<Char,R>> {
-    val first = iterator()
-    val second = other.iterator()
-    val list = ArrayList<Pair<Char,R>>()
-    while (first.hasNext() && second.hasNext()) {
-        list.add(first.next() to second.next())
-    }
-    return list
-    
 }
 
 /**
  * Returns a stream of pairs built from elements of both collections with same indexes. List has length of shortest collection.
  */
-public fun <T, R> Stream<T>.zip(stream: Stream<R>) : Stream<Pair<T,R>> {
+public fun <T, R> Stream<T>.zip(stream: Stream<R>): Stream<Pair<T, R>> {
     return ZippingStream(this, stream)
-    
 }
 
diff --git a/libraries/stdlib/src/generated/_Guards.kt b/libraries/stdlib/src/generated/_Guards.kt
index b3686bb3958..82d1664be8f 100644
--- a/libraries/stdlib/src/generated/_Guards.kt
+++ b/libraries/stdlib/src/generated/_Guards.kt
@@ -10,52 +10,48 @@ import java.util.*
 /**
  * Returns an original collection containing all the non-*null* elements, throwing an [[IllegalArgumentException]] if there are any null elements
  */
-public fun <T:Any> Array<T?>.requireNoNulls() : Array<T> {
+public fun <T : Any> Array<T?>.requireNoNulls(): Array<T> {
     for (element in this) {
         if (element == null) {
             throw IllegalArgumentException("null element found in $this")
         }
     }
     return this as Array<T>
-    
 }
 
 /**
  * Returns an original collection containing all the non-*null* elements, throwing an [[IllegalArgumentException]] if there are any null elements
  */
-public fun <T:Any> Iterable<T?>.requireNoNulls() : Iterable<T> {
+public fun <T : Any> Iterable<T?>.requireNoNulls(): Iterable<T> {
     for (element in this) {
         if (element == null) {
             throw IllegalArgumentException("null element found in $this")
         }
     }
     return this as Iterable<T>
-    
 }
 
 /**
  * Returns an original collection containing all the non-*null* elements, throwing an [[IllegalArgumentException]] if there are any null elements
  */
-public fun <T:Any> List<T?>.requireNoNulls() : List<T> {
+public fun <T : Any> List<T?>.requireNoNulls(): List<T> {
     for (element in this) {
         if (element == null) {
             throw IllegalArgumentException("null element found in $this")
         }
     }
     return this as List<T>
-    
 }
 
 /**
  * Returns an original collection containing all the non-*null* elements, throwing an [[IllegalArgumentException]] if there are any null elements
  */
-public fun <T:Any> Stream<T?>.requireNoNulls() : Stream<T> {
+public fun <T : Any> Stream<T?>.requireNoNulls(): Stream<T> {
     return FilteringStream(this) {
         if (it == null) {
             throw IllegalArgumentException("null element found in $this")
         }
         true
     } as Stream<T>
-    
 }
 
diff --git a/libraries/stdlib/src/generated/_Mapping.kt b/libraries/stdlib/src/generated/_Mapping.kt
index 733f9f9cc82..7e91adfde32 100644
--- a/libraries/stdlib/src/generated/_Mapping.kt
+++ b/libraries/stdlib/src/generated/_Mapping.kt
@@ -10,915 +10,858 @@ import java.util.*
 /**
  * Returns a single list of all elements yielded from results of *transform* function being invoked on each element of original collection
  */
-public inline fun <T, R> Array<out T>.flatMap(transform: (T)-> Iterable<R>) : List<R> {
+public inline fun <T, R> Array<out T>.flatMap(transform: (T) -> Iterable<R>): List<R> {
     return flatMapTo(ArrayList<R>(), transform)
 }
 
 /**
  * Returns a single list of all elements yielded from results of *transform* function being invoked on each element of original collection
  */
-public inline fun <R> BooleanArray.flatMap(transform: (Boolean)-> Iterable<R>) : List<R> {
+public inline fun <R> BooleanArray.flatMap(transform: (Boolean) -> Iterable<R>): List<R> {
     return flatMapTo(ArrayList<R>(), transform)
 }
 
 /**
  * Returns a single list of all elements yielded from results of *transform* function being invoked on each element of original collection
  */
-public inline fun <R> ByteArray.flatMap(transform: (Byte)-> Iterable<R>) : List<R> {
+public inline fun <R> ByteArray.flatMap(transform: (Byte) -> Iterable<R>): List<R> {
     return flatMapTo(ArrayList<R>(), transform)
 }
 
 /**
  * Returns a single list of all elements yielded from results of *transform* function being invoked on each element of original collection
  */
-public inline fun <R> CharArray.flatMap(transform: (Char)-> Iterable<R>) : List<R> {
+public inline fun <R> CharArray.flatMap(transform: (Char) -> Iterable<R>): List<R> {
     return flatMapTo(ArrayList<R>(), transform)
 }
 
 /**
  * Returns a single list of all elements yielded from results of *transform* function being invoked on each element of original collection
  */
-public inline fun <R> DoubleArray.flatMap(transform: (Double)-> Iterable<R>) : List<R> {
+public inline fun <R> DoubleArray.flatMap(transform: (Double) -> Iterable<R>): List<R> {
     return flatMapTo(ArrayList<R>(), transform)
 }
 
 /**
  * Returns a single list of all elements yielded from results of *transform* function being invoked on each element of original collection
  */
-public inline fun <R> FloatArray.flatMap(transform: (Float)-> Iterable<R>) : List<R> {
+public inline fun <R> FloatArray.flatMap(transform: (Float) -> Iterable<R>): List<R> {
     return flatMapTo(ArrayList<R>(), transform)
 }
 
 /**
  * Returns a single list of all elements yielded from results of *transform* function being invoked on each element of original collection
  */
-public inline fun <R> IntArray.flatMap(transform: (Int)-> Iterable<R>) : List<R> {
+public inline fun <R> IntArray.flatMap(transform: (Int) -> Iterable<R>): List<R> {
     return flatMapTo(ArrayList<R>(), transform)
 }
 
 /**
  * Returns a single list of all elements yielded from results of *transform* function being invoked on each element of original collection
  */
-public inline fun <R> LongArray.flatMap(transform: (Long)-> Iterable<R>) : List<R> {
+public inline fun <R> LongArray.flatMap(transform: (Long) -> Iterable<R>): List<R> {
     return flatMapTo(ArrayList<R>(), transform)
 }
 
 /**
  * Returns a single list of all elements yielded from results of *transform* function being invoked on each element of original collection
  */
-public inline fun <R> ShortArray.flatMap(transform: (Short)-> Iterable<R>) : List<R> {
+public inline fun <R> ShortArray.flatMap(transform: (Short) -> Iterable<R>): List<R> {
     return flatMapTo(ArrayList<R>(), transform)
 }
 
 /**
  * Returns a single list of all elements yielded from results of *transform* function being invoked on each element of original collection
  */
-public inline fun <T, R> Iterable<T>.flatMap(transform: (T)-> Iterable<R>) : List<R> {
+public inline fun <T, R> Iterable<T>.flatMap(transform: (T) -> Iterable<R>): List<R> {
     return flatMapTo(ArrayList<R>(), transform)
 }
 
 /**
  * Returns a single list of all elements yielded from results of *transform* function being invoked on each element of original collection
  */
-public inline fun <K, V, R> Map<K,V>.flatMap(transform: (Map.Entry<K,V>)-> Iterable<R>) : List<R> {
+public inline fun <K, V, R> Map<K, V>.flatMap(transform: (Map.Entry<K, V>) -> Iterable<R>): List<R> {
     return flatMapTo(ArrayList<R>(), transform)
 }
 
 /**
  * Returns a single list of all elements yielded from results of *transform* function being invoked on each element of original collection
  */
-public inline fun <R> String.flatMap(transform: (Char)-> Iterable<R>) : List<R> {
+public inline fun <R> String.flatMap(transform: (Char) -> Iterable<R>): List<R> {
     return flatMapTo(ArrayList<R>(), transform)
 }
 
 /**
  * Returns a single stream of all elements streamed from results of *transform* function being invoked on each element of original stream
  */
-public fun <T, R> Stream<T>.flatMap(transform: (T)-> Stream<R>) : Stream<R> {
+public fun <T, R> Stream<T>.flatMap(transform: (T) -> Stream<R>): Stream<R> {
     return FlatteningStream(this, transform)
 }
 
 /**
  * Appends all elements yielded from results of *transform* function being invoked on each element of original collection, to the given *collection*
  */
-public inline fun <T, R, C: MutableCollection<in R>> Array<out T>.flatMapTo(collection: C, transform: (T) -> Iterable<R>) : C {
+public inline fun <T, R, C : MutableCollection<in R>> Array<out T>.flatMapTo(collection: C, transform: (T) -> Iterable<R>): C {
     for (element in this) {
         val list = transform(element)
         collection.addAll(list)
     }
     return collection
-    
 }
 
 /**
  * Appends all elements yielded from results of *transform* function being invoked on each element of original collection, to the given *collection*
  */
-public inline fun <R, C: MutableCollection<in R>> BooleanArray.flatMapTo(collection: C, transform: (Boolean) -> Iterable<R>) : C {
+public inline fun <R, C : MutableCollection<in R>> BooleanArray.flatMapTo(collection: C, transform: (Boolean) -> Iterable<R>): C {
     for (element in this) {
         val list = transform(element)
         collection.addAll(list)
     }
     return collection
-    
 }
 
 /**
  * Appends all elements yielded from results of *transform* function being invoked on each element of original collection, to the given *collection*
  */
-public inline fun <R, C: MutableCollection<in R>> ByteArray.flatMapTo(collection: C, transform: (Byte) -> Iterable<R>) : C {
+public inline fun <R, C : MutableCollection<in R>> ByteArray.flatMapTo(collection: C, transform: (Byte) -> Iterable<R>): C {
     for (element in this) {
         val list = transform(element)
         collection.addAll(list)
     }
     return collection
-    
 }
 
 /**
  * Appends all elements yielded from results of *transform* function being invoked on each element of original collection, to the given *collection*
  */
-public inline fun <R, C: MutableCollection<in R>> CharArray.flatMapTo(collection: C, transform: (Char) -> Iterable<R>) : C {
+public inline fun <R, C : MutableCollection<in R>> CharArray.flatMapTo(collection: C, transform: (Char) -> Iterable<R>): C {
     for (element in this) {
         val list = transform(element)
         collection.addAll(list)
     }
     return collection
-    
 }
 
 /**
  * Appends all elements yielded from results of *transform* function being invoked on each element of original collection, to the given *collection*
  */
-public inline fun <R, C: MutableCollection<in R>> DoubleArray.flatMapTo(collection: C, transform: (Double) -> Iterable<R>) : C {
+public inline fun <R, C : MutableCollection<in R>> DoubleArray.flatMapTo(collection: C, transform: (Double) -> Iterable<R>): C {
     for (element in this) {
         val list = transform(element)
         collection.addAll(list)
     }
     return collection
-    
 }
 
 /**
  * Appends all elements yielded from results of *transform* function being invoked on each element of original collection, to the given *collection*
  */
-public inline fun <R, C: MutableCollection<in R>> FloatArray.flatMapTo(collection: C, transform: (Float) -> Iterable<R>) : C {
+public inline fun <R, C : MutableCollection<in R>> FloatArray.flatMapTo(collection: C, transform: (Float) -> Iterable<R>): C {
     for (element in this) {
         val list = transform(element)
         collection.addAll(list)
     }
     return collection
-    
 }
 
 /**
  * Appends all elements yielded from results of *transform* function being invoked on each element of original collection, to the given *collection*
  */
-public inline fun <R, C: MutableCollection<in R>> IntArray.flatMapTo(collection: C, transform: (Int) -> Iterable<R>) : C {
+public inline fun <R, C : MutableCollection<in R>> IntArray.flatMapTo(collection: C, transform: (Int) -> Iterable<R>): C {
     for (element in this) {
         val list = transform(element)
         collection.addAll(list)
     }
     return collection
-    
 }
 
 /**
  * Appends all elements yielded from results of *transform* function being invoked on each element of original collection, to the given *collection*
  */
-public inline fun <R, C: MutableCollection<in R>> LongArray.flatMapTo(collection: C, transform: (Long) -> Iterable<R>) : C {
+public inline fun <R, C : MutableCollection<in R>> LongArray.flatMapTo(collection: C, transform: (Long) -> Iterable<R>): C {
     for (element in this) {
         val list = transform(element)
         collection.addAll(list)
     }
     return collection
-    
 }
 
 /**
  * Appends all elements yielded from results of *transform* function being invoked on each element of original collection, to the given *collection*
  */
-public inline fun <R, C: MutableCollection<in R>> ShortArray.flatMapTo(collection: C, transform: (Short) -> Iterable<R>) : C {
+public inline fun <R, C : MutableCollection<in R>> ShortArray.flatMapTo(collection: C, transform: (Short) -> Iterable<R>): C {
     for (element in this) {
         val list = transform(element)
         collection.addAll(list)
     }
     return collection
-    
 }
 
 /**
  * Appends all elements yielded from results of *transform* function being invoked on each element of original collection, to the given *collection*
  */
-public inline fun <T, R, C: MutableCollection<in R>> Iterable<T>.flatMapTo(collection: C, transform: (T) -> Iterable<R>) : C {
+public inline fun <T, R, C : MutableCollection<in R>> Iterable<T>.flatMapTo(collection: C, transform: (T) -> Iterable<R>): C {
     for (element in this) {
         val list = transform(element)
         collection.addAll(list)
     }
     return collection
-    
 }
 
 /**
  * Appends all elements yielded from results of *transform* function being invoked on each element of original collection, to the given *collection*
  */
-public inline fun <K, V, R, C: MutableCollection<in R>> Map<K,V>.flatMapTo(collection: C, transform: (Map.Entry<K,V>) -> Iterable<R>) : C {
+public inline fun <K, V, R, C : MutableCollection<in R>> Map<K, V>.flatMapTo(collection: C, transform: (Map.Entry<K, V>) -> Iterable<R>): C {
     for (element in this) {
         val list = transform(element)
         collection.addAll(list)
     }
     return collection
-    
 }
 
 /**
  * Appends all elements yielded from results of *transform* function being invoked on each element of original collection, to the given *collection*
  */
-public inline fun <R, C: MutableCollection<in R>> String.flatMapTo(collection: C, transform: (Char) -> Iterable<R>) : C {
+public inline fun <R, C : MutableCollection<in R>> String.flatMapTo(collection: C, transform: (Char) -> Iterable<R>): C {
     for (element in this) {
         val list = transform(element)
         collection.addAll(list)
     }
     return collection
-    
 }
 
 /**
  * Appends all elements yielded from results of *transform* function being invoked on each element of original stream, to the given *collection*
  */
-public inline fun <T, R, C: MutableCollection<in R>> Stream<T>.flatMapTo(collection: C, transform: (T) -> Stream<R>) : C {
+public inline fun <T, R, C : MutableCollection<in R>> Stream<T>.flatMapTo(collection: C, transform: (T) -> Stream<R>): C {
     for (element in this) {
         val list = transform(element)
         collection.addAll(list)
     }
     return collection
-    
 }
 
 /**
  * Returns a map of the elements in original collection grouped by the result of given *toKey* function
  */
-public inline fun <T, K> Array<out T>.groupBy(toKey: (T) -> K) : Map<K, List<T>> {
+public inline fun <T, K> Array<out T>.groupBy(toKey: (T) -> K): Map<K, List<T>> {
     return groupByTo(HashMap<K, MutableList<T>>(), toKey)
 }
 
 /**
  * Returns a map of the elements in original collection grouped by the result of given *toKey* function
  */
-public inline fun <K> BooleanArray.groupBy(toKey: (Boolean) -> K) : Map<K, List<Boolean>> {
+public inline fun <K> BooleanArray.groupBy(toKey: (Boolean) -> K): Map<K, List<Boolean>> {
     return groupByTo(HashMap<K, MutableList<Boolean>>(), toKey)
 }
 
 /**
  * Returns a map of the elements in original collection grouped by the result of given *toKey* function
  */
-public inline fun <K> ByteArray.groupBy(toKey: (Byte) -> K) : Map<K, List<Byte>> {
+public inline fun <K> ByteArray.groupBy(toKey: (Byte) -> K): Map<K, List<Byte>> {
     return groupByTo(HashMap<K, MutableList<Byte>>(), toKey)
 }
 
 /**
  * Returns a map of the elements in original collection grouped by the result of given *toKey* function
  */
-public inline fun <K> CharArray.groupBy(toKey: (Char) -> K) : Map<K, List<Char>> {
+public inline fun <K> CharArray.groupBy(toKey: (Char) -> K): Map<K, List<Char>> {
     return groupByTo(HashMap<K, MutableList<Char>>(), toKey)
 }
 
 /**
  * Returns a map of the elements in original collection grouped by the result of given *toKey* function
  */
-public inline fun <K> DoubleArray.groupBy(toKey: (Double) -> K) : Map<K, List<Double>> {
+public inline fun <K> DoubleArray.groupBy(toKey: (Double) -> K): Map<K, List<Double>> {
     return groupByTo(HashMap<K, MutableList<Double>>(), toKey)
 }
 
 /**
  * Returns a map of the elements in original collection grouped by the result of given *toKey* function
  */
-public inline fun <K> FloatArray.groupBy(toKey: (Float) -> K) : Map<K, List<Float>> {
+public inline fun <K> FloatArray.groupBy(toKey: (Float) -> K): Map<K, List<Float>> {
     return groupByTo(HashMap<K, MutableList<Float>>(), toKey)
 }
 
 /**
  * Returns a map of the elements in original collection grouped by the result of given *toKey* function
  */
-public inline fun <K> IntArray.groupBy(toKey: (Int) -> K) : Map<K, List<Int>> {
+public inline fun <K> IntArray.groupBy(toKey: (Int) -> K): Map<K, List<Int>> {
     return groupByTo(HashMap<K, MutableList<Int>>(), toKey)
 }
 
 /**
  * Returns a map of the elements in original collection grouped by the result of given *toKey* function
  */
-public inline fun <K> LongArray.groupBy(toKey: (Long) -> K) : Map<K, List<Long>> {
+public inline fun <K> LongArray.groupBy(toKey: (Long) -> K): Map<K, List<Long>> {
     return groupByTo(HashMap<K, MutableList<Long>>(), toKey)
 }
 
 /**
  * Returns a map of the elements in original collection grouped by the result of given *toKey* function
  */
-public inline fun <K> ShortArray.groupBy(toKey: (Short) -> K) : Map<K, List<Short>> {
+public inline fun <K> ShortArray.groupBy(toKey: (Short) -> K): Map<K, List<Short>> {
     return groupByTo(HashMap<K, MutableList<Short>>(), toKey)
 }
 
 /**
  * Returns a map of the elements in original collection grouped by the result of given *toKey* function
  */
-public inline fun <T, K> Iterable<T>.groupBy(toKey: (T) -> K) : Map<K, List<T>> {
+public inline fun <T, K> Iterable<T>.groupBy(toKey: (T) -> K): Map<K, List<T>> {
     return groupByTo(HashMap<K, MutableList<T>>(), toKey)
 }
 
 /**
  * Returns a map of the elements in original collection grouped by the result of given *toKey* function
  */
-public inline fun <V, K> Map<K,V>.groupBy(toKey: (Map.Entry<K,V>) -> K) : Map<K, List<Map.Entry<K,V>>> {
-    return groupByTo(HashMap<K, MutableList<Map.Entry<K,V>>>(), toKey)
+public inline fun <V, K> Map<K, V>.groupBy(toKey: (Map.Entry<K, V>) -> K): Map<K, List<Map.Entry<K, V>>> {
+    return groupByTo(HashMap<K, MutableList<Map.Entry<K, V>>>(), toKey)
 }
 
 /**
  * Returns a map of the elements in original collection grouped by the result of given *toKey* function
  */
-public inline fun <T, K> Stream<T>.groupBy(toKey: (T) -> K) : Map<K, List<T>> {
+public inline fun <T, K> Stream<T>.groupBy(toKey: (T) -> K): Map<K, List<T>> {
     return groupByTo(HashMap<K, MutableList<T>>(), toKey)
 }
 
 /**
  * Returns a map of the elements in original collection grouped by the result of given *toKey* function
  */
-public inline fun <K> String.groupBy(toKey: (Char) -> K) : Map<K, List<Char>> {
+public inline fun <K> String.groupBy(toKey: (Char) -> K): Map<K, List<Char>> {
     return groupByTo(HashMap<K, MutableList<Char>>(), toKey)
 }
 
 /**
  * Appends elements from original collection grouped by the result of given *toKey* function to the given *map*
  */
-public inline fun <T, K> Array<out T>.groupByTo(map: MutableMap<K, MutableList<T>>, toKey: (T) -> K) : Map<K, MutableList<T>> {
+public inline fun <T, K> Array<out T>.groupByTo(map: MutableMap<K, MutableList<T>>, toKey: (T) -> K): Map<K, MutableList<T>> {
     for (element in this) {
         val key = toKey(element)
         val list = map.getOrPut(key) { ArrayList<T>() }
         list.add(element)
     }
     return map
-    
 }
 
 /**
  * Appends elements from original collection grouped by the result of given *toKey* function to the given *map*
  */
-public inline fun <K> BooleanArray.groupByTo(map: MutableMap<K, MutableList<Boolean>>, toKey: (Boolean) -> K) : Map<K, MutableList<Boolean>> {
+public inline fun <K> BooleanArray.groupByTo(map: MutableMap<K, MutableList<Boolean>>, toKey: (Boolean) -> K): Map<K, MutableList<Boolean>> {
     for (element in this) {
         val key = toKey(element)
         val list = map.getOrPut(key) { ArrayList<Boolean>() }
         list.add(element)
     }
     return map
-    
 }
 
 /**
  * Appends elements from original collection grouped by the result of given *toKey* function to the given *map*
  */
-public inline fun <K> ByteArray.groupByTo(map: MutableMap<K, MutableList<Byte>>, toKey: (Byte) -> K) : Map<K, MutableList<Byte>> {
+public inline fun <K> ByteArray.groupByTo(map: MutableMap<K, MutableList<Byte>>, toKey: (Byte) -> K): Map<K, MutableList<Byte>> {
     for (element in this) {
         val key = toKey(element)
         val list = map.getOrPut(key) { ArrayList<Byte>() }
         list.add(element)
     }
     return map
-    
 }
 
 /**
  * Appends elements from original collection grouped by the result of given *toKey* function to the given *map*
  */
-public inline fun <K> CharArray.groupByTo(map: MutableMap<K, MutableList<Char>>, toKey: (Char) -> K) : Map<K, MutableList<Char>> {
+public inline fun <K> CharArray.groupByTo(map: MutableMap<K, MutableList<Char>>, toKey: (Char) -> K): Map<K, MutableList<Char>> {
     for (element in this) {
         val key = toKey(element)
         val list = map.getOrPut(key) { ArrayList<Char>() }
         list.add(element)
     }
     return map
-    
 }
 
 /**
  * Appends elements from original collection grouped by the result of given *toKey* function to the given *map*
  */
-public inline fun <K> DoubleArray.groupByTo(map: MutableMap<K, MutableList<Double>>, toKey: (Double) -> K) : Map<K, MutableList<Double>> {
+public inline fun <K> DoubleArray.groupByTo(map: MutableMap<K, MutableList<Double>>, toKey: (Double) -> K): Map<K, MutableList<Double>> {
     for (element in this) {
         val key = toKey(element)
         val list = map.getOrPut(key) { ArrayList<Double>() }
         list.add(element)
     }
     return map
-    
 }
 
 /**
  * Appends elements from original collection grouped by the result of given *toKey* function to the given *map*
  */
-public inline fun <K> FloatArray.groupByTo(map: MutableMap<K, MutableList<Float>>, toKey: (Float) -> K) : Map<K, MutableList<Float>> {
+public inline fun <K> FloatArray.groupByTo(map: MutableMap<K, MutableList<Float>>, toKey: (Float) -> K): Map<K, MutableList<Float>> {
     for (element in this) {
         val key = toKey(element)
         val list = map.getOrPut(key) { ArrayList<Float>() }
         list.add(element)
     }
     return map
-    
 }
 
 /**
  * Appends elements from original collection grouped by the result of given *toKey* function to the given *map*
  */
-public inline fun <K> IntArray.groupByTo(map: MutableMap<K, MutableList<Int>>, toKey: (Int) -> K) : Map<K, MutableList<Int>> {
+public inline fun <K> IntArray.groupByTo(map: MutableMap<K, MutableList<Int>>, toKey: (Int) -> K): Map<K, MutableList<Int>> {
     for (element in this) {
         val key = toKey(element)
         val list = map.getOrPut(key) { ArrayList<Int>() }
         list.add(element)
     }
     return map
-    
 }
 
 /**
  * Appends elements from original collection grouped by the result of given *toKey* function to the given *map*
  */
-public inline fun <K> LongArray.groupByTo(map: MutableMap<K, MutableList<Long>>, toKey: (Long) -> K) : Map<K, MutableList<Long>> {
+public inline fun <K> LongArray.groupByTo(map: MutableMap<K, MutableList<Long>>, toKey: (Long) -> K): Map<K, MutableList<Long>> {
     for (element in this) {
         val key = toKey(element)
         val list = map.getOrPut(key) { ArrayList<Long>() }
         list.add(element)
     }
     return map
-    
 }
 
 /**
  * Appends elements from original collection grouped by the result of given *toKey* function to the given *map*
  */
-public inline fun <K> ShortArray.groupByTo(map: MutableMap<K, MutableList<Short>>, toKey: (Short) -> K) : Map<K, MutableList<Short>> {
+public inline fun <K> ShortArray.groupByTo(map: MutableMap<K, MutableList<Short>>, toKey: (Short) -> K): Map<K, MutableList<Short>> {
     for (element in this) {
         val key = toKey(element)
         val list = map.getOrPut(key) { ArrayList<Short>() }
         list.add(element)
     }
     return map
-    
 }
 
 /**
  * Appends elements from original collection grouped by the result of given *toKey* function to the given *map*
  */
-public inline fun <T, K> Iterable<T>.groupByTo(map: MutableMap<K, MutableList<T>>, toKey: (T) -> K) : Map<K, MutableList<T>> {
+public inline fun <T, K> Iterable<T>.groupByTo(map: MutableMap<K, MutableList<T>>, toKey: (T) -> K): Map<K, MutableList<T>> {
     for (element in this) {
         val key = toKey(element)
         val list = map.getOrPut(key) { ArrayList<T>() }
         list.add(element)
     }
     return map
-    
 }
 
 /**
  * Appends elements from original collection grouped by the result of given *toKey* function to the given *map*
  */
-public inline fun <V, K> Map<K,V>.groupByTo(map: MutableMap<K, MutableList<Map.Entry<K,V>>>, toKey: (Map.Entry<K,V>) -> K) : Map<K, MutableList<Map.Entry<K,V>>> {
+public inline fun <V, K> Map<K, V>.groupByTo(map: MutableMap<K, MutableList<Map.Entry<K, V>>>, toKey: (Map.Entry<K, V>) -> K): Map<K, MutableList<Map.Entry<K, V>>> {
     for (element in this) {
         val key = toKey(element)
-        val list = map.getOrPut(key) { ArrayList<Map.Entry<K,V>>() }
+        val list = map.getOrPut(key) { ArrayList<Map.Entry<K, V>>() }
         list.add(element)
     }
     return map
-    
 }
 
 /**
  * Appends elements from original collection grouped by the result of given *toKey* function to the given *map*
  */
-public inline fun <T, K> Stream<T>.groupByTo(map: MutableMap<K, MutableList<T>>, toKey: (T) -> K) : Map<K, MutableList<T>> {
+public inline fun <T, K> Stream<T>.groupByTo(map: MutableMap<K, MutableList<T>>, toKey: (T) -> K): Map<K, MutableList<T>> {
     for (element in this) {
         val key = toKey(element)
         val list = map.getOrPut(key) { ArrayList<T>() }
         list.add(element)
     }
     return map
-    
 }
 
 /**
  * Appends elements from original collection grouped by the result of given *toKey* function to the given *map*
  */
-public inline fun <K> String.groupByTo(map: MutableMap<K, MutableList<Char>>, toKey: (Char) -> K) : Map<K, MutableList<Char>> {
+public inline fun <K> String.groupByTo(map: MutableMap<K, MutableList<Char>>, toKey: (Char) -> K): Map<K, MutableList<Char>> {
     for (element in this) {
         val key = toKey(element)
         val list = map.getOrPut(key) { ArrayList<Char>() }
         list.add(element)
     }
     return map
-    
 }
 
 /**
  * Returns a list containing the results of applying the given *transform* function to each element of the original collection
  */
-public inline fun <T, R> Array<out T>.map(transform : (T) -> R) : List<R> {
+public inline fun <T, R> Array<out T>.map(transform: (T) -> R): List<R> {
     return mapTo(ArrayList<R>(), transform)
 }
 
 /**
  * Returns a list containing the results of applying the given *transform* function to each element of the original collection
  */
-public inline fun <R> BooleanArray.map(transform : (Boolean) -> R) : List<R> {
+public inline fun <R> BooleanArray.map(transform: (Boolean) -> R): List<R> {
     return mapTo(ArrayList<R>(), transform)
 }
 
 /**
  * Returns a list containing the results of applying the given *transform* function to each element of the original collection
  */
-public inline fun <R> ByteArray.map(transform : (Byte) -> R) : List<R> {
+public inline fun <R> ByteArray.map(transform: (Byte) -> R): List<R> {
     return mapTo(ArrayList<R>(), transform)
 }
 
 /**
  * Returns a list containing the results of applying the given *transform* function to each element of the original collection
  */
-public inline fun <R> CharArray.map(transform : (Char) -> R) : List<R> {
+public inline fun <R> CharArray.map(transform: (Char) -> R): List<R> {
     return mapTo(ArrayList<R>(), transform)
 }
 
 /**
  * Returns a list containing the results of applying the given *transform* function to each element of the original collection
  */
-public inline fun <R> DoubleArray.map(transform : (Double) -> R) : List<R> {
+public inline fun <R> DoubleArray.map(transform: (Double) -> R): List<R> {
     return mapTo(ArrayList<R>(), transform)
 }
 
 /**
  * Returns a list containing the results of applying the given *transform* function to each element of the original collection
  */
-public inline fun <R> FloatArray.map(transform : (Float) -> R) : List<R> {
+public inline fun <R> FloatArray.map(transform: (Float) -> R): List<R> {
     return mapTo(ArrayList<R>(), transform)
 }
 
 /**
  * Returns a list containing the results of applying the given *transform* function to each element of the original collection
  */
-public inline fun <R> IntArray.map(transform : (Int) -> R) : List<R> {
+public inline fun <R> IntArray.map(transform: (Int) -> R): List<R> {
     return mapTo(ArrayList<R>(), transform)
 }
 
 /**
  * Returns a list containing the results of applying the given *transform* function to each element of the original collection
  */
-public inline fun <R> LongArray.map(transform : (Long) -> R) : List<R> {
+public inline fun <R> LongArray.map(transform: (Long) -> R): List<R> {
     return mapTo(ArrayList<R>(), transform)
 }
 
 /**
  * Returns a list containing the results of applying the given *transform* function to each element of the original collection
  */
-public inline fun <R> ShortArray.map(transform : (Short) -> R) : List<R> {
+public inline fun <R> ShortArray.map(transform: (Short) -> R): List<R> {
     return mapTo(ArrayList<R>(), transform)
 }
 
 /**
  * Returns a list containing the results of applying the given *transform* function to each element of the original collection
  */
-public inline fun <T, R> Iterable<T>.map(transform : (T) -> R) : List<R> {
+public inline fun <T, R> Iterable<T>.map(transform: (T) -> R): List<R> {
     return mapTo(ArrayList<R>(), transform)
 }
 
 /**
  * Returns a list containing the results of applying the given *transform* function to each element of the original collection
  */
-public inline fun <K, V, R> Map<K,V>.map(transform : (Map.Entry<K,V>) -> R) : List<R> {
+public inline fun <K, V, R> Map<K, V>.map(transform: (Map.Entry<K, V>) -> R): List<R> {
     return mapTo(ArrayList<R>(), transform)
 }
 
 /**
  * Returns a stream containing the results of applying the given *transform* function to each element of the original stream
  */
-public fun <T, R> Stream<T>.map(transform : (T) -> R) : Stream<R> {
-    return TransformingStream(this, transform) 
+public fun <T, R> Stream<T>.map(transform: (T) -> R): Stream<R> {
+    return TransformingStream(this, transform)
 }
 
 /**
  * Returns a list containing the results of applying the given *transform* function to each element of the original collection
  */
-public inline fun <R> String.map(transform : (Char) -> R) : List<R> {
+public inline fun <R> String.map(transform: (Char) -> R): List<R> {
     return mapTo(ArrayList<R>(), transform)
 }
 
 /**
  * Returns a list containing the results of applying the given *transform* function to each non-null element of the original collection
  */
-public inline fun <T: Any, R> Array<T?>.mapNotNull(transform : (T) -> R) : List<R> {
+public inline fun <T : Any, R> Array<T?>.mapNotNull(transform: (T) -> R): List<R> {
     return mapNotNullTo(ArrayList<R>(), transform)
-    
 }
 
 /**
  * Returns a list containing the results of applying the given *transform* function to each non-null element of the original collection
  */
-public inline fun <T: Any, R> Iterable<T?>.mapNotNull(transform : (T) -> R) : List<R> {
+public inline fun <T : Any, R> Iterable<T?>.mapNotNull(transform: (T) -> R): List<R> {
     return mapNotNullTo(ArrayList<R>(), transform)
-    
 }
 
 /**
  * Returns a stream containing the results of applying the given *transform* function to each non-null element of the original stream
  */
-public fun <T: Any, R> Stream<T?>.mapNotNull(transform : (T) -> R) : Stream<R> {
+public fun <T : Any, R> Stream<T?>.mapNotNull(transform: (T) -> R): Stream<R> {
     return TransformingStream(FilteringStream(this, false, { it != null }) as Stream<T>, transform)
-    
 }
 
 /**
  * Appends transformed non-null elements of original collection using the given *transform* function
  * to the given *collection*
  */
-public inline fun <T: Any, R, C: MutableCollection<in R>> Array<T?>.mapNotNullTo(collection: C, transform : (T) -> R) : C {
+public inline fun <T : Any, R, C : MutableCollection<in R>> Array<T?>.mapNotNullTo(collection: C, transform: (T) -> R): C {
     for (element in this) {
         if (element != null) {
             collection.add(transform(element))
-         }
+        }
     }
     return collection
-    
 }
 
 /**
  * Appends transformed non-null elements of original collection using the given *transform* function
  * to the given *collection*
  */
-public inline fun <T: Any, R, C: MutableCollection<in R>> Iterable<T?>.mapNotNullTo(collection: C, transform : (T) -> R) : C {
+public inline fun <T : Any, R, C : MutableCollection<in R>> Iterable<T?>.mapNotNullTo(collection: C, transform: (T) -> R): C {
     for (element in this) {
         if (element != null) {
             collection.add(transform(element))
-         }
+        }
     }
     return collection
-    
 }
 
 /**
  * Appends transformed non-null elements of original collection using the given *transform* function
  * to the given *collection*
  */
-public inline fun <T: Any, R, C: MutableCollection<in R>> Stream<T?>.mapNotNullTo(collection: C, transform : (T) -> R) : C {
+public inline fun <T : Any, R, C : MutableCollection<in R>> Stream<T?>.mapNotNullTo(collection: C, transform: (T) -> R): C {
     for (element in this) {
         if (element != null) {
             collection.add(transform(element))
-         }
+        }
     }
     return collection
-    
 }
 
 /**
  * Appends transformed elements of original collection using the given *transform* function
  * to the given *collection*
  */
-public inline fun <T, R, C: MutableCollection<in R>> Array<out T>.mapTo(collection: C, transform : (T) -> R) : C {
+public inline fun <T, R, C : MutableCollection<in R>> Array<out T>.mapTo(collection: C, transform: (T) -> R): C {
     for (item in this)
         collection.add(transform(item))
     return collection
-    
 }
 
 /**
  * Appends transformed elements of original collection using the given *transform* function
  * to the given *collection*
  */
-public inline fun <R, C: MutableCollection<in R>> BooleanArray.mapTo(collection: C, transform : (Boolean) -> R) : C {
+public inline fun <R, C : MutableCollection<in R>> BooleanArray.mapTo(collection: C, transform: (Boolean) -> R): C {
     for (item in this)
         collection.add(transform(item))
     return collection
-    
 }
 
 /**
  * Appends transformed elements of original collection using the given *transform* function
  * to the given *collection*
  */
-public inline fun <R, C: MutableCollection<in R>> ByteArray.mapTo(collection: C, transform : (Byte) -> R) : C {
+public inline fun <R, C : MutableCollection<in R>> ByteArray.mapTo(collection: C, transform: (Byte) -> R): C {
     for (item in this)
         collection.add(transform(item))
     return collection
-    
 }
 
 /**
  * Appends transformed elements of original collection using the given *transform* function
  * to the given *collection*
  */
-public inline fun <R, C: MutableCollection<in R>> CharArray.mapTo(collection: C, transform : (Char) -> R) : C {
+public inline fun <R, C : MutableCollection<in R>> CharArray.mapTo(collection: C, transform: (Char) -> R): C {
     for (item in this)
         collection.add(transform(item))
     return collection
-    
 }
 
 /**
  * Appends transformed elements of original collection using the given *transform* function
  * to the given *collection*
  */
-public inline fun <R, C: MutableCollection<in R>> DoubleArray.mapTo(collection: C, transform : (Double) -> R) : C {
+public inline fun <R, C : MutableCollection<in R>> DoubleArray.mapTo(collection: C, transform: (Double) -> R): C {
     for (item in this)
         collection.add(transform(item))
     return collection
-    
 }
 
 /**
  * Appends transformed elements of original collection using the given *transform* function
  * to the given *collection*
  */
-public inline fun <R, C: MutableCollection<in R>> FloatArray.mapTo(collection: C, transform : (Float) -> R) : C {
+public inline fun <R, C : MutableCollection<in R>> FloatArray.mapTo(collection: C, transform: (Float) -> R): C {
     for (item in this)
         collection.add(transform(item))
     return collection
-    
 }
 
 /**
  * Appends transformed elements of original collection using the given *transform* function
  * to the given *collection*
  */
-public inline fun <R, C: MutableCollection<in R>> IntArray.mapTo(collection: C, transform : (Int) -> R) : C {
+public inline fun <R, C : MutableCollection<in R>> IntArray.mapTo(collection: C, transform: (Int) -> R): C {
     for (item in this)
         collection.add(transform(item))
     return collection
-    
 }
 
 /**
  * Appends transformed elements of original collection using the given *transform* function
  * to the given *collection*
  */
-public inline fun <R, C: MutableCollection<in R>> LongArray.mapTo(collection: C, transform : (Long) -> R) : C {
+public inline fun <R, C : MutableCollection<in R>> LongArray.mapTo(collection: C, transform: (Long) -> R): C {
     for (item in this)
         collection.add(transform(item))
     return collection
-    
 }
 
 /**
  * Appends transformed elements of original collection using the given *transform* function
  * to the given *collection*
  */
-public inline fun <R, C: MutableCollection<in R>> ShortArray.mapTo(collection: C, transform : (Short) -> R) : C {
+public inline fun <R, C : MutableCollection<in R>> ShortArray.mapTo(collection: C, transform: (Short) -> R): C {
     for (item in this)
         collection.add(transform(item))
     return collection
-    
 }
 
 /**
  * Appends transformed elements of original collection using the given *transform* function
  * to the given *collection*
  */
-public inline fun <T, R, C: MutableCollection<in R>> Iterable<T>.mapTo(collection: C, transform : (T) -> R) : C {
+public inline fun <T, R, C : MutableCollection<in R>> Iterable<T>.mapTo(collection: C, transform: (T) -> R): C {
     for (item in this)
         collection.add(transform(item))
     return collection
-    
 }
 
 /**
  * Appends transformed elements of original collection using the given *transform* function
  * to the given *collection*
  */
-public inline fun <K, V, R, C: MutableCollection<in R>> Map<K,V>.mapTo(collection: C, transform : (Map.Entry<K,V>) -> R) : C {
+public inline fun <K, V, R, C : MutableCollection<in R>> Map<K, V>.mapTo(collection: C, transform: (Map.Entry<K, V>) -> R): C {
     for (item in this)
         collection.add(transform(item))
     return collection
-    
 }
 
 /**
  * Appends transformed elements of original collection using the given *transform* function
  * to the given *collection*
  */
-public inline fun <T, R, C: MutableCollection<in R>> Stream<T>.mapTo(collection: C, transform : (T) -> R) : C {
+public inline fun <T, R, C : MutableCollection<in R>> Stream<T>.mapTo(collection: C, transform: (T) -> R): C {
     for (item in this)
         collection.add(transform(item))
     return collection
-    
 }
 
 /**
  * Appends transformed elements of original collection using the given *transform* function
  * to the given *collection*
  */
-public inline fun <R, C: MutableCollection<in R>> String.mapTo(collection: C, transform : (Char) -> R) : C {
+public inline fun <R, C : MutableCollection<in R>> String.mapTo(collection: C, transform: (Char) -> R): C {
     for (item in this)
         collection.add(transform(item))
     return collection
-    
 }
 
 /**
  * Returns a list containing pairs of each element of the original collection and their index
  */
-public fun <T> Array<out T>.withIndices() : List<Pair<Int, T>> {
+public fun <T> Array<out T>.withIndices(): List<Pair<Int, T>> {
     var index = 0
     return mapTo(ArrayList<Pair<Int, T>>(), { index++ to it })
-    
 }
 
 /**
  * Returns a list containing pairs of each element of the original collection and their index
  */
-public fun BooleanArray.withIndices() : List<Pair<Int, Boolean>> {
+public fun BooleanArray.withIndices(): List<Pair<Int, Boolean>> {
     var index = 0
     return mapTo(ArrayList<Pair<Int, Boolean>>(), { index++ to it })
-    
 }
 
 /**
  * Returns a list containing pairs of each element of the original collection and their index
  */
-public fun ByteArray.withIndices() : List<Pair<Int, Byte>> {
+public fun ByteArray.withIndices(): List<Pair<Int, Byte>> {
     var index = 0
     return mapTo(ArrayList<Pair<Int, Byte>>(), { index++ to it })
-    
 }
 
 /**
  * Returns a list containing pairs of each element of the original collection and their index
  */
-public fun CharArray.withIndices() : List<Pair<Int, Char>> {
+public fun CharArray.withIndices(): List<Pair<Int, Char>> {
     var index = 0
     return mapTo(ArrayList<Pair<Int, Char>>(), { index++ to it })
-    
 }
 
 /**
  * Returns a list containing pairs of each element of the original collection and their index
  */
-public fun DoubleArray.withIndices() : List<Pair<Int, Double>> {
+public fun DoubleArray.withIndices(): List<Pair<Int, Double>> {
     var index = 0
     return mapTo(ArrayList<Pair<Int, Double>>(), { index++ to it })
-    
 }
 
 /**
  * Returns a list containing pairs of each element of the original collection and their index
  */
-public fun FloatArray.withIndices() : List<Pair<Int, Float>> {
+public fun FloatArray.withIndices(): List<Pair<Int, Float>> {
     var index = 0
     return mapTo(ArrayList<Pair<Int, Float>>(), { index++ to it })
-    
 }
 
 /**
  * Returns a list containing pairs of each element of the original collection and their index
  */
-public fun IntArray.withIndices() : List<Pair<Int, Int>> {
+public fun IntArray.withIndices(): List<Pair<Int, Int>> {
     var index = 0
     return mapTo(ArrayList<Pair<Int, Int>>(), { index++ to it })
-    
 }
 
 /**
  * Returns a list containing pairs of each element of the original collection and their index
  */
-public fun LongArray.withIndices() : List<Pair<Int, Long>> {
+public fun LongArray.withIndices(): List<Pair<Int, Long>> {
     var index = 0
     return mapTo(ArrayList<Pair<Int, Long>>(), { index++ to it })
-    
 }
 
 /**
  * Returns a list containing pairs of each element of the original collection and their index
  */
-public fun ShortArray.withIndices() : List<Pair<Int, Short>> {
+public fun ShortArray.withIndices(): List<Pair<Int, Short>> {
     var index = 0
     return mapTo(ArrayList<Pair<Int, Short>>(), { index++ to it })
-    
 }
 
 /**
  * Returns a list containing pairs of each element of the original collection and their index
  */
-public fun <T> Iterable<T>.withIndices() : List<Pair<Int, T>> {
+public fun <T> Iterable<T>.withIndices(): List<Pair<Int, T>> {
     var index = 0
     return mapTo(ArrayList<Pair<Int, T>>(), { index++ to it })
-    
 }
 
 /**
  * Returns a stream containing pairs of each element of the original collection and their index
  */
-public fun <T> Stream<T>.withIndices() : Stream<Pair<Int, T>> {
+public fun <T> Stream<T>.withIndices(): Stream<Pair<Int, T>> {
     var index = 0
     return TransformingStream(this, { index++ to it })
-    
 }
 
 /**
  * Returns a list containing pairs of each element of the original collection and their index
  */
-public fun String.withIndices() : List<Pair<Int, Char>> {
+public fun String.withIndices(): List<Pair<Int, Char>> {
     var index = 0
     return mapTo(ArrayList<Pair<Int, Char>>(), { index++ to it })
-    
 }
 
diff --git a/libraries/stdlib/src/generated/_Numeric.kt b/libraries/stdlib/src/generated/_Numeric.kt
index c8d4ede75b0..ceaa2b4826a 100644
--- a/libraries/stdlib/src/generated/_Numeric.kt
+++ b/libraries/stdlib/src/generated/_Numeric.kt
@@ -10,208 +10,192 @@ import java.util.*
 /**
  * Returns the sum of all elements in the collection
  */
-public fun Iterable<Int>.sum() : Int {
+public fun Iterable<Int>.sum(): Int {
     val iterator = iterator()
-    var sum : Int = 0
+    var sum: Int = 0
     while (iterator.hasNext()) {
         sum += iterator.next()
     }
     return sum
-    
 }
 
 /**
  * Returns the sum of all elements in the collection
  */
-public fun Iterable<Long>.sum() : Long {
+public fun Iterable<Long>.sum(): Long {
     val iterator = iterator()
-    var sum : Long = 0
+    var sum: Long = 0
     while (iterator.hasNext()) {
         sum += iterator.next()
     }
     return sum
-    
 }
 
 /**
  * Returns the sum of all elements in the collection
  */
-public fun Iterable<Double>.sum() : Double {
+public fun Iterable<Double>.sum(): Double {
     val iterator = iterator()
-    var sum : Double = 0.0
+    var sum: Double = 0.0
     while (iterator.hasNext()) {
         sum += iterator.next()
     }
     return sum
-    
 }
 
 /**
  * Returns the sum of all elements in the collection
  */
-public fun Iterable<Float>.sum() : Float {
+public fun Iterable<Float>.sum(): Float {
     val iterator = iterator()
-    var sum : Float = 0.0f
+    var sum: Float = 0.0f
     while (iterator.hasNext()) {
         sum += iterator.next()
     }
     return sum
-    
 }
 
 /**
  * Returns the sum of all elements in the collection
  */
-public fun Array<out Int>.sum() : Int {
+public fun Array<out Int>.sum(): Int {
     val iterator = iterator()
-    var sum : Int = 0
+    var sum: Int = 0
     while (iterator.hasNext()) {
         sum += iterator.next()
     }
     return sum
-    
 }
 
 /**
  * Returns the sum of all elements in the collection
  */
-public fun IntArray.sum() : Int {
+public fun IntArray.sum(): Int {
     val iterator = iterator()
-    var sum : Int = 0
+    var sum: Int = 0
     while (iterator.hasNext()) {
         sum += iterator.next()
     }
     return sum
-    
 }
 
 /**
  * Returns the sum of all elements in the collection
  */
-public fun Array<out Long>.sum() : Long {
+public fun Array<out Long>.sum(): Long {
     val iterator = iterator()
-    var sum : Long = 0
+    var sum: Long = 0
     while (iterator.hasNext()) {
         sum += iterator.next()
     }
     return sum
-    
 }
 
 /**
  * Returns the sum of all elements in the collection
  */
-public fun LongArray.sum() : Long {
+public fun LongArray.sum(): Long {
     val iterator = iterator()
-    var sum : Long = 0
+    var sum: Long = 0
     while (iterator.hasNext()) {
         sum += iterator.next()
     }
     return sum
-    
 }
 
 /**
  * Returns the sum of all elements in the collection
  */
-public fun Array<out Byte>.sum() : Int {
+public fun Array<out Byte>.sum(): Int {
     val iterator = iterator()
-    var sum : Int = 0
+    var sum: Int = 0
     while (iterator.hasNext()) {
         sum += iterator.next()
     }
     return sum
-    
 }
 
 /**
  * Returns the sum of all elements in the collection
  */
-public fun ByteArray.sum() : Int {
+public fun ByteArray.sum(): Int {
     val iterator = iterator()
-    var sum : Int = 0
+    var sum: Int = 0
     while (iterator.hasNext()) {
         sum += iterator.next()
     }
     return sum
-    
 }
 
 /**
  * Returns the sum of all elements in the collection
  */
-public fun Array<out Short>.sum() : Int {
+public fun Array<out Short>.sum(): Int {
     val iterator = iterator()
-    var sum : Int = 0
+    var sum: Int = 0
     while (iterator.hasNext()) {
         sum += iterator.next()
     }
     return sum
-    
 }
 
 /**
  * Returns the sum of all elements in the collection
  */
-public fun ShortArray.sum() : Int {
+public fun ShortArray.sum(): Int {
     val iterator = iterator()
-    var sum : Int = 0
+    var sum: Int = 0
     while (iterator.hasNext()) {
         sum += iterator.next()
     }
     return sum
-    
 }
 
 /**
  * Returns the sum of all elements in the collection
  */
-public fun Array<out Double>.sum() : Double {
+public fun Array<out Double>.sum(): Double {
     val iterator = iterator()
-    var sum : Double = 0.0
+    var sum: Double = 0.0
     while (iterator.hasNext()) {
         sum += iterator.next()
     }
     return sum
-    
 }
 
 /**
  * Returns the sum of all elements in the collection
  */
-public fun DoubleArray.sum() : Double {
+public fun DoubleArray.sum(): Double {
     val iterator = iterator()
-    var sum : Double = 0.0
+    var sum: Double = 0.0
     while (iterator.hasNext()) {
         sum += iterator.next()
     }
     return sum
-    
 }
 
 /**
  * Returns the sum of all elements in the collection
  */
-public fun Array<out Float>.sum() : Float {
+public fun Array<out Float>.sum(): Float {
     val iterator = iterator()
-    var sum : Float = 0.0f
+    var sum: Float = 0.0f
     while (iterator.hasNext()) {
         sum += iterator.next()
     }
     return sum
-    
 }
 
 /**
  * Returns the sum of all elements in the collection
  */
-public fun FloatArray.sum() : Float {
+public fun FloatArray.sum(): Float {
     val iterator = iterator()
-    var sum : Float = 0.0f
+    var sum: Float = 0.0f
     while (iterator.hasNext()) {
         sum += iterator.next()
     }
     return sum
-    
 }
 
diff --git a/libraries/stdlib/src/generated/_Ordering.kt b/libraries/stdlib/src/generated/_Ordering.kt
index c6a9d7e3aac..78e1d52c570 100644
--- a/libraries/stdlib/src/generated/_Ordering.kt
+++ b/libraries/stdlib/src/generated/_Ordering.kt
@@ -10,193 +10,174 @@ import java.util.*
 /**
  * Returns a list with elements in reversed order
  */
-public fun <T> Array<out T>.reverse() : List<T> {
+public fun <T> Array<out T>.reverse(): List<T> {
     val list = toArrayList()
     Collections.reverse(list)
     return list
-    
 }
 
 /**
  * Returns a list with elements in reversed order
  */
-public fun BooleanArray.reverse() : List<Boolean> {
+public fun BooleanArray.reverse(): List<Boolean> {
     val list = toArrayList()
     Collections.reverse(list)
     return list
-    
 }
 
 /**
  * Returns a list with elements in reversed order
  */
-public fun ByteArray.reverse() : List<Byte> {
+public fun ByteArray.reverse(): List<Byte> {
     val list = toArrayList()
     Collections.reverse(list)
     return list
-    
 }
 
 /**
  * Returns a list with elements in reversed order
  */
-public fun CharArray.reverse() : List<Char> {
+public fun CharArray.reverse(): List<Char> {
     val list = toArrayList()
     Collections.reverse(list)
     return list
-    
 }
 
 /**
  * Returns a list with elements in reversed order
  */
-public fun DoubleArray.reverse() : List<Double> {
+public fun DoubleArray.reverse(): List<Double> {
     val list = toArrayList()
     Collections.reverse(list)
     return list
-    
 }
 
 /**
  * Returns a list with elements in reversed order
  */
-public fun FloatArray.reverse() : List<Float> {
+public fun FloatArray.reverse(): List<Float> {
     val list = toArrayList()
     Collections.reverse(list)
     return list
-    
 }
 
 /**
  * Returns a list with elements in reversed order
  */
-public fun IntArray.reverse() : List<Int> {
+public fun IntArray.reverse(): List<Int> {
     val list = toArrayList()
     Collections.reverse(list)
     return list
-    
 }
 
 /**
  * Returns a list with elements in reversed order
  */
-public fun LongArray.reverse() : List<Long> {
+public fun LongArray.reverse(): List<Long> {
     val list = toArrayList()
     Collections.reverse(list)
     return list
-    
 }
 
 /**
  * Returns a list with elements in reversed order
  */
-public fun ShortArray.reverse() : List<Short> {
+public fun ShortArray.reverse(): List<Short> {
     val list = toArrayList()
     Collections.reverse(list)
     return list
-    
 }
 
 /**
  * Returns a list with elements in reversed order
  */
-public fun <T> Iterable<T>.reverse() : List<T> {
+public fun <T> Iterable<T>.reverse(): List<T> {
     val list = toArrayList()
     Collections.reverse(list)
     return list
-    
 }
 
 /**
  * Returns a string with characters in reversed order
  */
-public fun String.reverse() : String {
+public fun String.reverse(): String {
     return StringBuilder().append(this).reverse().toString()
-    
 }
 
 /**
  * Returns a sorted list of all elements
  */
-public fun <T: Comparable<T>> Iterable<T>.sort() : List<T> {
+public fun <T : Comparable<T>> Iterable<T>.sort(): List<T> {
     val sortedList = toArrayList()
     java.util.Collections.sort(sortedList)
     return sortedList
-    
 }
 
 /**
  * Returns a list of all elements, sorted by the specified *comparator*
  */
-public fun <T> Array<out T>.sortBy(comparator : Comparator<T>) : List<T> {
+public fun <T> Array<out T>.sortBy(comparator: Comparator<T>): List<T> {
     val sortedList = toArrayList()
     java.util.Collections.sort(sortedList, comparator)
     return sortedList
-    
 }
 
 /**
  * Returns a list of all elements, sorted by the specified *comparator*
  */
-public fun <T> Iterable<T>.sortBy(comparator : Comparator<T>) : List<T> {
+public fun <T> Iterable<T>.sortBy(comparator: Comparator<T>): List<T> {
     val sortedList = toArrayList()
     java.util.Collections.sort(sortedList, comparator)
     return sortedList
-    
 }
 
 /**
  * Returns a list of all elements, sorted by results of specified *order* function.
  */
-public inline fun <T, R: Comparable<R>> Array<out T>.sortBy(order: (T) -> R) : List<T> {
+public inline fun <T, R : Comparable<R>> Array<out T>.sortBy(order: (T) -> R): List<T> {
     val sortedList = toArrayList()
-    val sortBy: Comparator<T> = comparator<T> {(x: T, y: T) -> order(x).compareTo(order(y))}
+    val sortBy: Comparator<T> = comparator<T> {(x: T, y: T) -> order(x).compareTo(order(y)) }
     java.util.Collections.sort(sortedList, sortBy)
     return sortedList
-    
 }
 
 /**
  * Returns a list of all elements, sorted by results of specified *order* function.
  */
-public inline fun <T, R: Comparable<R>> Iterable<T>.sortBy(order: (T) -> R) : List<T> {
+public inline fun <T, R : Comparable<R>> Iterable<T>.sortBy(order: (T) -> R): List<T> {
     val sortedList = toArrayList()
-    val sortBy: Comparator<T> = comparator<T> {(x: T, y: T) -> order(x).compareTo(order(y))}
+    val sortBy: Comparator<T> = comparator<T> {(x: T, y: T) -> order(x).compareTo(order(y)) }
     java.util.Collections.sort(sortedList, sortBy)
     return sortedList
-    
 }
 
 /**
  * Returns a sorted list of all elements
  */
-public fun <T: Comparable<T>> Iterable<T>.sortDescending() : List<T> {
+public fun <T : Comparable<T>> Iterable<T>.sortDescending(): List<T> {
     val sortedList = toArrayList()
-    val sortBy: Comparator<T> = comparator<T> {(x: T, y: T) -> -x.compareTo(y)}
+    val sortBy: Comparator<T> = comparator<T> {(x: T, y: T) -> -x.compareTo(y) }
     java.util.Collections.sort(sortedList, sortBy)
     return sortedList
-    
 }
 
 /**
  * Returns a list of all elements, sorted by results of specified *order* function.
  */
-public inline fun <T, R: Comparable<R>> Array<out T>.sortDescendingBy(order: (T) -> R) : List<T> {
+public inline fun <T, R : Comparable<R>> Array<out T>.sortDescendingBy(order: (T) -> R): List<T> {
     val sortedList = toArrayList()
-    val sortBy: Comparator<T> = comparator<T> {(x: T, y: T) -> -order(x).compareTo(order(y))}
+    val sortBy: Comparator<T> = comparator<T> {(x: T, y: T) -> -order(x).compareTo(order(y)) }
     java.util.Collections.sort(sortedList, sortBy)
     return sortedList
-    
 }
 
 /**
  * Returns a list of all elements, sorted by results of specified *order* function.
  */
-public inline fun <T, R: Comparable<R>> Iterable<T>.sortDescendingBy(order: (T) -> R) : List<T> {
+public inline fun <T, R : Comparable<R>> Iterable<T>.sortDescendingBy(order: (T) -> R): List<T> {
     val sortedList = toArrayList()
-    val sortBy: Comparator<T> = comparator<T> {(x: T, y: T) -> -order(x).compareTo(order(y))}
+    val sortBy: Comparator<T> = comparator<T> {(x: T, y: T) -> -order(x).compareTo(order(y)) }
     java.util.Collections.sort(sortedList, sortBy)
     return sortedList
-    
 }
 
diff --git a/libraries/stdlib/src/generated/_Snapshots.kt b/libraries/stdlib/src/generated/_Snapshots.kt
index c384f451e82..e063bd3aa2d 100644
--- a/libraries/stdlib/src/generated/_Snapshots.kt
+++ b/libraries/stdlib/src/generated/_Snapshots.kt
@@ -10,771 +10,742 @@ import java.util.*
 /**
  * Returns an ArrayList of all elements
  */
-public fun <T> Array<out T>.toArrayList() : ArrayList<T> {
+public fun <T> Array<out T>.toArrayList(): ArrayList<T> {
     val list = ArrayList<T>(size)
     for (item in this) list.add(item)
     return list
-    
 }
 
 /**
  * Returns an ArrayList of all elements
  */
-public fun BooleanArray.toArrayList() : ArrayList<Boolean> {
+public fun BooleanArray.toArrayList(): ArrayList<Boolean> {
     val list = ArrayList<Boolean>(size)
     for (item in this) list.add(item)
     return list
-    
 }
 
 /**
  * Returns an ArrayList of all elements
  */
-public fun ByteArray.toArrayList() : ArrayList<Byte> {
+public fun ByteArray.toArrayList(): ArrayList<Byte> {
     val list = ArrayList<Byte>(size)
     for (item in this) list.add(item)
     return list
-    
 }
 
 /**
  * Returns an ArrayList of all elements
  */
-public fun CharArray.toArrayList() : ArrayList<Char> {
+public fun CharArray.toArrayList(): ArrayList<Char> {
     val list = ArrayList<Char>(size)
     for (item in this) list.add(item)
     return list
-    
 }
 
 /**
  * Returns an ArrayList of all elements
  */
-public fun DoubleArray.toArrayList() : ArrayList<Double> {
+public fun DoubleArray.toArrayList(): ArrayList<Double> {
     val list = ArrayList<Double>(size)
     for (item in this) list.add(item)
     return list
-    
 }
 
 /**
  * Returns an ArrayList of all elements
  */
-public fun FloatArray.toArrayList() : ArrayList<Float> {
+public fun FloatArray.toArrayList(): ArrayList<Float> {
     val list = ArrayList<Float>(size)
     for (item in this) list.add(item)
     return list
-    
 }
 
 /**
  * Returns an ArrayList of all elements
  */
-public fun IntArray.toArrayList() : ArrayList<Int> {
+public fun IntArray.toArrayList(): ArrayList<Int> {
     val list = ArrayList<Int>(size)
     for (item in this) list.add(item)
     return list
-    
 }
 
 /**
  * Returns an ArrayList of all elements
  */
-public fun LongArray.toArrayList() : ArrayList<Long> {
+public fun LongArray.toArrayList(): ArrayList<Long> {
     val list = ArrayList<Long>(size)
     for (item in this) list.add(item)
     return list
-    
 }
 
 /**
  * Returns an ArrayList of all elements
  */
-public fun ShortArray.toArrayList() : ArrayList<Short> {
+public fun ShortArray.toArrayList(): ArrayList<Short> {
     val list = ArrayList<Short>(size)
     for (item in this) list.add(item)
     return list
-    
 }
 
 /**
  * Returns an ArrayList of all elements
  */
-public fun <T> Iterable<T>.toArrayList() : ArrayList<T> {
+public fun <T> Iterable<T>.toArrayList(): ArrayList<T> {
     return toCollection(ArrayList<T>())
 }
 
 /**
  * Returns an ArrayList of all elements
  */
-public fun <T> Stream<T>.toArrayList() : ArrayList<T> {
+public fun <T> Stream<T>.toArrayList(): ArrayList<T> {
     return toCollection(ArrayList<T>())
 }
 
 /**
  * Returns an ArrayList of all elements
  */
-public fun String.toArrayList() : ArrayList<Char> {
+public fun String.toArrayList(): ArrayList<Char> {
     return toCollection(ArrayList<Char>())
 }
 
 /**
  * Appends all elements to the given *collection*
  */
-public fun <T, C : MutableCollection<in T>> Array<out T>.toCollection(collection : C) : C {
+public fun <T, C : MutableCollection<in T>> Array<out T>.toCollection(collection: C): C {
     for (item in this) {
         collection.add(item)
     }
     return collection
-    
 }
 
 /**
  * Appends all elements to the given *collection*
  */
-public fun <C : MutableCollection<in Boolean>> BooleanArray.toCollection(collection : C) : C {
+public fun <C : MutableCollection<in Boolean>> BooleanArray.toCollection(collection: C): C {
     for (item in this) {
         collection.add(item)
     }
     return collection
-    
 }
 
 /**
  * Appends all elements to the given *collection*
  */
-public fun <C : MutableCollection<in Byte>> ByteArray.toCollection(collection : C) : C {
+public fun <C : MutableCollection<in Byte>> ByteArray.toCollection(collection: C): C {
     for (item in this) {
         collection.add(item)
     }
     return collection
-    
 }
 
 /**
  * Appends all elements to the given *collection*
  */
-public fun <C : MutableCollection<in Char>> CharArray.toCollection(collection : C) : C {
+public fun <C : MutableCollection<in Char>> CharArray.toCollection(collection: C): C {
     for (item in this) {
         collection.add(item)
     }
     return collection
-    
 }
 
 /**
  * Appends all elements to the given *collection*
  */
-public fun <C : MutableCollection<in Double>> DoubleArray.toCollection(collection : C) : C {
+public fun <C : MutableCollection<in Double>> DoubleArray.toCollection(collection: C): C {
     for (item in this) {
         collection.add(item)
     }
     return collection
-    
 }
 
 /**
  * Appends all elements to the given *collection*
  */
-public fun <C : MutableCollection<in Float>> FloatArray.toCollection(collection : C) : C {
+public fun <C : MutableCollection<in Float>> FloatArray.toCollection(collection: C): C {
     for (item in this) {
         collection.add(item)
     }
     return collection
-    
 }
 
 /**
  * Appends all elements to the given *collection*
  */
-public fun <C : MutableCollection<in Int>> IntArray.toCollection(collection : C) : C {
+public fun <C : MutableCollection<in Int>> IntArray.toCollection(collection: C): C {
     for (item in this) {
         collection.add(item)
     }
     return collection
-    
 }
 
 /**
  * Appends all elements to the given *collection*
  */
-public fun <C : MutableCollection<in Long>> LongArray.toCollection(collection : C) : C {
+public fun <C : MutableCollection<in Long>> LongArray.toCollection(collection: C): C {
     for (item in this) {
         collection.add(item)
     }
     return collection
-    
 }
 
 /**
  * Appends all elements to the given *collection*
  */
-public fun <C : MutableCollection<in Short>> ShortArray.toCollection(collection : C) : C {
+public fun <C : MutableCollection<in Short>> ShortArray.toCollection(collection: C): C {
     for (item in this) {
         collection.add(item)
     }
     return collection
-    
 }
 
 /**
  * Appends all elements to the given *collection*
  */
-public fun <T, C : MutableCollection<in T>> Iterable<T>.toCollection(collection : C) : C {
+public fun <T, C : MutableCollection<in T>> Iterable<T>.toCollection(collection: C): C {
     for (item in this) {
         collection.add(item)
     }
     return collection
-    
 }
 
 /**
  * Appends all elements to the given *collection*
  */
-public fun <T, C : MutableCollection<in T>> Stream<T>.toCollection(collection : C) : C {
+public fun <T, C : MutableCollection<in T>> Stream<T>.toCollection(collection: C): C {
     for (item in this) {
         collection.add(item)
     }
     return collection
-    
 }
 
 /**
  * Appends all elements to the given *collection*
  */
-public fun <C : MutableCollection<in Char>> String.toCollection(collection : C) : C {
+public fun <C : MutableCollection<in Char>> String.toCollection(collection: C): C {
     for (item in this) {
         collection.add(item)
     }
     return collection
-    
 }
 
 /**
  * Returns a HashSet of all elements
  */
-public fun <T> Array<out T>.toHashSet() : HashSet<T> {
+public fun <T> Array<out T>.toHashSet(): HashSet<T> {
     return toCollection(HashSet<T>())
 }
 
 /**
  * Returns a HashSet of all elements
  */
-public fun BooleanArray.toHashSet() : HashSet<Boolean> {
+public fun BooleanArray.toHashSet(): HashSet<Boolean> {
     return toCollection(HashSet<Boolean>())
 }
 
 /**
  * Returns a HashSet of all elements
  */
-public fun ByteArray.toHashSet() : HashSet<Byte> {
+public fun ByteArray.toHashSet(): HashSet<Byte> {
     return toCollection(HashSet<Byte>())
 }
 
 /**
  * Returns a HashSet of all elements
  */
-public fun CharArray.toHashSet() : HashSet<Char> {
+public fun CharArray.toHashSet(): HashSet<Char> {
     return toCollection(HashSet<Char>())
 }
 
 /**
  * Returns a HashSet of all elements
  */
-public fun DoubleArray.toHashSet() : HashSet<Double> {
+public fun DoubleArray.toHashSet(): HashSet<Double> {
     return toCollection(HashSet<Double>())
 }
 
 /**
  * Returns a HashSet of all elements
  */
-public fun FloatArray.toHashSet() : HashSet<Float> {
+public fun FloatArray.toHashSet(): HashSet<Float> {
     return toCollection(HashSet<Float>())
 }
 
 /**
  * Returns a HashSet of all elements
  */
-public fun IntArray.toHashSet() : HashSet<Int> {
+public fun IntArray.toHashSet(): HashSet<Int> {
     return toCollection(HashSet<Int>())
 }
 
 /**
  * Returns a HashSet of all elements
  */
-public fun LongArray.toHashSet() : HashSet<Long> {
+public fun LongArray.toHashSet(): HashSet<Long> {
     return toCollection(HashSet<Long>())
 }
 
 /**
  * Returns a HashSet of all elements
  */
-public fun ShortArray.toHashSet() : HashSet<Short> {
+public fun ShortArray.toHashSet(): HashSet<Short> {
     return toCollection(HashSet<Short>())
 }
 
 /**
  * Returns a HashSet of all elements
  */
-public fun <T> Iterable<T>.toHashSet() : HashSet<T> {
+public fun <T> Iterable<T>.toHashSet(): HashSet<T> {
     return toCollection(HashSet<T>())
 }
 
 /**
  * Returns a HashSet of all elements
  */
-public fun <T> Stream<T>.toHashSet() : HashSet<T> {
+public fun <T> Stream<T>.toHashSet(): HashSet<T> {
     return toCollection(HashSet<T>())
 }
 
 /**
  * Returns a HashSet of all elements
  */
-public fun String.toHashSet() : HashSet<Char> {
+public fun String.toHashSet(): HashSet<Char> {
     return toCollection(HashSet<Char>())
 }
 
 /**
  * Returns a LinkedList containing all elements
  */
-public fun <T> Array<out T>.toLinkedList() : LinkedList<T> {
+public fun <T> Array<out T>.toLinkedList(): LinkedList<T> {
     return toCollection(LinkedList<T>())
 }
 
 /**
  * Returns a LinkedList containing all elements
  */
-public fun BooleanArray.toLinkedList() : LinkedList<Boolean> {
+public fun BooleanArray.toLinkedList(): LinkedList<Boolean> {
     return toCollection(LinkedList<Boolean>())
 }
 
 /**
  * Returns a LinkedList containing all elements
  */
-public fun ByteArray.toLinkedList() : LinkedList<Byte> {
+public fun ByteArray.toLinkedList(): LinkedList<Byte> {
     return toCollection(LinkedList<Byte>())
 }
 
 /**
  * Returns a LinkedList containing all elements
  */
-public fun CharArray.toLinkedList() : LinkedList<Char> {
+public fun CharArray.toLinkedList(): LinkedList<Char> {
     return toCollection(LinkedList<Char>())
 }
 
 /**
  * Returns a LinkedList containing all elements
  */
-public fun DoubleArray.toLinkedList() : LinkedList<Double> {
+public fun DoubleArray.toLinkedList(): LinkedList<Double> {
     return toCollection(LinkedList<Double>())
 }
 
 /**
  * Returns a LinkedList containing all elements
  */
-public fun FloatArray.toLinkedList() : LinkedList<Float> {
+public fun FloatArray.toLinkedList(): LinkedList<Float> {
     return toCollection(LinkedList<Float>())
 }
 
 /**
  * Returns a LinkedList containing all elements
  */
-public fun IntArray.toLinkedList() : LinkedList<Int> {
+public fun IntArray.toLinkedList(): LinkedList<Int> {
     return toCollection(LinkedList<Int>())
 }
 
 /**
  * Returns a LinkedList containing all elements
  */
-public fun LongArray.toLinkedList() : LinkedList<Long> {
+public fun LongArray.toLinkedList(): LinkedList<Long> {
     return toCollection(LinkedList<Long>())
 }
 
 /**
  * Returns a LinkedList containing all elements
  */
-public fun ShortArray.toLinkedList() : LinkedList<Short> {
+public fun ShortArray.toLinkedList(): LinkedList<Short> {
     return toCollection(LinkedList<Short>())
 }
 
 /**
  * Returns a LinkedList containing all elements
  */
-public fun <T> Iterable<T>.toLinkedList() : LinkedList<T> {
+public fun <T> Iterable<T>.toLinkedList(): LinkedList<T> {
     return toCollection(LinkedList<T>())
 }
 
 /**
  * Returns a LinkedList containing all elements
  */
-public fun <T> Stream<T>.toLinkedList() : LinkedList<T> {
+public fun <T> Stream<T>.toLinkedList(): LinkedList<T> {
     return toCollection(LinkedList<T>())
 }
 
 /**
  * Returns a LinkedList containing all elements
  */
-public fun String.toLinkedList() : LinkedList<Char> {
+public fun String.toLinkedList(): LinkedList<Char> {
     return toCollection(LinkedList<Char>())
 }
 
 /**
  * Returns a List containing all elements
  */
-public fun <T> Array<out T>.toList() : List<T> {
+public fun <T> Array<out T>.toList(): List<T> {
     return toCollection(ArrayList<T>())
 }
 
 /**
  * Returns a List containing all elements
  */
-public fun BooleanArray.toList() : List<Boolean> {
+public fun BooleanArray.toList(): List<Boolean> {
     val list = ArrayList<Boolean>(size)
     for (item in this) list.add(item)
     return list
-    
 }
 
 /**
  * Returns a List containing all elements
  */
-public fun ByteArray.toList() : List<Byte> {
+public fun ByteArray.toList(): List<Byte> {
     val list = ArrayList<Byte>(size)
     for (item in this) list.add(item)
     return list
-    
 }
 
 /**
  * Returns a List containing all elements
  */
-public fun CharArray.toList() : List<Char> {
+public fun CharArray.toList(): List<Char> {
     val list = ArrayList<Char>(size)
     for (item in this) list.add(item)
     return list
-    
 }
 
 /**
  * Returns a List containing all elements
  */
-public fun DoubleArray.toList() : List<Double> {
+public fun DoubleArray.toList(): List<Double> {
     val list = ArrayList<Double>(size)
     for (item in this) list.add(item)
     return list
-    
 }
 
 /**
  * Returns a List containing all elements
  */
-public fun FloatArray.toList() : List<Float> {
+public fun FloatArray.toList(): List<Float> {
     val list = ArrayList<Float>(size)
     for (item in this) list.add(item)
     return list
-    
 }
 
 /**
  * Returns a List containing all elements
  */
-public fun IntArray.toList() : List<Int> {
+public fun IntArray.toList(): List<Int> {
     val list = ArrayList<Int>(size)
     for (item in this) list.add(item)
     return list
-    
 }
 
 /**
  * Returns a List containing all elements
  */
-public fun LongArray.toList() : List<Long> {
+public fun LongArray.toList(): List<Long> {
     val list = ArrayList<Long>(size)
     for (item in this) list.add(item)
     return list
-    
 }
 
 /**
  * Returns a List containing all elements
  */
-public fun ShortArray.toList() : List<Short> {
+public fun ShortArray.toList(): List<Short> {
     val list = ArrayList<Short>(size)
     for (item in this) list.add(item)
     return list
-    
 }
 
 /**
  * Returns a List containing all elements
  */
-public fun <T> Iterable<T>.toList() : List<T> {
+public fun <T> Iterable<T>.toList(): List<T> {
     return toCollection(ArrayList<T>())
 }
 
 /**
  * Returns a List containing all elements
  */
-public fun <T> Stream<T>.toList() : List<T> {
+public fun <T> Stream<T>.toList(): List<T> {
     return toCollection(ArrayList<T>())
 }
 
 /**
  * Returns a List containing all elements
  */
-public fun String.toList() : List<Char> {
+public fun String.toList(): List<Char> {
     return toCollection(ArrayList<Char>())
 }
 
 /**
  * Returns a Set of all elements
  */
-public fun <T> Array<out T>.toSet() : Set<T> {
+public fun <T> Array<out T>.toSet(): Set<T> {
     return toCollection(LinkedHashSet<T>())
 }
 
 /**
  * Returns a Set of all elements
  */
-public fun BooleanArray.toSet() : Set<Boolean> {
+public fun BooleanArray.toSet(): Set<Boolean> {
     return toCollection(LinkedHashSet<Boolean>())
 }
 
 /**
  * Returns a Set of all elements
  */
-public fun ByteArray.toSet() : Set<Byte> {
+public fun ByteArray.toSet(): Set<Byte> {
     return toCollection(LinkedHashSet<Byte>())
 }
 
 /**
  * Returns a Set of all elements
  */
-public fun CharArray.toSet() : Set<Char> {
+public fun CharArray.toSet(): Set<Char> {
     return toCollection(LinkedHashSet<Char>())
 }
 
 /**
  * Returns a Set of all elements
  */
-public fun DoubleArray.toSet() : Set<Double> {
+public fun DoubleArray.toSet(): Set<Double> {
     return toCollection(LinkedHashSet<Double>())
 }
 
 /**
  * Returns a Set of all elements
  */
-public fun FloatArray.toSet() : Set<Float> {
+public fun FloatArray.toSet(): Set<Float> {
     return toCollection(LinkedHashSet<Float>())
 }
 
 /**
  * Returns a Set of all elements
  */
-public fun IntArray.toSet() : Set<Int> {
+public fun IntArray.toSet(): Set<Int> {
     return toCollection(LinkedHashSet<Int>())
 }
 
 /**
  * Returns a Set of all elements
  */
-public fun LongArray.toSet() : Set<Long> {
+public fun LongArray.toSet(): Set<Long> {
     return toCollection(LinkedHashSet<Long>())
 }
 
 /**
  * Returns a Set of all elements
  */
-public fun ShortArray.toSet() : Set<Short> {
+public fun ShortArray.toSet(): Set<Short> {
     return toCollection(LinkedHashSet<Short>())
 }
 
 /**
  * Returns a Set of all elements
  */
-public fun <T> Iterable<T>.toSet() : Set<T> {
+public fun <T> Iterable<T>.toSet(): Set<T> {
     return toCollection(LinkedHashSet<T>())
 }
 
 /**
  * Returns a Set of all elements
  */
-public fun <T> Stream<T>.toSet() : Set<T> {
+public fun <T> Stream<T>.toSet(): Set<T> {
     return toCollection(LinkedHashSet<T>())
 }
 
 /**
  * Returns a Set of all elements
  */
-public fun String.toSet() : Set<Char> {
+public fun String.toSet(): Set<Char> {
     return toCollection(LinkedHashSet<Char>())
 }
 
 /**
  * Returns a sorted list of all elements
  */
-public fun <T: Comparable<T>> Array<out T>.toSortedList() : List<T> {
+public fun <T : Comparable<T>> Array<out T>.toSortedList(): List<T> {
     return toArrayList().sort()
 }
 
 /**
  * Returns a sorted list of all elements
  */
-public fun BooleanArray.toSortedList() : List<Boolean> {
+public fun BooleanArray.toSortedList(): List<Boolean> {
     return toArrayList().sort()
 }
 
 /**
  * Returns a sorted list of all elements
  */
-public fun ByteArray.toSortedList() : List<Byte> {
+public fun ByteArray.toSortedList(): List<Byte> {
     return toArrayList().sort()
 }
 
 /**
  * Returns a sorted list of all elements
  */
-public fun CharArray.toSortedList() : List<Char> {
+public fun CharArray.toSortedList(): List<Char> {
     return toArrayList().sort()
 }
 
 /**
  * Returns a sorted list of all elements
  */
-public fun DoubleArray.toSortedList() : List<Double> {
+public fun DoubleArray.toSortedList(): List<Double> {
     return toArrayList().sort()
 }
 
 /**
  * Returns a sorted list of all elements
  */
-public fun FloatArray.toSortedList() : List<Float> {
+public fun FloatArray.toSortedList(): List<Float> {
     return toArrayList().sort()
 }
 
 /**
  * Returns a sorted list of all elements
  */
-public fun IntArray.toSortedList() : List<Int> {
+public fun IntArray.toSortedList(): List<Int> {
     return toArrayList().sort()
 }
 
 /**
  * Returns a sorted list of all elements
  */
-public fun LongArray.toSortedList() : List<Long> {
+public fun LongArray.toSortedList(): List<Long> {
     return toArrayList().sort()
 }
 
 /**
  * Returns a sorted list of all elements
  */
-public fun ShortArray.toSortedList() : List<Short> {
+public fun ShortArray.toSortedList(): List<Short> {
     return toArrayList().sort()
 }
 
 /**
  * Returns a sorted list of all elements
  */
-public fun <T: Comparable<T>> Iterable<T>.toSortedList() : List<T> {
+public fun <T : Comparable<T>> Iterable<T>.toSortedList(): List<T> {
     return sort()
 }
 
 /**
  * Returns a sorted list of all elements
  */
-public fun <T: Comparable<T>> Stream<T>.toSortedList() : List<T> {
+public fun <T : Comparable<T>> Stream<T>.toSortedList(): List<T> {
     return toArrayList().sort()
 }
 
 /**
  * Returns a sorted list of all elements
  */
-public fun String.toSortedList() : List<Char> {
+public fun String.toSortedList(): List<Char> {
     return toArrayList().sort()
 }
 
 /**
  * Returns a SortedSet of all elements
  */
-public fun <T> Array<out T>.toSortedSet() : SortedSet<T> {
+public fun <T> Array<out T>.toSortedSet(): SortedSet<T> {
     return toCollection(TreeSet<T>())
 }
 
 /**
  * Returns a SortedSet of all elements
  */
-public fun BooleanArray.toSortedSet() : SortedSet<Boolean> {
+public fun BooleanArray.toSortedSet(): SortedSet<Boolean> {
     return toCollection(TreeSet<Boolean>())
 }
 
 /**
  * Returns a SortedSet of all elements
  */
-public fun ByteArray.toSortedSet() : SortedSet<Byte> {
+public fun ByteArray.toSortedSet(): SortedSet<Byte> {
     return toCollection(TreeSet<Byte>())
 }
 
 /**
  * Returns a SortedSet of all elements
  */
-public fun CharArray.toSortedSet() : SortedSet<Char> {
+public fun CharArray.toSortedSet(): SortedSet<Char> {
     return toCollection(TreeSet<Char>())
 }
 
 /**
  * Returns a SortedSet of all elements
  */
-public fun DoubleArray.toSortedSet() : SortedSet<Double> {
+public fun DoubleArray.toSortedSet(): SortedSet<Double> {
     return toCollection(TreeSet<Double>())
 }
 
 /**
  * Returns a SortedSet of all elements
  */
-public fun FloatArray.toSortedSet() : SortedSet<Float> {
+public fun FloatArray.toSortedSet(): SortedSet<Float> {
     return toCollection(TreeSet<Float>())
 }
 
 /**
  * Returns a SortedSet of all elements
  */
-public fun IntArray.toSortedSet() : SortedSet<Int> {
+public fun IntArray.toSortedSet(): SortedSet<Int> {
     return toCollection(TreeSet<Int>())
 }
 
 /**
  * Returns a SortedSet of all elements
  */
-public fun LongArray.toSortedSet() : SortedSet<Long> {
+public fun LongArray.toSortedSet(): SortedSet<Long> {
     return toCollection(TreeSet<Long>())
 }
 
 /**
  * Returns a SortedSet of all elements
  */
-public fun ShortArray.toSortedSet() : SortedSet<Short> {
+public fun ShortArray.toSortedSet(): SortedSet<Short> {
     return toCollection(TreeSet<Short>())
 }
 
 /**
  * Returns a SortedSet of all elements
  */
-public fun <T> Iterable<T>.toSortedSet() : SortedSet<T> {
+public fun <T> Iterable<T>.toSortedSet(): SortedSet<T> {
     return toCollection(TreeSet<T>())
 }
 
 /**
  * Returns a SortedSet of all elements
  */
-public fun <T> Stream<T>.toSortedSet() : SortedSet<T> {
+public fun <T> Stream<T>.toSortedSet(): SortedSet<T> {
     return toCollection(TreeSet<T>())
 }
 
 /**
  * Returns a SortedSet of all elements
  */
-public fun String.toSortedSet() : SortedSet<Char> {
+public fun String.toSortedSet(): SortedSet<Char> {
     return toCollection(TreeSet<Char>())
 }
 
diff --git a/libraries/stdlib/src/generated/_SpecialJVM.kt b/libraries/stdlib/src/generated/_SpecialJVM.kt
index 2c2e7d5a02b..edefa308e9d 100644
--- a/libraries/stdlib/src/generated/_SpecialJVM.kt
+++ b/libraries/stdlib/src/generated/_SpecialJVM.kt
@@ -10,450 +10,433 @@ import java.util.*
 /**
  * Searches array or range of array for provided element index using binary search algorithm. Array is expected to be sorted.
  */
-public fun <T> Array<out T>.binarySearch(element: T, fromIndex: Int = 0, toIndex: Int = size - 1) : Int {
+public fun <T> Array<out T>.binarySearch(element: T, fromIndex: Int = 0, toIndex: Int = size - 1): Int {
     return Arrays.binarySearch(this, fromIndex, toIndex, element)
 }
 
 /**
  * Searches array or range of array for provided element index using binary search algorithm. Array is expected to be sorted.
  */
-public fun ByteArray.binarySearch(element: Byte, fromIndex: Int = 0, toIndex: Int = size - 1) : Int {
+public fun ByteArray.binarySearch(element: Byte, fromIndex: Int = 0, toIndex: Int = size - 1): Int {
     return Arrays.binarySearch(this, fromIndex, toIndex, element)
 }
 
 /**
  * Searches array or range of array for provided element index using binary search algorithm. Array is expected to be sorted.
  */
-public fun CharArray.binarySearch(element: Char, fromIndex: Int = 0, toIndex: Int = size - 1) : Int {
+public fun CharArray.binarySearch(element: Char, fromIndex: Int = 0, toIndex: Int = size - 1): Int {
     return Arrays.binarySearch(this, fromIndex, toIndex, element)
 }
 
 /**
  * Searches array or range of array for provided element index using binary search algorithm. Array is expected to be sorted.
  */
-public fun DoubleArray.binarySearch(element: Double, fromIndex: Int = 0, toIndex: Int = size - 1) : Int {
+public fun DoubleArray.binarySearch(element: Double, fromIndex: Int = 0, toIndex: Int = size - 1): Int {
     return Arrays.binarySearch(this, fromIndex, toIndex, element)
 }
 
 /**
  * Searches array or range of array for provided element index using binary search algorithm. Array is expected to be sorted.
  */
-public fun FloatArray.binarySearch(element: Float, fromIndex: Int = 0, toIndex: Int = size - 1) : Int {
+public fun FloatArray.binarySearch(element: Float, fromIndex: Int = 0, toIndex: Int = size - 1): Int {
     return Arrays.binarySearch(this, fromIndex, toIndex, element)
 }
 
 /**
  * Searches array or range of array for provided element index using binary search algorithm. Array is expected to be sorted.
  */
-public fun IntArray.binarySearch(element: Int, fromIndex: Int = 0, toIndex: Int = size - 1) : Int {
+public fun IntArray.binarySearch(element: Int, fromIndex: Int = 0, toIndex: Int = size - 1): Int {
     return Arrays.binarySearch(this, fromIndex, toIndex, element)
 }
 
 /**
  * Searches array or range of array for provided element index using binary search algorithm. Array is expected to be sorted.
  */
-public fun LongArray.binarySearch(element: Long, fromIndex: Int = 0, toIndex: Int = size - 1) : Int {
+public fun LongArray.binarySearch(element: Long, fromIndex: Int = 0, toIndex: Int = size - 1): Int {
     return Arrays.binarySearch(this, fromIndex, toIndex, element)
 }
 
 /**
  * Searches array or range of array for provided element index using binary search algorithm. Array is expected to be sorted.
  */
-public fun ShortArray.binarySearch(element: Short, fromIndex: Int = 0, toIndex: Int = size - 1) : Int {
+public fun ShortArray.binarySearch(element: Short, fromIndex: Int = 0, toIndex: Int = size - 1): Int {
     return Arrays.binarySearch(this, fromIndex, toIndex, element)
 }
 
 /**
  * Returns new array which is a copy of the original array
  */
-public fun <T> Array<out T>.copyOf() : Array<T> {
+public fun <T> Array<out T>.copyOf(): Array<T> {
     return Arrays.copyOf(this, size) as Array<T>
 }
 
 /**
  * Returns new array which is a copy of the original array
  */
-public fun BooleanArray.copyOf() : BooleanArray {
+public fun BooleanArray.copyOf(): BooleanArray {
     return Arrays.copyOf(this, size)
 }
 
 /**
  * Returns new array which is a copy of the original array
  */
-public fun ByteArray.copyOf() : ByteArray {
+public fun ByteArray.copyOf(): ByteArray {
     return Arrays.copyOf(this, size)
 }
 
 /**
  * Returns new array which is a copy of the original array
  */
-public fun CharArray.copyOf() : CharArray {
+public fun CharArray.copyOf(): CharArray {
     return Arrays.copyOf(this, size)
 }
 
 /**
  * Returns new array which is a copy of the original array
  */
-public fun DoubleArray.copyOf() : DoubleArray {
+public fun DoubleArray.copyOf(): DoubleArray {
     return Arrays.copyOf(this, size)
 }
 
 /**
  * Returns new array which is a copy of the original array
  */
-public fun FloatArray.copyOf() : FloatArray {
+public fun FloatArray.copyOf(): FloatArray {
     return Arrays.copyOf(this, size)
 }
 
 /**
  * Returns new array which is a copy of the original array
  */
-public fun IntArray.copyOf() : IntArray {
+public fun IntArray.copyOf(): IntArray {
     return Arrays.copyOf(this, size)
 }
 
 /**
  * Returns new array which is a copy of the original array
  */
-public fun LongArray.copyOf() : LongArray {
+public fun LongArray.copyOf(): LongArray {
     return Arrays.copyOf(this, size)
 }
 
 /**
  * Returns new array which is a copy of the original array
  */
-public fun ShortArray.copyOf() : ShortArray {
+public fun ShortArray.copyOf(): ShortArray {
     return Arrays.copyOf(this, size)
 }
 
 /**
  * Returns new array which is a copy of the original array
  */
-public fun <T> Array<out T>.copyOf(newSize: Int) : Array<T?> {
+public fun <T> Array<out T>.copyOf(newSize: Int): Array<T?> {
     return Arrays.copyOf(this, newSize) as Array<T?>
 }
 
 /**
  * Returns new array which is a copy of the original array
  */
-public fun BooleanArray.copyOf(newSize: Int) : BooleanArray {
+public fun BooleanArray.copyOf(newSize: Int): BooleanArray {
     return Arrays.copyOf(this, newSize)
 }
 
 /**
  * Returns new array which is a copy of the original array
  */
-public fun ByteArray.copyOf(newSize: Int) : ByteArray {
+public fun ByteArray.copyOf(newSize: Int): ByteArray {
     return Arrays.copyOf(this, newSize)
 }
 
 /**
  * Returns new array which is a copy of the original array
  */
-public fun CharArray.copyOf(newSize: Int) : CharArray {
+public fun CharArray.copyOf(newSize: Int): CharArray {
     return Arrays.copyOf(this, newSize)
 }
 
 /**
  * Returns new array which is a copy of the original array
  */
-public fun DoubleArray.copyOf(newSize: Int) : DoubleArray {
+public fun DoubleArray.copyOf(newSize: Int): DoubleArray {
     return Arrays.copyOf(this, newSize)
 }
 
 /**
  * Returns new array which is a copy of the original array
  */
-public fun FloatArray.copyOf(newSize: Int) : FloatArray {
+public fun FloatArray.copyOf(newSize: Int): FloatArray {
     return Arrays.copyOf(this, newSize)
 }
 
 /**
  * Returns new array which is a copy of the original array
  */
-public fun IntArray.copyOf(newSize: Int) : IntArray {
+public fun IntArray.copyOf(newSize: Int): IntArray {
     return Arrays.copyOf(this, newSize)
 }
 
 /**
  * Returns new array which is a copy of the original array
  */
-public fun LongArray.copyOf(newSize: Int) : LongArray {
+public fun LongArray.copyOf(newSize: Int): LongArray {
     return Arrays.copyOf(this, newSize)
 }
 
 /**
  * Returns new array which is a copy of the original array
  */
-public fun ShortArray.copyOf(newSize: Int) : ShortArray {
+public fun ShortArray.copyOf(newSize: Int): ShortArray {
     return Arrays.copyOf(this, newSize)
 }
 
 /**
  * Returns new array which is a copy of range of original array
  */
-public fun <T> Array<out T>.copyOfRange(from: Int, to: Int) : Array<T> {
+public fun <T> Array<out T>.copyOfRange(from: Int, to: Int): Array<T> {
     return Arrays.copyOfRange(this, from, to)
 }
 
 /**
  * Returns new array which is a copy of range of original array
  */
-public fun BooleanArray.copyOfRange(from: Int, to: Int) : BooleanArray {
+public fun BooleanArray.copyOfRange(from: Int, to: Int): BooleanArray {
     return Arrays.copyOfRange(this, from, to)
 }
 
 /**
  * Returns new array which is a copy of range of original array
  */
-public fun ByteArray.copyOfRange(from: Int, to: Int) : ByteArray {
+public fun ByteArray.copyOfRange(from: Int, to: Int): ByteArray {
     return Arrays.copyOfRange(this, from, to)
 }
 
 /**
  * Returns new array which is a copy of range of original array
  */
-public fun CharArray.copyOfRange(from: Int, to: Int) : CharArray {
+public fun CharArray.copyOfRange(from: Int, to: Int): CharArray {
     return Arrays.copyOfRange(this, from, to)
 }
 
 /**
  * Returns new array which is a copy of range of original array
  */
-public fun DoubleArray.copyOfRange(from: Int, to: Int) : DoubleArray {
+public fun DoubleArray.copyOfRange(from: Int, to: Int): DoubleArray {
     return Arrays.copyOfRange(this, from, to)
 }
 
 /**
  * Returns new array which is a copy of range of original array
  */
-public fun FloatArray.copyOfRange(from: Int, to: Int) : FloatArray {
+public fun FloatArray.copyOfRange(from: Int, to: Int): FloatArray {
     return Arrays.copyOfRange(this, from, to)
 }
 
 /**
  * Returns new array which is a copy of range of original array
  */
-public fun IntArray.copyOfRange(from: Int, to: Int) : IntArray {
+public fun IntArray.copyOfRange(from: Int, to: Int): IntArray {
     return Arrays.copyOfRange(this, from, to)
 }
 
 /**
  * Returns new array which is a copy of range of original array
  */
-public fun LongArray.copyOfRange(from: Int, to: Int) : LongArray {
+public fun LongArray.copyOfRange(from: Int, to: Int): LongArray {
     return Arrays.copyOfRange(this, from, to)
 }
 
 /**
  * Returns new array which is a copy of range of original array
  */
-public fun ShortArray.copyOfRange(from: Int, to: Int) : ShortArray {
+public fun ShortArray.copyOfRange(from: Int, to: Int): ShortArray {
     return Arrays.copyOfRange(this, from, to)
 }
 
 /**
  * Fills original array with the provided value
  */
-public fun <T> Array<out T>.fill(element: T) : Array<out T> {
+public fun <T> Array<out T>.fill(element: T): Array<out T> {
     Arrays.fill(this, element)
     return this
-    
 }
 
 /**
  * Fills original array with the provided value
  */
-public fun BooleanArray.fill(element: Boolean) : BooleanArray {
+public fun BooleanArray.fill(element: Boolean): BooleanArray {
     Arrays.fill(this, element)
     return this
-    
 }
 
 /**
  * Fills original array with the provided value
  */
-public fun ByteArray.fill(element: Byte) : ByteArray {
+public fun ByteArray.fill(element: Byte): ByteArray {
     Arrays.fill(this, element)
     return this
-    
 }
 
 /**
  * Fills original array with the provided value
  */
-public fun CharArray.fill(element: Char) : CharArray {
+public fun CharArray.fill(element: Char): CharArray {
     Arrays.fill(this, element)
     return this
-    
 }
 
 /**
  * Fills original array with the provided value
  */
-public fun DoubleArray.fill(element: Double) : DoubleArray {
+public fun DoubleArray.fill(element: Double): DoubleArray {
     Arrays.fill(this, element)
     return this
-    
 }
 
 /**
  * Fills original array with the provided value
  */
-public fun FloatArray.fill(element: Float) : FloatArray {
+public fun FloatArray.fill(element: Float): FloatArray {
     Arrays.fill(this, element)
     return this
-    
 }
 
 /**
  * Fills original array with the provided value
  */
-public fun IntArray.fill(element: Int) : IntArray {
+public fun IntArray.fill(element: Int): IntArray {
     Arrays.fill(this, element)
     return this
-    
 }
 
 /**
  * Fills original array with the provided value
  */
-public fun LongArray.fill(element: Long) : LongArray {
+public fun LongArray.fill(element: Long): LongArray {
     Arrays.fill(this, element)
     return this
-    
 }
 
 /**
  * Fills original array with the provided value
  */
-public fun ShortArray.fill(element: Short) : ShortArray {
+public fun ShortArray.fill(element: Short): ShortArray {
     Arrays.fill(this, element)
     return this
-    
 }
 
 /**
  * Returns a list containing all elements that are instances of specified class
  */
-public fun <T, R: T> Array<out T>.filterIsInstance(klass: Class<R>) : List<R> {
+public fun <T, R : T> Array<out T>.filterIsInstance(klass: Class<R>): List<R> {
     return filterIsInstanceTo(ArrayList<R>(), klass)
-    
 }
 
 /**
  * Returns a list containing all elements that are instances of specified class
  */
-public fun <T, R: T> Iterable<T>.filterIsInstance(klass: Class<R>) : List<R> {
+public fun <T, R : T> Iterable<T>.filterIsInstance(klass: Class<R>): List<R> {
     return filterIsInstanceTo(ArrayList<R>(), klass)
-    
 }
 
 /**
  * Returns a stream containing all elements that are instances of specified class
  */
-public fun <T, R: T> Stream<T>.filterIsInstance(klass: Class<R>) : Stream<T> {
+public fun <T, R : T> Stream<T>.filterIsInstance(klass: Class<R>): Stream<T> {
     return FilteringStream(this, true, { klass.isInstance(it) })
-    
 }
 
 /**
  * Returns a list containing all elements that are instances of specified class
  */
-public fun <R: Char> String.filterIsInstance(klass: Class<R>) : List<R> {
+public fun <R : Char> String.filterIsInstance(klass: Class<R>): List<R> {
     return filterIsInstanceTo(ArrayList<R>(), klass)
-    
 }
 
 /**
  * Appends all elements that are instances of specified class into the given *collection*
  */
-public fun <T, C: MutableCollection<in R>, R: T> Array<out T>.filterIsInstanceTo(collection: C, klass: Class<R>) : C {
+public fun <T, C : MutableCollection<in R>, R : T> Array<out T>.filterIsInstanceTo(collection: C, klass: Class<R>): C {
     for (element in this) if (klass.isInstance(element)) collection.add(element as R)
     return collection
-    
 }
 
 /**
  * Appends all elements that are instances of specified class into the given *collection*
  */
-public fun <T, C: MutableCollection<in R>, R: T> Iterable<T>.filterIsInstanceTo(collection: C, klass: Class<R>) : C {
+public fun <T, C : MutableCollection<in R>, R : T> Iterable<T>.filterIsInstanceTo(collection: C, klass: Class<R>): C {
     for (element in this) if (klass.isInstance(element)) collection.add(element as R)
     return collection
-    
 }
 
 /**
  * Appends all elements that are instances of specified class into the given *collection*
  */
-public fun <T, C: MutableCollection<in R>, R: T> Stream<T>.filterIsInstanceTo(collection: C, klass: Class<R>) : C {
+public fun <T, C : MutableCollection<in R>, R : T> Stream<T>.filterIsInstanceTo(collection: C, klass: Class<R>): C {
     for (element in this) if (klass.isInstance(element)) collection.add(element as R)
     return collection
-    
 }
 
 /**
  * Appends all elements that are instances of specified class into the given *collection*
  */
-public fun <C: MutableCollection<in R>, R: Char> String.filterIsInstanceTo(collection: C, klass: Class<R>) : C {
+public fun <C : MutableCollection<in R>, R : Char> String.filterIsInstanceTo(collection: C, klass: Class<R>): C {
     for (element in this) if (klass.isInstance(element)) collection.add(element as R)
     return collection
-    
 }
 
 /**
  * Sorts array or range in array inplace
  */
-public fun <T> Array<out T>.sort(fromIndex : Int = 0, toIndex : Int = size - 1) : Unit {
+public fun <T> Array<out T>.sort(fromIndex: Int = 0, toIndex: Int = size - 1): Unit {
     Arrays.sort(this, fromIndex, toIndex)
 }
 
 /**
  * Sorts array or range in array inplace
  */
-public fun ByteArray.sort(fromIndex : Int = 0, toIndex : Int = size - 1) : Unit {
+public fun ByteArray.sort(fromIndex: Int = 0, toIndex: Int = size - 1): Unit {
     Arrays.sort(this, fromIndex, toIndex)
 }
 
 /**
  * Sorts array or range in array inplace
  */
-public fun CharArray.sort(fromIndex : Int = 0, toIndex : Int = size - 1) : Unit {
+public fun CharArray.sort(fromIndex: Int = 0, toIndex: Int = size - 1): Unit {
     Arrays.sort(this, fromIndex, toIndex)
 }
 
 /**
  * Sorts array or range in array inplace
  */
-public fun DoubleArray.sort(fromIndex : Int = 0, toIndex : Int = size - 1) : Unit {
+public fun DoubleArray.sort(fromIndex: Int = 0, toIndex: Int = size - 1): Unit {
     Arrays.sort(this, fromIndex, toIndex)
 }
 
 /**
  * Sorts array or range in array inplace
  */
-public fun FloatArray.sort(fromIndex : Int = 0, toIndex : Int = size - 1) : Unit {
+public fun FloatArray.sort(fromIndex: Int = 0, toIndex: Int = size - 1): Unit {
     Arrays.sort(this, fromIndex, toIndex)
 }
 
 /**
  * Sorts array or range in array inplace
  */
-public fun IntArray.sort(fromIndex : Int = 0, toIndex : Int = size - 1) : Unit {
+public fun IntArray.sort(fromIndex: Int = 0, toIndex: Int = size - 1): Unit {
     Arrays.sort(this, fromIndex, toIndex)
 }
 
 /**
  * Sorts array or range in array inplace
  */
-public fun LongArray.sort(fromIndex : Int = 0, toIndex : Int = size - 1) : Unit {
+public fun LongArray.sort(fromIndex: Int = 0, toIndex: Int = size - 1): Unit {
     Arrays.sort(this, fromIndex, toIndex)
 }
 
 /**
  * Sorts array or range in array inplace
  */
-public fun ShortArray.sort(fromIndex : Int = 0, toIndex : Int = size - 1) : Unit {
+public fun ShortArray.sort(fromIndex: Int = 0, toIndex: Int = size - 1): Unit {
     Arrays.sort(this, fromIndex, toIndex)
 }
 
diff --git a/libraries/stdlib/src/generated/_Streams.kt b/libraries/stdlib/src/generated/_Streams.kt
index 28b4e1b0866..a34d1126e67 100644
--- a/libraries/stdlib/src/generated/_Streams.kt
+++ b/libraries/stdlib/src/generated/_Streams.kt
@@ -10,96 +10,128 @@ import java.util.*
 /**
  * Returns a stream from the given collection
  */
-public fun <T> Array<out T>.stream() : Stream<T> {
-    return object : Stream<T> { override fun iterator() : Iterator<T> { return this@stream.iterator() } }
-    
+public fun <T> Array<out T>.stream(): Stream<T> {
+    return object : Stream<T> {
+        override fun iterator(): Iterator<T> {
+            return this@stream.iterator()
+        }
+    }
 }
 
 /**
  * Returns a stream from the given collection
  */
-public fun BooleanArray.stream() : Stream<Boolean> {
-    return object : Stream<Boolean> { override fun iterator() : Iterator<Boolean> { return this@stream.iterator() } }
-    
+public fun BooleanArray.stream(): Stream<Boolean> {
+    return object : Stream<Boolean> {
+        override fun iterator(): Iterator<Boolean> {
+            return this@stream.iterator()
+        }
+    }
 }
 
 /**
  * Returns a stream from the given collection
  */
-public fun ByteArray.stream() : Stream<Byte> {
-    return object : Stream<Byte> { override fun iterator() : Iterator<Byte> { return this@stream.iterator() } }
-    
+public fun ByteArray.stream(): Stream<Byte> {
+    return object : Stream<Byte> {
+        override fun iterator(): Iterator<Byte> {
+            return this@stream.iterator()
+        }
+    }
 }
 
 /**
  * Returns a stream from the given collection
  */
-public fun CharArray.stream() : Stream<Char> {
-    return object : Stream<Char> { override fun iterator() : Iterator<Char> { return this@stream.iterator() } }
-    
+public fun CharArray.stream(): Stream<Char> {
+    return object : Stream<Char> {
+        override fun iterator(): Iterator<Char> {
+            return this@stream.iterator()
+        }
+    }
 }
 
 /**
  * Returns a stream from the given collection
  */
-public fun DoubleArray.stream() : Stream<Double> {
-    return object : Stream<Double> { override fun iterator() : Iterator<Double> { return this@stream.iterator() } }
-    
+public fun DoubleArray.stream(): Stream<Double> {
+    return object : Stream<Double> {
+        override fun iterator(): Iterator<Double> {
+            return this@stream.iterator()
+        }
+    }
 }
 
 /**
  * Returns a stream from the given collection
  */
-public fun FloatArray.stream() : Stream<Float> {
-    return object : Stream<Float> { override fun iterator() : Iterator<Float> { return this@stream.iterator() } }
-    
+public fun FloatArray.stream(): Stream<Float> {
+    return object : Stream<Float> {
+        override fun iterator(): Iterator<Float> {
+            return this@stream.iterator()
+        }
+    }
 }
 
 /**
  * Returns a stream from the given collection
  */
-public fun IntArray.stream() : Stream<Int> {
-    return object : Stream<Int> { override fun iterator() : Iterator<Int> { return this@stream.iterator() } }
-    
+public fun IntArray.stream(): Stream<Int> {
+    return object : Stream<Int> {
+        override fun iterator(): Iterator<Int> {
+            return this@stream.iterator()
+        }
+    }
 }
 
 /**
  * Returns a stream from the given collection
  */
-public fun LongArray.stream() : Stream<Long> {
-    return object : Stream<Long> { override fun iterator() : Iterator<Long> { return this@stream.iterator() } }
-    
+public fun LongArray.stream(): Stream<Long> {
+    return object : Stream<Long> {
+        override fun iterator(): Iterator<Long> {
+            return this@stream.iterator()
+        }
+    }
 }
 
 /**
  * Returns a stream from the given collection
  */
-public fun ShortArray.stream() : Stream<Short> {
-    return object : Stream<Short> { override fun iterator() : Iterator<Short> { return this@stream.iterator() } }
-    
+public fun ShortArray.stream(): Stream<Short> {
+    return object : Stream<Short> {
+        override fun iterator(): Iterator<Short> {
+            return this@stream.iterator()
+        }
+    }
 }
 
 /**
  * Returns a stream from the given collection
  */
-public fun <T> Iterable<T>.stream() : Stream<T> {
-    return object : Stream<T> { override fun iterator() : Iterator<T> { return this@stream.iterator() } }
-    
+public fun <T> Iterable<T>.stream(): Stream<T> {
+    return object : Stream<T> {
+        override fun iterator(): Iterator<T> {
+            return this@stream.iterator()
+        }
+    }
 }
 
 /**
  * Returns a stream from the given collection
  */
-public fun <T> Stream<T>.stream() : Stream<T> {
+public fun <T> Stream<T>.stream(): Stream<T> {
     return this
-    
 }
 
 /**
  * Returns a stream from the given collection
  */
-public fun String.stream() : Stream<Char> {
-    return object : Stream<Char> { override fun iterator() : Iterator<Char> { return this@stream.iterator() } }
-    
+public fun String.stream(): Stream<Char> {
+    return object : Stream<Char> {
+        override fun iterator(): Iterator<Char> {
+            return this@stream.iterator()
+        }
+    }
 }
 
diff --git a/libraries/stdlib/src/generated/_Strings.kt b/libraries/stdlib/src/generated/_Strings.kt
index 8e45c36f041..fdec0449afb 100644
--- a/libraries/stdlib/src/generated/_Strings.kt
+++ b/libraries/stdlib/src/generated/_Strings.kt
@@ -12,7 +12,7 @@ import java.util.*
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun <T> Array<out T>.appendString(buffer: Appendable, separator: String = ", ", prefix: String ="", postfix: String = "", limit: Int = -1, truncated: String = "...") : Unit {
+public fun <T> Array<out T>.appendString(buffer: Appendable, separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): Unit {
     buffer.append(prefix)
     var count = 0
     for (element in this) {
@@ -24,7 +24,6 @@ public fun <T> Array<out T>.appendString(buffer: Appendable, separator: String =
     }
     if (limit >= 0 && count > limit) buffer.append(truncated)
     buffer.append(postfix)
-    
 }
 
 /**
@@ -32,7 +31,7 @@ public fun <T> Array<out T>.appendString(buffer: Appendable, separator: String =
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun BooleanArray.appendString(buffer: Appendable, separator: String = ", ", prefix: String ="", postfix: String = "", limit: Int = -1, truncated: String = "...") : Unit {
+public fun BooleanArray.appendString(buffer: Appendable, separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): Unit {
     buffer.append(prefix)
     var count = 0
     for (element in this) {
@@ -44,7 +43,6 @@ public fun BooleanArray.appendString(buffer: Appendable, separator: String = ",
     }
     if (limit >= 0 && count > limit) buffer.append(truncated)
     buffer.append(postfix)
-    
 }
 
 /**
@@ -52,7 +50,7 @@ public fun BooleanArray.appendString(buffer: Appendable, separator: String = ",
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun ByteArray.appendString(buffer: Appendable, separator: String = ", ", prefix: String ="", postfix: String = "", limit: Int = -1, truncated: String = "...") : Unit {
+public fun ByteArray.appendString(buffer: Appendable, separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): Unit {
     buffer.append(prefix)
     var count = 0
     for (element in this) {
@@ -64,7 +62,6 @@ public fun ByteArray.appendString(buffer: Appendable, separator: String = ", ",
     }
     if (limit >= 0 && count > limit) buffer.append(truncated)
     buffer.append(postfix)
-    
 }
 
 /**
@@ -72,7 +69,7 @@ public fun ByteArray.appendString(buffer: Appendable, separator: String = ", ",
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun CharArray.appendString(buffer: Appendable, separator: String = ", ", prefix: String ="", postfix: String = "", limit: Int = -1, truncated: String = "...") : Unit {
+public fun CharArray.appendString(buffer: Appendable, separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): Unit {
     buffer.append(prefix)
     var count = 0
     for (element in this) {
@@ -84,7 +81,6 @@ public fun CharArray.appendString(buffer: Appendable, separator: String = ", ",
     }
     if (limit >= 0 && count > limit) buffer.append(truncated)
     buffer.append(postfix)
-    
 }
 
 /**
@@ -92,7 +88,7 @@ public fun CharArray.appendString(buffer: Appendable, separator: String = ", ",
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun DoubleArray.appendString(buffer: Appendable, separator: String = ", ", prefix: String ="", postfix: String = "", limit: Int = -1, truncated: String = "...") : Unit {
+public fun DoubleArray.appendString(buffer: Appendable, separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): Unit {
     buffer.append(prefix)
     var count = 0
     for (element in this) {
@@ -104,7 +100,6 @@ public fun DoubleArray.appendString(buffer: Appendable, separator: String = ", "
     }
     if (limit >= 0 && count > limit) buffer.append(truncated)
     buffer.append(postfix)
-    
 }
 
 /**
@@ -112,7 +107,7 @@ public fun DoubleArray.appendString(buffer: Appendable, separator: String = ", "
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun FloatArray.appendString(buffer: Appendable, separator: String = ", ", prefix: String ="", postfix: String = "", limit: Int = -1, truncated: String = "...") : Unit {
+public fun FloatArray.appendString(buffer: Appendable, separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): Unit {
     buffer.append(prefix)
     var count = 0
     for (element in this) {
@@ -124,7 +119,6 @@ public fun FloatArray.appendString(buffer: Appendable, separator: String = ", ",
     }
     if (limit >= 0 && count > limit) buffer.append(truncated)
     buffer.append(postfix)
-    
 }
 
 /**
@@ -132,7 +126,7 @@ public fun FloatArray.appendString(buffer: Appendable, separator: String = ", ",
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun IntArray.appendString(buffer: Appendable, separator: String = ", ", prefix: String ="", postfix: String = "", limit: Int = -1, truncated: String = "...") : Unit {
+public fun IntArray.appendString(buffer: Appendable, separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): Unit {
     buffer.append(prefix)
     var count = 0
     for (element in this) {
@@ -144,7 +138,6 @@ public fun IntArray.appendString(buffer: Appendable, separator: String = ", ", p
     }
     if (limit >= 0 && count > limit) buffer.append(truncated)
     buffer.append(postfix)
-    
 }
 
 /**
@@ -152,7 +145,7 @@ public fun IntArray.appendString(buffer: Appendable, separator: String = ", ", p
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun LongArray.appendString(buffer: Appendable, separator: String = ", ", prefix: String ="", postfix: String = "", limit: Int = -1, truncated: String = "...") : Unit {
+public fun LongArray.appendString(buffer: Appendable, separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): Unit {
     buffer.append(prefix)
     var count = 0
     for (element in this) {
@@ -164,7 +157,6 @@ public fun LongArray.appendString(buffer: Appendable, separator: String = ", ",
     }
     if (limit >= 0 && count > limit) buffer.append(truncated)
     buffer.append(postfix)
-    
 }
 
 /**
@@ -172,7 +164,7 @@ public fun LongArray.appendString(buffer: Appendable, separator: String = ", ",
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun ShortArray.appendString(buffer: Appendable, separator: String = ", ", prefix: String ="", postfix: String = "", limit: Int = -1, truncated: String = "...") : Unit {
+public fun ShortArray.appendString(buffer: Appendable, separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): Unit {
     buffer.append(prefix)
     var count = 0
     for (element in this) {
@@ -184,7 +176,6 @@ public fun ShortArray.appendString(buffer: Appendable, separator: String = ", ",
     }
     if (limit >= 0 && count > limit) buffer.append(truncated)
     buffer.append(postfix)
-    
 }
 
 /**
@@ -192,7 +183,7 @@ public fun ShortArray.appendString(buffer: Appendable, separator: String = ", ",
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun <T> Iterable<T>.appendString(buffer: Appendable, separator: String = ", ", prefix: String ="", postfix: String = "", limit: Int = -1, truncated: String = "...") : Unit {
+public fun <T> Iterable<T>.appendString(buffer: Appendable, separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): Unit {
     buffer.append(prefix)
     var count = 0
     for (element in this) {
@@ -204,7 +195,6 @@ public fun <T> Iterable<T>.appendString(buffer: Appendable, separator: String =
     }
     if (limit >= 0 && count > limit) buffer.append(truncated)
     buffer.append(postfix)
-    
 }
 
 /**
@@ -212,7 +202,7 @@ public fun <T> Iterable<T>.appendString(buffer: Appendable, separator: String =
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun <T> Stream<T>.appendString(buffer: Appendable, separator: String = ", ", prefix: String ="", postfix: String = "", limit: Int = -1, truncated: String = "...") : Unit {
+public fun <T> Stream<T>.appendString(buffer: Appendable, separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): Unit {
     buffer.append(prefix)
     var count = 0
     for (element in this) {
@@ -224,7 +214,6 @@ public fun <T> Stream<T>.appendString(buffer: Appendable, separator: String = ",
     }
     if (limit >= 0 && count > limit) buffer.append(truncated)
     buffer.append(postfix)
-    
 }
 
 /**
@@ -232,7 +221,7 @@ public fun <T> Stream<T>.appendString(buffer: Appendable, separator: String = ",
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun String.appendString(buffer: Appendable, separator: String = ", ", prefix: String ="", postfix: String = "", limit: Int = -1, truncated: String = "...") : Unit {
+public fun String.appendString(buffer: Appendable, separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): Unit {
     buffer.append(prefix)
     var count = 0
     for (element in this) {
@@ -244,7 +233,6 @@ public fun String.appendString(buffer: Appendable, separator: String = ", ", pre
     }
     if (limit >= 0 && count > limit) buffer.append(truncated)
     buffer.append(postfix)
-    
 }
 
 /**
@@ -252,11 +240,10 @@ public fun String.appendString(buffer: Appendable, separator: String = ", ", pre
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun <T> Array<out T>.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "...") : String {
+public fun <T> Array<out T>.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): String {
     val buffer = StringBuilder()
     appendString(buffer, separator, prefix, postfix, limit, truncated)
     return buffer.toString()
-    
 }
 
 /**
@@ -264,11 +251,10 @@ public fun <T> Array<out T>.makeString(separator: String = ", ", prefix: String
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun BooleanArray.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "...") : String {
+public fun BooleanArray.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): String {
     val buffer = StringBuilder()
     appendString(buffer, separator, prefix, postfix, limit, truncated)
     return buffer.toString()
-    
 }
 
 /**
@@ -276,11 +262,10 @@ public fun BooleanArray.makeString(separator: String = ", ", prefix: String = ""
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun ByteArray.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "...") : String {
+public fun ByteArray.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): String {
     val buffer = StringBuilder()
     appendString(buffer, separator, prefix, postfix, limit, truncated)
     return buffer.toString()
-    
 }
 
 /**
@@ -288,11 +273,10 @@ public fun ByteArray.makeString(separator: String = ", ", prefix: String = "", p
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun CharArray.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "...") : String {
+public fun CharArray.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): String {
     val buffer = StringBuilder()
     appendString(buffer, separator, prefix, postfix, limit, truncated)
     return buffer.toString()
-    
 }
 
 /**
@@ -300,11 +284,10 @@ public fun CharArray.makeString(separator: String = ", ", prefix: String = "", p
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun DoubleArray.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "...") : String {
+public fun DoubleArray.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): String {
     val buffer = StringBuilder()
     appendString(buffer, separator, prefix, postfix, limit, truncated)
     return buffer.toString()
-    
 }
 
 /**
@@ -312,11 +295,10 @@ public fun DoubleArray.makeString(separator: String = ", ", prefix: String = "",
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun FloatArray.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "...") : String {
+public fun FloatArray.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): String {
     val buffer = StringBuilder()
     appendString(buffer, separator, prefix, postfix, limit, truncated)
     return buffer.toString()
-    
 }
 
 /**
@@ -324,11 +306,10 @@ public fun FloatArray.makeString(separator: String = ", ", prefix: String = "",
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun IntArray.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "...") : String {
+public fun IntArray.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): String {
     val buffer = StringBuilder()
     appendString(buffer, separator, prefix, postfix, limit, truncated)
     return buffer.toString()
-    
 }
 
 /**
@@ -336,11 +317,10 @@ public fun IntArray.makeString(separator: String = ", ", prefix: String = "", po
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun LongArray.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "...") : String {
+public fun LongArray.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): String {
     val buffer = StringBuilder()
     appendString(buffer, separator, prefix, postfix, limit, truncated)
     return buffer.toString()
-    
 }
 
 /**
@@ -348,11 +328,10 @@ public fun LongArray.makeString(separator: String = ", ", prefix: String = "", p
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun ShortArray.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "...") : String {
+public fun ShortArray.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): String {
     val buffer = StringBuilder()
     appendString(buffer, separator, prefix, postfix, limit, truncated)
     return buffer.toString()
-    
 }
 
 /**
@@ -360,11 +339,10 @@ public fun ShortArray.makeString(separator: String = ", ", prefix: String = "",
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun <T> Iterable<T>.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "...") : String {
+public fun <T> Iterable<T>.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): String {
     val buffer = StringBuilder()
     appendString(buffer, separator, prefix, postfix, limit, truncated)
     return buffer.toString()
-    
 }
 
 /**
@@ -372,11 +350,10 @@ public fun <T> Iterable<T>.makeString(separator: String = ", ", prefix: String =
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun <T> Stream<T>.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "...") : String {
+public fun <T> Stream<T>.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): String {
     val buffer = StringBuilder()
     appendString(buffer, separator, prefix, postfix, limit, truncated)
     return buffer.toString()
-    
 }
 
 /**
@@ -384,10 +361,9 @@ public fun <T> Stream<T>.makeString(separator: String = ", ", prefix: String = "
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
  * a special *truncated* separator (which defaults to "..."
  */
-public fun String.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "...") : String {
+public fun String.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "..."): String {
     val buffer = StringBuilder()
     appendString(buffer, separator, prefix, postfix, limit, truncated)
     return buffer.toString()
-    
 }
 
diff --git a/libraries/tools/kotlin-stdlib-gen/src/generators/GenerateCollections.kt b/libraries/tools/kotlin-stdlib-gen/src/generators/GenerateCollections.kt
index c76b1cbb71a..2e43193bbd4 100644
--- a/libraries/tools/kotlin-stdlib-gen/src/generators/GenerateCollections.kt
+++ b/libraries/tools/kotlin-stdlib-gen/src/generators/GenerateCollections.kt
@@ -5,12 +5,12 @@ import templates.Family.*
 import templates.*
 import templates.PrimitiveType.*
 
-fun generateCollectionsAPI(outDir : File) {
+fun generateCollectionsAPI(outDir: File) {
     elements().writeTo(File(outDir, "_Elements.kt")) { build() }
     filtering().writeTo(File(outDir, "_Filtering.kt")) { build() }
     ordering().writeTo(File(outDir, "_Ordering.kt")) { build() }
     arrays().writeTo(File(outDir, "_Arrays.kt")) { build() }
-    snapshots().writeTo(File(outDir, "_Snapshots.kt"))  { build() }
+    snapshots().writeTo(File(outDir, "_Snapshots.kt")) { build() }
     mapping().writeTo(File(outDir, "_Mapping.kt")) { build() }
     aggregates().writeTo(File(outDir, "_Aggregates.kt")) { build() }
     guards().writeTo(File(outDir, "_Guards.kt")) { build() }
@@ -22,11 +22,11 @@ fun generateCollectionsAPI(outDir : File) {
     numeric().writeTo(File(outDir, "_Numeric.kt")) {
         val builder = StringBuilder()
         // TODO: decide if sum for byte and short is needed and how to make it work
-        for(numeric in listOf(Int, Long, /*Byte, Short, */ Double, Float)) {
+        for (numeric in listOf(Int, Long, /*Byte, Short, */ Double, Float)) {
             build(builder, Iterables, numeric)
         }
 
-        for(numeric in listOf(Int, Long, Byte, Short,  Double, Float)) {
+        for (numeric in listOf(Int, Long, Byte, Short, Double, Float)) {
             build(builder, ArraysOfObjects, numeric)
             build(builder, ArraysOfPrimitives, numeric)
         }
diff --git a/libraries/tools/kotlin-stdlib-gen/src/templates/Aggregates.kt b/libraries/tools/kotlin-stdlib-gen/src/templates/Aggregates.kt
index a9df46dace4..208cde44757 100644
--- a/libraries/tools/kotlin-stdlib-gen/src/templates/Aggregates.kt
+++ b/libraries/tools/kotlin-stdlib-gen/src/templates/Aggregates.kt
@@ -104,7 +104,7 @@ fun aggregates(): List<GenericFunction> {
         doc { "Returns the smallest element or null if there are no elements" }
         returns("T?")
         exclude(PrimitiveType.Boolean)
-        typeParam("T: Comparable<T>")
+        typeParam("T : Comparable<T>")
         body {
             """
             val iterator = iterator()
@@ -135,8 +135,8 @@ fun aggregates(): List<GenericFunction> {
         inline(true)
 
         doc { "Returns the first element yielding the smallest value of the given function or null if there are no elements" }
-        typeParam("R: Comparable<R>")
-        typeParam("T: Any")
+        typeParam("R : Comparable<R>")
+        typeParam("T : Any")
         returns("T?")
         body {
             """
@@ -149,8 +149,8 @@ fun aggregates(): List<GenericFunction> {
                 val e = iterator.next()
                 val v = f(e)
                 if (minValue > v) {
-                   minElem = e
-                   minValue = v
+                    minElem = e
+                    minValue = v
                 }
             }
             return minElem
@@ -166,8 +166,8 @@ fun aggregates(): List<GenericFunction> {
                 val e = this[i]
                 val v = f(e)
                 if (minValue > v) {
-                   minElem = e
-                   minValue = v
+                    minElem = e
+                    minValue = v
                 }
             }
             return minElem
@@ -180,7 +180,7 @@ fun aggregates(): List<GenericFunction> {
 
         only(Maps)
         doc { "Returns the first element yielding the smallest value of the given function or null if there are no elements" }
-        typeParam("R: Comparable<R>")
+        typeParam("R : Comparable<R>")
         returns("T?")
         body {
             """
@@ -193,8 +193,8 @@ fun aggregates(): List<GenericFunction> {
                 val e = iterator.next()
                 val v = f(e)
                 if (minValue > v) {
-                   minElem = e
-                   minValue = v
+                    minElem = e
+                    minValue = v
                 }
             }
             return minElem
@@ -206,7 +206,7 @@ fun aggregates(): List<GenericFunction> {
         doc { "Returns the largest element or null if there are no elements" }
         returns("T?")
         exclude(PrimitiveType.Boolean)
-        typeParam("T: Comparable<T>")
+        typeParam("T : Comparable<T>")
         body {
             """
             val iterator = iterator()
@@ -239,8 +239,8 @@ fun aggregates(): List<GenericFunction> {
         inline(true)
 
         doc { "Returns the first element yielding the largest value of the given function or null if there are no elements" }
-        typeParam("R: Comparable<R>")
-        typeParam("T: Any")
+        typeParam("R : Comparable<R>")
+        typeParam("T : Any")
         returns("T?")
         body {
             """
@@ -253,8 +253,8 @@ fun aggregates(): List<GenericFunction> {
                 val e = iterator.next()
                 val v = f(e)
                 if (maxValue < v) {
-                   maxElem = e
-                   maxValue = v
+                    maxElem = e
+                    maxValue = v
                 }
             }
             return maxElem
@@ -270,8 +270,8 @@ fun aggregates(): List<GenericFunction> {
                 val e = this[i]
                 val v = f(e)
                 if (maxValue < v) {
-                   maxElem = e
-                   maxValue = v
+                    maxElem = e
+                    maxValue = v
                 }
             }
             return maxElem
@@ -284,7 +284,7 @@ fun aggregates(): List<GenericFunction> {
 
         only(Maps)
         doc { "Returns the first element yielding the largest value of the given function or null if there are no elements" }
-        typeParam("R: Comparable<R>")
+        typeParam("R : Comparable<R>")
         returns("T?")
         body {
             """
@@ -297,8 +297,8 @@ fun aggregates(): List<GenericFunction> {
                 val e = iterator.next()
                 val v = f(e)
                 if (maxValue < v) {
-                   maxElem = e
-                   maxValue = v
+                    maxElem = e
+                    maxValue = v
                 }
             }
             return maxElem
diff --git a/libraries/tools/kotlin-stdlib-gen/src/templates/Elements.kt b/libraries/tools/kotlin-stdlib-gen/src/templates/Elements.kt
index f77a9a8a23f..58245648a62 100644
--- a/libraries/tools/kotlin-stdlib-gen/src/templates/Elements.kt
+++ b/libraries/tools/kotlin-stdlib-gen/src/templates/Elements.kt
@@ -116,7 +116,7 @@ fun elements(): List<GenericFunction> {
         }
     }
 
-    templates add f("elementAt(index : Int)") {
+    templates add f("elementAt(index: Int)") {
         doc { "Returns element at given *index*" }
         returns("T")
         body {
@@ -241,10 +241,12 @@ fun elements(): List<GenericFunction> {
         body {
             """
             when (this) {
-                is List<*> -> if (size == 0)
+                is List<*> -> {
+                    if (size == 0)
                         throw IllegalArgumentException("Collection is empty")
                     else
                         return this[size - 1] as T
+                }
                 else -> {
                     val iterator = iterator()
                     if (!iterator.hasNext())
diff --git a/libraries/tools/kotlin-stdlib-gen/src/templates/Engine.kt b/libraries/tools/kotlin-stdlib-gen/src/templates/Engine.kt
index deb83614e12..ef1fb5b59be 100644
--- a/libraries/tools/kotlin-stdlib-gen/src/templates/Engine.kt
+++ b/libraries/tools/kotlin-stdlib-gen/src/templates/Engine.kt
@@ -91,7 +91,7 @@ class GenericFunction(val signature: String) : Comparable<GenericFunction> {
         typeParams.add(t)
     }
 
-    fun inline(value : Boolean, vararg families: Family) {
+    fun inline(value: Boolean, vararg families: Family) {
         if (families.isEmpty())
             defaultInline = value
         else
@@ -148,7 +148,7 @@ class GenericFunction(val signature: String) : Comparable<GenericFunction> {
             Iterables -> "Iterable<T>"
             Collections -> "Collection<T>"
             Lists -> "List<T>"
-            Maps -> "Map<K,V>"
+            Maps -> "Map<K, V>"
             Streams -> "Stream<T>"
             ArraysOfObjects -> "Array<T>"
             Strings -> "String"
@@ -186,7 +186,7 @@ class GenericFunction(val signature: String) : Comparable<GenericFunction> {
                                   "T" -> {
                                       when (f) {
                                           Strings -> "Char"
-                                          Maps -> "Map.Entry<K,V>"
+                                          Maps -> "Map.Entry<K, V>"
                                           else -> primitive?.name() ?: token
                                       }
                                   }
@@ -200,7 +200,7 @@ class GenericFunction(val signature: String) : Comparable<GenericFunction> {
         fun effectiveTypeParams(): List<String> {
             val types = ArrayList(typeParams)
             if (primitive == null && f != Strings) {
-                val implicitTypeParameters = receiver.dropWhile { it != '<' }.drop(1).takeWhile { it != '>' }.split(",")
+                val implicitTypeParameters = receiver.dropWhile { it != '<' }.drop(1).filterNot { it == ' ' }.takeWhile { it != '>' }.split(",")
                 for (implicit in implicitTypeParameters.reverse()) {
                     if (!types.any { it.startsWith(implicit) }) {
                         types.add(0, implicit)
@@ -249,18 +249,21 @@ class GenericFunction(val signature: String) : Comparable<GenericFunction> {
 
 
         builder.append(receiverType)
-        builder.append(".${signature.renderType()} : ${returnType.renderType()} {")
+        builder.append(".${signature.renderType()}: ${returnType.renderType()} {")
 
         val body = (bodies[f] ?: defaultBody).trim("\n")
-        val prefix: Int = body.takeWhile { it == ' ' }.length
+        val indent: Int = body.takeWhile { it == ' ' }.length
 
+        builder.append('\n')
         StringReader(body).forEachLine {
-            builder.append('\n')
-            var count = prefix
-            builder.append("    ").append(it.dropWhile { count-- > 0 && it == ' ' } .renderType())
+            var count = indent
+            val line = it.dropWhile { count-- > 0 && it == ' ' } .renderType()
+            if (line.isNotEmpty()) {
+                builder.append("    ").append(line)
+                builder.append("\n")
+            }
         }
-
-        builder.append("\n}\n\n")
+        builder.append("}\n\n")
     }
 
     public override fun compareTo(other: GenericFunction): Int = this.signature.compareTo(other.signature)
diff --git a/libraries/tools/kotlin-stdlib-gen/src/templates/Filtering.kt b/libraries/tools/kotlin-stdlib-gen/src/templates/Filtering.kt
index f08090f38cc..a3dc1fcefc7 100644
--- a/libraries/tools/kotlin-stdlib-gen/src/templates/Filtering.kt
+++ b/libraries/tools/kotlin-stdlib-gen/src/templates/Filtering.kt
@@ -29,7 +29,7 @@ fun filtering(): List<GenericFunction> {
         }
 
         body(Strings) { "return substring(Math.min(n, size))" }
-        returns(Strings) { "String"}
+        returns(Strings) { "String" }
 
         body(Collections, ArraysOfObjects, ArraysOfPrimitives) {
             """
@@ -63,7 +63,7 @@ fun filtering(): List<GenericFunction> {
         }
 
         body(Strings) { "return substring(0, Math.min(n, size))" }
-        returns(Strings) { "String"}
+        returns(Strings) { "String" }
 
         doc(Streams) { "Returns a stream containing first *n* elements" }
         returns(Streams) { "Stream<T>" }
@@ -90,7 +90,7 @@ fun filtering(): List<GenericFunction> {
         }
     }
 
-    templates add f("dropWhile(predicate: (T)->Boolean)") {
+    templates add f("dropWhile(predicate: (T) -> Boolean)") {
         inline(true)
 
         doc { "Returns a list containing all elements except first elements that satisfy the given *predicate*" }
@@ -102,7 +102,7 @@ fun filtering(): List<GenericFunction> {
             for (item in this)
                 if (yielding)
                     list.add(item)
-                else if(!predicate(item)) {
+                else if (!predicate(item)) {
                     list.add(item)
                     yielding = true
                 }
@@ -110,7 +110,7 @@ fun filtering(): List<GenericFunction> {
             """
         }
 
-        returns(Strings) { "String"}
+        returns(Strings) { "String" }
         body(Strings) {
             """
             for (index in 0..length)
@@ -128,20 +128,20 @@ fun filtering(): List<GenericFunction> {
             """
             var yielding = false
             return FilteringStream(this) {
-                        if (yielding)
-                            true
-                        else if (!predicate(it)) {
-                            yielding = true
-                            true
-                        } else
-                            false
-                    }
+                if (yielding)
+                    true
+                else if (!predicate(it)) {
+                    yielding = true
+                    true
+                } else
+                    false
+            }
             """
         }
 
     }
 
-    templates add f("takeWhile(predicate: (T)->Boolean)") {
+    templates add f("takeWhile(predicate: (T) -> Boolean)") {
         inline(true)
 
         doc { "Returns a list containing first elements satisfying the given *predicate*" }
@@ -150,15 +150,15 @@ fun filtering(): List<GenericFunction> {
             """
             val list = ArrayList<T>()
             for (item in this) {
-                 if(!predicate(item))
+                if (!predicate(item))
                     break;
-                 list.add(item)
+                list.add(item)
             }
             return list
             """
         }
 
-        returns(Strings) { "String"}
+        returns(Strings) { "String" }
         body(Strings) {
             """
             for (index in 0..length)
@@ -179,7 +179,7 @@ fun filtering(): List<GenericFunction> {
         }
     }
 
-    templates add f("filter(predicate: (T)->Boolean)") {
+    templates add f("filter(predicate: (T) -> Boolean)") {
         inline(true)
 
         doc { "Returns a list containing all elements matching the given *predicate*" }
@@ -190,7 +190,7 @@ fun filtering(): List<GenericFunction> {
             """
         }
 
-        returns(Strings) { "String"}
+        returns(Strings) { "String" }
         body(Strings) {
             """
             return filterTo(StringBuilder(), predicate).toString()
@@ -212,7 +212,7 @@ fun filtering(): List<GenericFunction> {
         inline(true)
 
         doc { "Appends all elements matching the given *predicate* into the given *collection*" }
-        typeParam("C: TCollection")
+        typeParam("C : TCollection")
         returns("C")
 
         body {
@@ -236,7 +236,7 @@ fun filtering(): List<GenericFunction> {
         include(Maps)
     }
 
-    templates add f("filterNot(predicate: (T)->Boolean)") {
+    templates add f("filterNot(predicate: (T) -> Boolean)") {
         inline(true)
 
         doc { "Returns a list containing all elements not matching the given *predicate*" }
@@ -247,7 +247,7 @@ fun filtering(): List<GenericFunction> {
             """
         }
 
-        returns(Strings) { "String"}
+        returns(Strings) { "String" }
         body(Strings) {
             """
             return filterNotTo(StringBuilder(), predicate).toString()
@@ -269,7 +269,7 @@ fun filtering(): List<GenericFunction> {
         inline(true)
 
         doc { "Appends all elements not matching the given *predicate* to the given *collection*" }
-        typeParam("C: TCollection")
+        typeParam("C : TCollection")
         returns("C")
 
         body {
@@ -292,7 +292,7 @@ fun filtering(): List<GenericFunction> {
     templates add f("filterNotNull()") {
         exclude(ArraysOfPrimitives, Strings)
         doc { "Returns a list containing all elements that are not null" }
-        typeParam("T: Any")
+        typeParam("T : Any")
         returns("List<T>")
         toNullableT = true
         body {
@@ -314,8 +314,8 @@ fun filtering(): List<GenericFunction> {
         exclude(ArraysOfPrimitives, Strings)
         doc { "Appends all elements that are not null to the given *collection*" }
         returns("C")
-        typeParam("C: TCollection")
-        typeParam("T: Any")
+        typeParam("C : TCollection")
+        typeParam("T : Any")
         toNullableT = true
         body {
             """
diff --git a/libraries/tools/kotlin-stdlib-gen/src/templates/Generators.kt b/libraries/tools/kotlin-stdlib-gen/src/templates/Generators.kt
index 89221626d1c..3d1cb6599c6 100644
--- a/libraries/tools/kotlin-stdlib-gen/src/templates/Generators.kt
+++ b/libraries/tools/kotlin-stdlib-gen/src/templates/Generators.kt
@@ -11,9 +11,9 @@ fun generators(): List<GenericFunction> {
         returns("List<T>")
         body {
             """
-                val answer = toArrayList()
-                answer.add(element)
-                return answer
+            val answer = toArrayList()
+            answer.add(element)
+            return answer
             """
         }
 
@@ -32,9 +32,9 @@ fun generators(): List<GenericFunction> {
         returns("List<T>")
         body {
             """
-                val answer = toArrayList()
-                answer.addAll(collection)
-                return answer
+            val answer = toArrayList()
+            answer.addAll(collection)
+            return answer
             """
         }
     }
@@ -45,9 +45,9 @@ fun generators(): List<GenericFunction> {
         returns("List<T>")
         body {
             """
-                val answer = toArrayList()
-                answer.addAll(array)
-                return answer
+            val answer = toArrayList()
+            answer.addAll(array)
+            return answer
             """
         }
     }
@@ -88,32 +88,32 @@ fun generators(): List<GenericFunction> {
         returns("Pair<List<T>, List<T>>")
         body {
             """
-                val first = ArrayList<T>()
-                val second = ArrayList<T>()
-                for (element in this) {
-                    if (predicate(element)) {
-                        first.add(element)
-                    } else {
-                        second.add(element)
-                    }
+            val first = ArrayList<T>()
+            val second = ArrayList<T>()
+            for (element in this) {
+                if (predicate(element)) {
+                    first.add(element)
+                } else {
+                    second.add(element)
                 }
-                return Pair(first, second)
+            }
+            return Pair(first, second)
             """
         }
 
         returns(Strings) { "Pair<String, String>" }
         body(Strings) {
             """
-                val first = StringBuilder()
-                val second = StringBuilder()
-                for (element in this) {
-                    if (predicate(element)) {
-                        first.append(element)
-                    } else {
-                        second.append(element)
-                    }
+            val first = StringBuilder()
+            val second = StringBuilder()
+            for (element in this) {
+                if (predicate(element)) {
+                    first.append(element)
+                } else {
+                    second.append(element)
                 }
-                return Pair(first.toString(), second.toString())
+            }
+            return Pair(first.toString(), second.toString())
             """
         }
     }
@@ -126,37 +126,37 @@ fun generators(): List<GenericFunction> {
             """
         }
         typeParam("R")
-        returns("List<Pair<T,R>>")
+        returns("List<Pair<T, R>>")
         body {
             """
-                val first = iterator()
-                val second = other.iterator()
-                val list = ArrayList<Pair<T,R>>()
-                while (first.hasNext() && second.hasNext()) {
-                    list.add(first.next() to second.next())
-                }
-                return list
+            val first = iterator()
+            val second = other.iterator()
+            val list = ArrayList<Pair<T, R>>()
+            while (first.hasNext() && second.hasNext()) {
+                list.add(first.next() to second.next())
+            }
+            return list
             """
         }
     }
 
-    templates add f("zip(other : String)") {
+    templates add f("zip(other: String)") {
         only(Strings)
         doc {
             """
             Returns a list of pairs built from characters of both strings with same indexes. List has length of shortest collection.
             """
         }
-        returns("List<Pair<Char,Char>>")
+        returns("List<Pair<Char, Char>>")
         body {
             """
-                val first = iterator()
-                val second = other.iterator()
-                val list = ArrayList<Pair<Char,Char>>()
-                while (first.hasNext() && second.hasNext()) {
-                    list.add(first.next() to second.next())
-                }
-                return list
+            val first = iterator()
+            val second = other.iterator()
+            val list = ArrayList<Pair<Char, Char>>()
+            while (first.hasNext() && second.hasNext()) {
+                list.add(first.next() to second.next())
+            }
+            return list
             """
         }
     }
@@ -169,16 +169,16 @@ fun generators(): List<GenericFunction> {
             """
         }
         typeParam("R")
-        returns("List<Pair<T,R>>")
+        returns("List<Pair<T, R>>")
         body {
             """
-                val first = iterator()
-                val second = array.iterator()
-                val list = ArrayList<Pair<T,R>>()
-                while (first.hasNext() && second.hasNext()) {
-                    list.add(first.next() to second.next())
-                }
-                return list
+            val first = iterator()
+            val second = array.iterator()
+            val list = ArrayList<Pair<T, R>>()
+            while (first.hasNext() && second.hasNext()) {
+                list.add(first.next() to second.next())
+            }
+            return list
             """
         }
     }
@@ -191,10 +191,10 @@ fun generators(): List<GenericFunction> {
             """
         }
         typeParam("R")
-        returns("Stream<Pair<T,R>>")
+        returns("Stream<Pair<T, R>>")
         body {
             """
-                return ZippingStream(this, stream)
+            return ZippingStream(this, stream)
             """
         }
     }
diff --git a/libraries/tools/kotlin-stdlib-gen/src/templates/Guards.kt b/libraries/tools/kotlin-stdlib-gen/src/templates/Guards.kt
index 1fa4fac5914..66c8cf3acf0 100644
--- a/libraries/tools/kotlin-stdlib-gen/src/templates/Guards.kt
+++ b/libraries/tools/kotlin-stdlib-gen/src/templates/Guards.kt
@@ -12,7 +12,7 @@ fun guards(): List<GenericFunction> {
         include(Lists)
         exclude(Strings, ArraysOfPrimitives)
         doc { "Returns an original collection containing all the non-*null* elements, throwing an [[IllegalArgumentException]] if there are any null elements" }
-        typeParam("T:Any")
+        typeParam("T : Any")
         toNullableT = true
         returns("SELF")
         body {
diff --git a/libraries/tools/kotlin-stdlib-gen/src/templates/Mapping.kt b/libraries/tools/kotlin-stdlib-gen/src/templates/Mapping.kt
index ebaa41ff4cc..48689019e73 100644
--- a/libraries/tools/kotlin-stdlib-gen/src/templates/Mapping.kt
+++ b/libraries/tools/kotlin-stdlib-gen/src/templates/Mapping.kt
@@ -25,7 +25,7 @@ fun mapping(): List<GenericFunction> {
         }
     }
 
-    templates add f("map(transform : (T) -> R)") {
+    templates add f("map(transform: (T) -> R)") {
         inline(true)
 
         doc { "Returns a list containing the results of applying the given *transform* function to each element of the original collection" }
@@ -39,16 +39,16 @@ fun mapping(): List<GenericFunction> {
         returns(Streams) { "Stream<R>" }
         doc(Streams) { "Returns a stream containing the results of applying the given *transform* function to each element of the original stream" }
         body(Streams) {
-            "return TransformingStream(this, transform) "
+            "return TransformingStream(this, transform)"
         }
         include(Maps)
     }
 
-    templates add f("mapNotNull(transform : (T) -> R)") {
+    templates add f("mapNotNull(transform: (T) -> R)") {
         inline(true)
         exclude(Strings, ArraysOfPrimitives)
         doc { "Returns a list containing the results of applying the given *transform* function to each non-null element of the original collection" }
-        typeParam("T: Any")
+        typeParam("T : Any")
         typeParam("R")
         returns("List<R>")
         toNullableT = true
@@ -68,7 +68,7 @@ fun mapping(): List<GenericFunction> {
         }
     }
 
-    templates add f("mapTo(collection: C, transform : (T) -> R)") {
+    templates add f("mapTo(collection: C, transform: (T) -> R)") {
         inline(true)
 
         doc {
@@ -78,7 +78,7 @@ fun mapping(): List<GenericFunction> {
             """
         }
         typeParam("R")
-        typeParam("C: MutableCollection<in R>")
+        typeParam("C : MutableCollection<in R>")
         returns("C")
 
         body {
@@ -91,7 +91,7 @@ fun mapping(): List<GenericFunction> {
         include(Maps)
     }
 
-    templates add f("mapNotNullTo(collection: C, transform : (T) -> R)") {
+    templates add f("mapNotNullTo(collection: C, transform: (T) -> R)") {
         inline(true)
         exclude(Strings, ArraysOfPrimitives)
         doc {
@@ -100,9 +100,9 @@ fun mapping(): List<GenericFunction> {
             to the given *collection*
             """
         }
-        typeParam("T: Any")
+        typeParam("T : Any")
         typeParam("R")
-        typeParam("C: MutableCollection<in R>")
+        typeParam("C : MutableCollection<in R>")
         returns("C")
         toNullableT = true
         body {
@@ -110,14 +110,14 @@ fun mapping(): List<GenericFunction> {
             for (element in this) {
                 if (element != null) {
                     collection.add(transform(element))
-                 }
+                }
             }
             return collection
             """
         }
     }
 
-    templates add f("flatMap(transform: (T)-> Iterable<R>)") {
+    templates add f("flatMap(transform: (T) -> Iterable<R>)") {
         inline(true)
 
         exclude(Streams)
@@ -130,7 +130,7 @@ fun mapping(): List<GenericFunction> {
         include(Maps)
     }
 
-    templates add f("flatMap(transform: (T)-> Stream<R>)") {
+    templates add f("flatMap(transform: (T) -> Stream<R>)") {
         only(Streams)
         doc { "Returns a single stream of all elements streamed from results of *transform* function being invoked on each element of original stream" }
         typeParam("R")
@@ -145,7 +145,7 @@ fun mapping(): List<GenericFunction> {
         exclude(Streams)
         doc { "Appends all elements yielded from results of *transform* function being invoked on each element of original collection, to the given *collection*" }
         typeParam("R")
-        typeParam("C: MutableCollection<in R>")
+        typeParam("C : MutableCollection<in R>")
         returns("C")
         body {
             """
@@ -165,7 +165,7 @@ fun mapping(): List<GenericFunction> {
         only(Streams)
         doc { "Appends all elements yielded from results of *transform* function being invoked on each element of original stream, to the given *collection*" }
         typeParam("R")
-        typeParam("C: MutableCollection<in R>")
+        typeParam("C : MutableCollection<in R>")
         returns("C")
         body {
             """
diff --git a/libraries/tools/kotlin-stdlib-gen/src/templates/Numeric.kt b/libraries/tools/kotlin-stdlib-gen/src/templates/Numeric.kt
index affce76a241..bf5d5b9e36d 100644
--- a/libraries/tools/kotlin-stdlib-gen/src/templates/Numeric.kt
+++ b/libraries/tools/kotlin-stdlib-gen/src/templates/Numeric.kt
@@ -10,12 +10,12 @@ fun numeric(): List<GenericFunction> {
         returns("SUM")
         body {
             """
-                val iterator = iterator()
-                var sum : SUM = ZERO
-                while (iterator.hasNext()) {
-                    sum += iterator.next()
-                }
-                return sum
+            val iterator = iterator()
+            var sum: SUM = ZERO
+            while (iterator.hasNext()) {
+                sum += iterator.next()
+            }
+            return sum
             """
         }
     }
diff --git a/libraries/tools/kotlin-stdlib-gen/src/templates/Ordering.kt b/libraries/tools/kotlin-stdlib-gen/src/templates/Ordering.kt
index a688623d73d..6d431a0380b 100644
--- a/libraries/tools/kotlin-stdlib-gen/src/templates/Ordering.kt
+++ b/libraries/tools/kotlin-stdlib-gen/src/templates/Ordering.kt
@@ -17,7 +17,7 @@ fun ordering(): List<GenericFunction> {
         }
 
         doc(Strings) { "Returns a string with characters in reversed order" }
-        returns(Strings) { "String"}
+        returns(Strings) { "String" }
         body(Strings) {
             // TODO: Replace with StringBuilder(this) when JS can handle it
             """
@@ -35,7 +35,7 @@ fun ordering(): List<GenericFunction> {
             """
         }
         returns("List<T>")
-        typeParam("T: Comparable<T>")
+        typeParam("T : Comparable<T>")
         body {
             """
             val sortedList = toArrayList()
@@ -57,11 +57,11 @@ fun ordering(): List<GenericFunction> {
             """
         }
         returns("List<T>")
-        typeParam("T: Comparable<T>")
+        typeParam("T : Comparable<T>")
         body {
             """
             val sortedList = toArrayList()
-            val sortBy: Comparator<T> = comparator<T> {(x: T, y: T) -> -x.compareTo(y)}
+            val sortBy: Comparator<T> = comparator<T> {(x: T, y: T) -> -x.compareTo(y) }
             java.util.Collections.sort(sortedList, sortBy)
             return sortedList
             """
@@ -82,11 +82,11 @@ fun ordering(): List<GenericFunction> {
             """
         }
         returns("List<T>")
-        typeParam("R: Comparable<R>")
+        typeParam("R : Comparable<R>")
         body {
             """
             val sortedList = toArrayList()
-            val sortBy: Comparator<T> = comparator<T> {(x: T, y: T) -> order(x).compareTo(order(y))}
+            val sortBy: Comparator<T> = comparator<T> {(x: T, y: T) -> order(x).compareTo(order(y)) }
             java.util.Collections.sort(sortedList, sortBy)
             return sortedList
             """
@@ -106,11 +106,11 @@ fun ordering(): List<GenericFunction> {
             """
         }
         returns("List<T>")
-        typeParam("R: Comparable<R>")
+        typeParam("R : Comparable<R>")
         body {
             """
             val sortedList = toArrayList()
-            val sortBy: Comparator<T> = comparator<T> {(x: T, y: T) -> -order(x).compareTo(order(y))}
+            val sortBy: Comparator<T> = comparator<T> {(x: T, y: T) -> -order(x).compareTo(order(y)) }
             java.util.Collections.sort(sortedList, sortBy)
             return sortedList
             """
@@ -121,7 +121,7 @@ fun ordering(): List<GenericFunction> {
         exclude(Strings)
     }
 
-    templates add f("sortBy(comparator : Comparator<T>)") {
+    templates add f("sortBy(comparator: Comparator<T>)") {
         doc {
             """
             Returns a list of all elements, sorted by the specified *comparator*
diff --git a/libraries/tools/kotlin-stdlib-gen/src/templates/Snapshots.kt b/libraries/tools/kotlin-stdlib-gen/src/templates/Snapshots.kt
index d000bb45d32..2ab5f9fceda 100644
--- a/libraries/tools/kotlin-stdlib-gen/src/templates/Snapshots.kt
+++ b/libraries/tools/kotlin-stdlib-gen/src/templates/Snapshots.kt
@@ -5,7 +5,7 @@ import templates.Family.*
 fun snapshots(): List<GenericFunction> {
     val templates = arrayListOf<GenericFunction>()
 
-    templates add f("toCollection(collection : C)") {
+    templates add f("toCollection(collection: C)") {
         doc { "Appends all elements to the given *collection*" }
         returns("C")
         typeParam("C : MutableCollection<in T>")
@@ -94,7 +94,7 @@ fun snapshots(): List<GenericFunction> {
 
     templates add f("toSortedList()") {
         doc { "Returns a sorted list of all elements" }
-        typeParam("T: Comparable<T>")
+        typeParam("T : Comparable<T>")
         returns("List<T>")
         body { "return toArrayList().sort()" }
         body(Iterables) { "return sort()" }
diff --git a/libraries/tools/kotlin-stdlib-gen/src/templates/SpecialJVM.kt b/libraries/tools/kotlin-stdlib-gen/src/templates/SpecialJVM.kt
index 38ae49d9ec2..77df201fbd4 100644
--- a/libraries/tools/kotlin-stdlib-gen/src/templates/SpecialJVM.kt
+++ b/libraries/tools/kotlin-stdlib-gen/src/templates/SpecialJVM.kt
@@ -63,7 +63,7 @@ fun specialJVM(): List<GenericFunction> {
         }
     }
 
-    templates add f("sort(fromIndex : Int = 0, toIndex : Int = size - 1)") {
+    templates add f("sort(fromIndex: Int = 0, toIndex: Int = size - 1)") {
         only(ArraysOfObjects, ArraysOfPrimitives)
         exclude(PrimitiveType.Boolean)
         doc { "Sorts array or range in array inplace" }
@@ -75,8 +75,8 @@ fun specialJVM(): List<GenericFunction> {
 
     templates add f("filterIsInstanceTo(collection: C, klass: Class<R>)") {
         doc { "Appends all elements that are instances of specified class into the given *collection*" }
-        typeParam("C: MutableCollection<in R>")
-        typeParam("R: T")
+        typeParam("C : MutableCollection<in R>")
+        typeParam("R : T")
         returns("C")
         exclude(ArraysOfPrimitives)
         body {
@@ -89,7 +89,7 @@ fun specialJVM(): List<GenericFunction> {
 
     templates add f("filterIsInstance(klass: Class<R>)") {
         doc { "Returns a list containing all elements that are instances of specified class" }
-        typeParam("R: T")
+        typeParam("R : T")
         returns("List<R>")
         body {
             """
diff --git a/libraries/tools/kotlin-stdlib-gen/src/templates/Stream.kt b/libraries/tools/kotlin-stdlib-gen/src/templates/Stream.kt
index a6dc7cc6e68..77ff1e3e1d7 100644
--- a/libraries/tools/kotlin-stdlib-gen/src/templates/Stream.kt
+++ b/libraries/tools/kotlin-stdlib-gen/src/templates/Stream.kt
@@ -10,7 +10,11 @@ fun streams(): List<GenericFunction> {
         returns("Stream<T>")
         body {
             """
-            return object : Stream<T> { override fun iterator() : Iterator<T> { return this@stream.iterator() } }
+            return object : Stream<T> {
+                override fun iterator(): Iterator<T> {
+                    return this@stream.iterator()
+                }
+            }
             """
         }
 
diff --git a/libraries/tools/kotlin-stdlib-gen/src/templates/Strings.kt b/libraries/tools/kotlin-stdlib-gen/src/templates/Strings.kt
index dbc699aa8a5..e05c7dff092 100644
--- a/libraries/tools/kotlin-stdlib-gen/src/templates/Strings.kt
+++ b/libraries/tools/kotlin-stdlib-gen/src/templates/Strings.kt
@@ -5,7 +5,7 @@ import templates.Family.*
 fun strings(): List<GenericFunction> {
     val templates = arrayListOf<GenericFunction>()
 
-    templates add f("appendString(buffer: Appendable, separator: String = \", \", prefix: String =\"\", postfix: String = \"\", limit: Int = -1, truncated: String = \"...\")") {
+    templates add f("appendString(buffer: Appendable, separator: String = \", \", prefix: String = \"\", postfix: String = \"\", limit: Int = -1, truncated: String = \"...\")") {
         doc {
             """
             Appends the string from all the elements separated using the *separator* and using the given *prefix* and *postfix* if supplied