public inline fun < R > ComplexFloatArray . fold ( initial : R , operation : ( acc : R , ComplexFloat ) -> R ) : R

{ <EOL> var accumulator = initial <EOL> for ( element in this ) accumulator = operation ( accumulator , element ) <EOL> return accumulator <EOL> }

/**
 * Accumulates value starting with [initial] value and applying [operation] from left to right
 * to current accumulator value and each element.
 *
 * Returns the specified [initial] value if the array is empty.
 *
 * @param [operation] function that takes current accumulator value and an element, and calculates the next accumulator value.
 */


public inline fun < R > ComplexDoubleArray . fold ( initial : R , operation : ( acc : R , ComplexDouble ) -> R ) : R


public inline fun < R > ComplexFloatArray . foldIndexed ( initial : R , operation : ( index : Int , acc : R , ComplexFloat ) -> R ) : R

{ <EOL> var index = <NUM_LIT:0> <EOL> var accumulator = initial <EOL> for ( element in this ) accumulator = operation ( index ++ , accumulator , element ) <EOL> return accumulator <EOL> }

/**
 * Accumulates value starting with [initial] value and applying [operation] from left to right
 * to current accumulator value and each element with its index in the original array.
 *
 * Returns the specified [initial] value if the array is empty.
 *
 * @param [operation] function that takes the index of an element, current accumulator value
 * and the element itself, and calculates the next accumulator value.
 */


public inline fun < R > ComplexDoubleArray . foldIndexed ( initial : R , operation : ( index : Int , acc : R , ComplexDouble ) -> R ) : R


public inline fun < R > ComplexFloatArray . foldRight ( initial : R , operation : ( ComplexFloat , acc : R ) -> R ) : R

{ <EOL> var index = lastIndex <EOL> var accumulator = initial <EOL> while ( index >= <NUM_LIT:0> ) { <EOL> accumulator = operation ( get ( index -- ) , accumulator ) <EOL> } <EOL> return accumulator <EOL> }

/**
 * Accumulates value starting with [initial] value and applying [operation] from right to left
 * to each element and current accumulator value.
 *
 * Returns the specified [initial] value if the array is empty.
 *
 * @param [operation] function that takes an element and current accumulator value, and calculates the next accumulator value.
 */


public inline fun < R > ComplexDoubleArray . foldRight ( initial : R , operation : ( ComplexDouble , acc : R ) -> R ) : R


public inline fun < R > ComplexFloatArray . foldRightIndexed ( initial : R , operation : ( index : Int , ComplexFloat , acc : R ) -> R ) : R

{ <EOL> var index = lastIndex <EOL> var accumulator = initial <EOL> while ( index >= <NUM_LIT:0> ) { <EOL> accumulator = operation ( index , get ( index ) , accumulator ) <EOL> -- index <EOL> } <EOL> return accumulator <EOL> }

/**
 * Accumulates value starting with [initial] value and applying [operation] from right to left
 * to each element with its index in the original array and current accumulator value.
 *
 * Returns the specified [initial] value if the array is empty.
 *
 * @param [operation] function that takes the index of an element, the element itself
 * and current accumulator value, and calculates the next accumulator value.
 */


public inline fun < R > ComplexDoubleArray . foldRightIndexed ( initial : R , operation : ( index : Int , ComplexDouble , acc : R ) -> R ) : R


public inline fun ComplexFloatArray . forEach ( action : ( ComplexFloat ) -> Unit ) : Unit

{ <EOL> for ( element in this ) action ( element ) <EOL> }

/**
 * Performs the given [action] on each element.
 */


public inline fun ComplexDoubleArray . forEach ( action : ( ComplexDouble ) -> Unit ) : Unit


public inline fun ComplexFloatArray . forEachIndexed ( action : ( index : Int , ComplexFloat ) -> Unit ) : Unit

{ <EOL> var index = <NUM_LIT:0> <EOL> for ( item in this ) action ( index ++ , item ) <EOL> }

/**
 * Performs the given [action] on each element, providing sequential index with the element.
 * @param [action] function that takes the index of an element and the element itself
 * and performs the action on the element.
 */


public inline fun ComplexDoubleArray . forEachIndexed ( action : ( index : Int , ComplexDouble ) -> Unit ) : Unit


public inline fun < R : Comparable < R > > ComplexFloatArray . maxByOrNull ( selector : ( ComplexFloat ) -> R ) : ComplexFloat ?

{ <EOL> if ( isEmpty ( ) ) return null <EOL> var maxElem = this [ <NUM_LIT:0> ] <EOL> val lastIndex = this . lastIndex <EOL> if ( lastIndex == <NUM_LIT:0> ) return maxElem <EOL> var maxValue = selector ( maxElem ) <EOL> for ( i in <NUM_LIT:1> .. lastIndex ) { <EOL> val e = this [ i ] <EOL> val v = selector ( e ) <EOL> if ( maxValue < v ) { <EOL> maxElem = e <EOL> maxValue = v <EOL> } <EOL> } <EOL> return maxElem <EOL> }

/**
 * 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 > > ComplexDoubleArray . maxByOrNull ( selector : ( ComplexDouble ) -> R ) : ComplexDouble ?


public inline fun < R : Comparable < R > > ComplexFloatArray . maxOf ( selector : ( ComplexFloat ) -> R ) : R

{ <EOL> if ( isEmpty ( ) ) throw NoSuchElementException ( ) <EOL> var maxValue = selector ( this [ <NUM_LIT:0> ] ) <EOL> for ( i in <NUM_LIT:1> .. lastIndex ) { <EOL> val v = selector ( this [ i ] ) <EOL> if ( maxValue < v ) { <EOL> maxValue = v <EOL> } <EOL> } <EOL> return maxValue <EOL> }

/**
 * Returns the largest value among all values produced by [selector] function
 * applied to each element in the array.
 *
 * @throws NoSuchElementException if the array is empty.
 */


public inline fun < R : Comparable < R > > ComplexDoubleArray . maxOf ( selector : ( ComplexDouble ) -> R ) : R


public inline fun < R : Comparable < R > > ComplexFloatArray . maxOfOrNull ( selector : ( ComplexFloat ) -> R ) : R ?

{ <EOL> if ( isEmpty ( ) ) return null <EOL> var maxValue = selector ( this [ <NUM_LIT:0> ] ) <EOL> for ( i in <NUM_LIT:1> .. lastIndex ) { <EOL> val v = selector ( this [ i ] ) <EOL> if ( maxValue < v ) { <EOL> maxValue = v <EOL> } <EOL> } <EOL> return maxValue <EOL> }

/**
 * Returns the largest value among all values produced by [selector] function
 * applied to each element in the array or `null` if there are no elements.
 */


public inline fun < R : Comparable < R > > ComplexDoubleArray . maxOfOrNull ( selector : ( ComplexDouble ) -> R ) : R ?


public inline fun < R > ComplexFloatArray . maxOfWith ( comparator : Comparator < in R > , selector : ( ComplexFloat ) -> R ) : R

{ <EOL> if ( isEmpty ( ) ) throw NoSuchElementException ( ) <EOL> var maxValue = selector ( this [ <NUM_LIT:0> ] ) <EOL> for ( i in <NUM_LIT:1> .. lastIndex ) { <EOL> val v = selector ( this [ i ] ) <EOL> if ( comparator . compare ( maxValue , v ) < <NUM_LIT:0> ) { <EOL> maxValue = v <EOL> } <EOL> } <EOL> return maxValue <EOL> }

/**
 * Returns the largest value according to the provided [comparator]
 * among all values produced by [selector] function applied to each element in the array.
 *
 * @throws NoSuchElementException if the array is empty.
 */


public inline fun < R > ComplexDoubleArray . maxOfWith ( comparator : Comparator < in R > , selector : ( ComplexDouble ) -> R ) : R


public inline fun < R > ComplexFloatArray . maxOfWithOrNull ( comparator : Comparator < in R > , selector : ( ComplexFloat ) -> R ) : R ?

{ <EOL> if ( isEmpty ( ) ) return null <EOL> var maxValue = selector ( this [ <NUM_LIT:0> ] ) <EOL> for ( i in <NUM_LIT:1> .. lastIndex ) { <EOL> val v = selector ( this [ i ] ) <EOL> if ( comparator . compare ( maxValue , v ) < <NUM_LIT:0> ) { <EOL> maxValue = v <EOL> } <EOL> } <EOL> return maxValue <EOL> }

/**
 * Returns the largest value according to the provided [comparator]
 * among all values produced by [selector] function applied to each element in the array or `null` if there are no elements.
 */


public inline fun < R > ComplexDoubleArray . maxOfWithOrNull ( comparator : Comparator < in R > , selector : ( ComplexDouble ) -> R ) : R ?


public inline fun < R : Comparable < R > > ComplexFloatArray . minByOrNull ( selector : ( ComplexFloat ) -> R ) : ComplexFloat ?

{ <EOL> if ( isEmpty ( ) ) return null <EOL> var minElem = this [ <NUM_LIT:0> ] <EOL> val lastIndex = this . lastIndex <EOL> if ( lastIndex == <NUM_LIT:0> ) return minElem <EOL> var minValue = selector ( minElem ) <EOL> for ( i in <NUM_LIT:1> .. lastIndex ) { <EOL> val e = this [ i ] <EOL> val v = selector ( e ) <EOL> if ( minValue > v ) { <EOL> minElem = e <EOL> minValue = v <EOL> } <EOL> } <EOL> return minElem <EOL> }

/**
 * 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 > > ComplexDoubleArray . minByOrNull ( selector : ( ComplexDouble ) -> R ) : ComplexDouble ?


public inline fun < R : Comparable < R > > ComplexFloatArray . minOf ( selector : ( ComplexFloat ) -> R ) : R

{ <EOL> if ( isEmpty ( ) ) throw NoSuchElementException ( ) <EOL> var minValue = selector ( this [ <NUM_LIT:0> ] ) <EOL> for ( i in <NUM_LIT:1> .. lastIndex ) { <EOL> val v = selector ( this [ i ] ) <EOL> if ( minValue > v ) { <EOL> minValue = v <EOL> } <EOL> } <EOL> return minValue <EOL> }

/**
 * Returns the smallest value among all values produced by [selector] function
 * applied to each element in the array.
 *
 * @throws NoSuchElementException if the array is empty.
 */


public inline fun < R : Comparable < R > > ComplexDoubleArray . minOf ( selector : ( ComplexDouble ) -> R ) : R


public inline fun < R : Comparable < R > > ComplexFloatArray . minOfOrNull ( selector : ( ComplexFloat ) -> R ) : R ?

{ <EOL> if ( isEmpty ( ) ) return null <EOL> var minValue = selector ( this [ <NUM_LIT:0> ] ) <EOL> for ( i in <NUM_LIT:1> .. lastIndex ) { <EOL> val v = selector ( this [ i ] ) <EOL> if ( minValue > v ) { <EOL> minValue = v <EOL> } <EOL> } <EOL> return minValue <EOL> }

/**
 * Returns the smallest value among all values produced by [selector] function
 * applied to each element in the array or `null` if there are no elements.
 */


public inline fun < R : Comparable < R > > ComplexDoubleArray . minOfOrNull ( selector : ( ComplexDouble ) -> R ) : R ?


public inline fun < R > ComplexFloatArray . minOfWith ( comparator : Comparator < in R > , selector : ( ComplexFloat ) -> R ) : R

{ <EOL> if ( isEmpty ( ) ) throw NoSuchElementException ( ) <EOL> var minValue = selector ( this [ <NUM_LIT:0> ] ) <EOL> for ( i in <NUM_LIT:1> .. lastIndex ) { <EOL> val v = selector ( this [ i ] ) <EOL> if ( comparator . compare ( minValue , v ) > <NUM_LIT:0> ) { <EOL> minValue = v <EOL> } <EOL> } <EOL> return minValue <EOL> }

/**
 * Returns the smallest value according to the provided [comparator]
 * among all values produced by [selector] function applied to each element in the array.
 *
 * @throws NoSuchElementException if the array is empty.
 */


public inline fun < R > ComplexDoubleArray . minOfWith ( comparator : Comparator < in R > , selector : ( ComplexDouble ) -> R ) : R


public inline fun < R > ComplexFloatArray . minOfWithOrNull ( comparator : Comparator < in R > , selector : ( ComplexFloat ) -> R ) : R ?

{ <EOL> if ( isEmpty ( ) ) return null <EOL> var minValue = selector ( this [ <NUM_LIT:0> ] ) <EOL> for ( i in <NUM_LIT:1> .. lastIndex ) { <EOL> val v = selector ( this [ i ] ) <EOL> if ( comparator . compare ( minValue , v ) > <NUM_LIT:0> ) { <EOL> minValue = v <EOL> } <EOL> } <EOL> return minValue <EOL> }

/**
 * Returns the smallest value according to the provided [comparator]
 * among all values produced by [selector] function applied to each element in the array or `null` if there are no elements.
 */


public inline fun < R > ComplexDoubleArray . minOfWithOrNull ( comparator : Comparator < in R > , selector : ( ComplexDouble ) -> R ) : R ?


public fun ComplexFloatArray . none ( ) : Boolean

= isEmpty ( )

/**
 * Returns `true` if the array has no elements.
 */


public fun ComplexDoubleArray . none ( ) : Boolean

= isEmpty ( )


public inline fun ComplexFloatArray . none ( predicate : ( ComplexFloat ) -> Boolean ) : Boolean

{ <EOL> for ( element in this ) if ( predicate ( element ) ) return false <EOL> return true <EOL> }

/**
 * Returns `true` if no elements match the given [predicate].
 */


public inline fun ComplexDoubleArray . none ( predicate : ( ComplexDouble ) -> Boolean ) : Boolean


public inline fun ComplexFloatArray . onEach ( action : ( ComplexFloat ) -> Unit ) : ComplexFloatArray

= <EOL> apply { for ( element in this ) action ( element ) }

/**
 * Performs the given [action] on each element and returns the array itself afterwards.
 */


public inline fun ComplexDoubleArray . onEach ( action : ( ComplexDouble ) -> Unit ) : ComplexDoubleArray


public inline fun ComplexFloatArray . onEachIndexed ( action : ( index : Int , ComplexFloat ) -> Unit ) : ComplexFloatArray

= <EOL> apply { forEachIndexed ( action ) }

/**
 * Performs the given [action] on each element, providing sequential index with the element,
 * and returns the array itself afterwards.
 * @param [action] function that takes the index of an element and the element itself
 * and performs the action on the element.
 */


public inline fun ComplexDoubleArray . onEachIndexed ( action : ( index : Int , ComplexDouble ) -> Unit ) : ComplexDoubleArray


public inline fun ComplexFloatArray . reduce ( operation : ( acc : ComplexFloat , ComplexFloat ) -> ComplexFloat ) : ComplexFloat

{ <EOL> if ( isEmpty ( ) ) throw UnsupportedOperationException ( "<STR_LIT>" ) <EOL> var accumulator = this [ <NUM_LIT:0> ] <EOL> for ( index in <NUM_LIT:1> .. lastIndex ) { <EOL> accumulator = operation ( accumulator , this [ index ] ) <EOL> } <EOL> return accumulator <EOL> }

/**
 * Accumulates value starting with the first element and applying [operation] from left to right
 * to current accumulator value and each element.
 *
 * Throws an exception if this array is empty. If the array can be empty in an expected way,
 * please use [reduceOrNull] instead. It returns `null` when its receiver is empty.
 *
 * @param [operation] function that takes current accumulator value and an element,
 * and calculates the next accumulator value.
 */


public inline fun ComplexDoubleArray . reduce ( operation : ( acc : ComplexDouble , ComplexDouble ) -> ComplexDouble ) : ComplexDouble


public inline fun ComplexFloatArray . reduceIndexed ( operation : ( index : Int , acc : ComplexFloat , ComplexFloat ) -> ComplexFloat ) : ComplexFloat

{ <EOL> if ( isEmpty ( ) ) throw UnsupportedOperationException ( "<STR_LIT>" ) <EOL> var accumulator = this [ <NUM_LIT:0> ] <EOL> for ( index in <NUM_LIT:1> .. lastIndex ) { <EOL> accumulator = operation ( index , accumulator , this [ index ] ) <EOL> } <EOL> return accumulator <EOL> }

/**
 * Accumulates value starting with the first element and applying [operation] from left to right
 * to current accumulator value and each element with its index in the original array.
 *
 * Throws an exception if this array is empty. If the array can be empty in an expected way,
 * please use [reduceIndexedOrNull] instead. It returns `null` when its receiver is empty.
 *
 * @param [operation] function that takes the index of an element, current accumulator value and the element itself,
 * and calculates the next accumulator value.
 */


public inline fun ComplexDoubleArray . reduceIndexed ( operation : ( index : Int , acc : ComplexDouble , ComplexDouble ) -> ComplexDouble ) : ComplexDouble


public inline fun ComplexFloatArray . reduceIndexedOrNull ( operation : ( index : Int , acc : ComplexFloat , ComplexFloat ) -> ComplexFloat ) : ComplexFloat ?

{ <EOL> if ( isEmpty ( ) ) return null <EOL> var accumulator = this [ <NUM_LIT:0> ] <EOL> for ( index in <NUM_LIT:1> .. lastIndex ) { <EOL> accumulator = operation ( index , accumulator , this [ index ] ) <EOL> } <EOL> return accumulator <EOL> }

/**
 * Accumulates value starting with the first element and applying [operation] from left to right
 * to current accumulator value and each element with its index in the original array.
 *
 * Returns `null` if the array is empty.
 *
 * @param [operation] function that takes the index of an element, current accumulator value and the element itself,
 * and calculates the next accumulator value.
 */


public inline fun ComplexDoubleArray . reduceIndexedOrNull ( operation : ( index : Int , acc : ComplexDouble , ComplexDouble ) -> ComplexDouble ) : ComplexDouble ?


public inline fun ComplexFloatArray . reduceOrNull ( operation : ( acc : ComplexFloat , ComplexFloat ) -> ComplexFloat ) : ComplexFloat ?

{ <EOL> if ( isEmpty ( ) ) return null <EOL> var accumulator = this [ <NUM_LIT:0> ] <EOL> for ( index in <NUM_LIT:1> .. lastIndex ) { <EOL> accumulator = operation ( accumulator , this [ index ] ) <EOL> } <EOL> return accumulator <EOL> }

/**
 * Accumulates value starting with the first element and applying [operation] from left to right
 * to current accumulator value and each element.
 *
 * Returns `null` if the array is empty.
 *
 * @param [operation] function that takes current accumulator value and an element,
 * and calculates the next accumulator value.
 */


public inline fun ComplexDoubleArray . reduceOrNull ( operation : ( acc : ComplexDouble , ComplexDouble ) -> ComplexDouble ) : ComplexDouble ?


public inline fun ComplexFloatArray . reduceRight ( operation : ( ComplexFloat , acc : ComplexFloat ) -> ComplexFloat ) : ComplexFloat

{ <EOL> var index = lastIndex <EOL> if ( index < <NUM_LIT:0> ) throw UnsupportedOperationException ( "<STR_LIT>" ) <EOL> var accumulator = get ( index -- ) <EOL> while ( index >= <NUM_LIT:0> ) { <EOL> accumulator = operation ( get ( index -- ) , accumulator ) <EOL> } <EOL> return accumulator <EOL> }

/**
 * Accumulates value starting with the last element and applying [operation] from right to left
 * to each element and current accumulator value.
 *
 * Throws an exception if this array is empty. If the array can be empty in an expected way,
 * please use [reduceRightOrNull] instead. It returns `null` when its receiver is empty.
 *
 * @param [operation] function that takes an element and current accumulator value,
 * and calculates the next accumulator value.
 */


public inline fun ComplexDoubleArray . reduceRight ( operation : ( ComplexDouble , acc : ComplexDouble ) -> ComplexDouble ) : ComplexDouble


public inline fun ComplexFloatArray . reduceRightIndexed ( operation : ( index : Int , ComplexFloat , acc : ComplexFloat ) -> ComplexFloat ) : ComplexFloat

{ <EOL> var index = lastIndex <EOL> if ( index < <NUM_LIT:0> ) throw UnsupportedOperationException ( "<STR_LIT>" ) <EOL> var accumulator = get ( index -- ) <EOL> while ( index >= <NUM_LIT:0> ) { <EOL> accumulator = operation ( index , get ( index ) , accumulator ) <EOL> -- index <EOL> } <EOL> return accumulator <EOL> }

/**
 * Accumulates value starting with the last element and applying [operation] from right to left
 * to each element with its index in the original array and current accumulator value.
 *
 * Throws an exception if this array is empty. If the array can be empty in an expected way,
 * please use [reduceRightIndexedOrNull] instead. It returns `null` when its receiver is empty.
 *
 * @param [operation] function that takes the index of an element, the element itself and current accumulator value,
 * and calculates the next accumulator value.
 */


public inline fun ComplexDoubleArray . reduceRightIndexed ( operation : ( index : Int , ComplexDouble , acc : ComplexDouble ) -> ComplexDouble ) : ComplexDouble


public inline fun ComplexFloatArray . reduceRightIndexedOrNull ( operation : ( index : Int , ComplexFloat , acc : ComplexFloat ) -> ComplexFloat ) : ComplexFloat ?

{ <EOL> var index = lastIndex <EOL> if ( index < <NUM_LIT:0> ) return null <EOL> var accumulator = get ( index -- ) <EOL> while ( index >= <NUM_LIT:0> ) { <EOL> accumulator = operation ( index , get ( index ) , accumulator ) <EOL> -- index <EOL> } <EOL> return accumulator <EOL> }

/**
 * Accumulates value starting with the last element and applying [operation] from right to left
 * to each element with its index in the original array and current accumulator value.
 *
 * Returns `null` if the array is empty.
 *
 * @param [operation] function that takes the index of an element, the element itself and current accumulator value,
 * and calculates the next accumulator value.
 */


public inline fun ComplexDoubleArray . reduceRightIndexedOrNull ( operation : ( index : Int , ComplexDouble , acc : ComplexDouble ) -> ComplexDouble ) : ComplexDouble ?


public inline fun ComplexFloatArray . reduceRightOrNull ( operation : ( ComplexFloat , acc : ComplexFloat ) -> ComplexFloat ) : ComplexFloat ?

{ <EOL> var index = lastIndex <EOL> if ( index < <NUM_LIT:0> ) return null <EOL> var accumulator = get ( index -- ) <EOL> while ( index >= <NUM_LIT:0> ) { <EOL> accumulator = operation ( get ( index -- ) , accumulator ) <EOL> } <EOL> return accumulator <EOL> }

/**
 * Accumulates value starting with the last element and applying [operation] from right to left
 * to each element and current accumulator value.
 *
 * Returns `null` if the array is empty.
 *
 * @param [operation] function that takes an element and current accumulator value,
 * and calculates the next accumulator value.
 */


public inline fun ComplexDoubleArray . reduceRightOrNull ( operation : ( ComplexDouble , acc : ComplexDouble ) -> ComplexDouble ) : ComplexDouble ?


public inline fun < R > ComplexFloatArray . runningFold ( initial : R , operation : ( acc : R , ComplexFloat ) -> R ) : List < R >

{ <EOL> if ( isEmpty ( ) ) return listOf ( initial ) <EOL> val result = ArrayList < R > ( size + <NUM_LIT:1> ) . apply { add ( initial ) } <EOL> var accumulator = initial <EOL> for ( element in this ) { <EOL> accumulator = operation ( accumulator , element ) <EOL> result . add ( accumulator ) <EOL> } <EOL> return result <EOL> }

/**
 * Returns a list containing successive accumulation values generated by applying [operation] from left to right
 * to each element and current accumulator value that starts with [initial] value.
 *
 * Note that `acc` value passed to [operation] function should not be mutated;
 * otherwise it would affect the previous value in resulting list.
 *
 * @param [operation] function that takes current accumulator value and an element, and calculates the next accumulator value.
 */


public inline fun < R > ComplexDoubleArray . runningFold ( initial : R , operation : ( acc : R , ComplexDouble ) -> R ) : List < R >


public inline fun < R > ComplexFloatArray . runningFoldIndexed ( initial : R , operation : ( index : Int , acc : R , ComplexFloat ) -> R ) : List < R >

{ <EOL> if ( isEmpty ( ) ) return listOf ( initial ) <EOL> val result = ArrayList < R > ( size + <NUM_LIT:1> ) . apply { add ( initial ) } <EOL> var accumulator = initial <EOL> for ( index in indices ) { <EOL> accumulator = operation ( index , accumulator , this [ index ] ) <EOL> result . add ( accumulator ) <EOL> } <EOL> return result <EOL> }

/**
 * Returns a list containing successive accumulation values generated by applying [operation] from left to right
 * to each element, its index in the original array and current accumulator value that starts with [initial] value.
 *
 * Note that `acc` value passed to [operation] function should not be mutated;
 * otherwise it would affect the previous value in resulting list.
 *
 * @param [operation] function that takes the index of an element, current accumulator value
 * and the element itself, and calculates the next accumulator value.
 */


public inline fun < R > ComplexDoubleArray . runningFoldIndexed ( initial : R , operation : ( index : Int , acc : R , ComplexDouble ) -> R ) : List < R >


public inline fun ComplexFloatArray . runningReduce ( operation : ( acc : ComplexFloat , ComplexFloat ) -> ComplexFloat ) : List < ComplexFloat >

{ <EOL> if ( isEmpty ( ) ) return emptyList ( ) <EOL> var accumulator = this [ <NUM_LIT:0> ] <EOL> val result = ArrayList < ComplexFloat > ( size ) . apply { add ( accumulator ) } <EOL> for ( index in <NUM_LIT:1> until size ) { <EOL> accumulator = operation ( accumulator , this [ index ] ) <EOL> result . add ( accumulator ) <EOL> } <EOL> return result <EOL> }

/**
 * Returns a list containing successive accumulation values generated by applying [operation] from left to right
 * to each element and current accumulator value that starts with the first element of this array.
 *
 * @param [operation] function that takes current accumulator value and an element, and calculates the next accumulator value.
 */


public inline fun ComplexDoubleArray . runningReduce ( operation : ( acc : ComplexDouble , ComplexDouble ) -> ComplexDouble ) : List < ComplexDouble >

{ <EOL> if ( isEmpty ( ) ) return emptyList ( ) <EOL> var accumulator = this [ <NUM_LIT:0> ] <EOL> val result = ArrayList < ComplexDouble > ( size ) . apply { add ( accumulator ) } <EOL> for ( index in <NUM_LIT:1> until size ) { <EOL> accumulator = operation ( accumulator , this [ index ] ) <EOL> result . add ( accumulator ) <EOL> } <EOL> return result <EOL> }


public inline fun ComplexFloatArray . runningReduceIndexed ( operation : ( index : Int , acc : ComplexFloat , ComplexFloat ) -> ComplexFloat ) : List < ComplexFloat >

{ <EOL> if ( isEmpty ( ) ) return emptyList ( ) <EOL> var accumulator = this [ <NUM_LIT:0> ] <EOL> val result = ArrayList < ComplexFloat > ( size ) . apply { add ( accumulator ) } <EOL> for ( index in <NUM_LIT:1> until size ) { <EOL> accumulator = operation ( index , accumulator , this [ index ] ) <EOL> result . add ( accumulator ) <EOL> } <EOL> return result <EOL> }

/**
 * Returns a list containing successive accumulation values generated by applying [operation] from left to right
 * to each element, its index in the original array and current accumulator value that starts with the first element of this array.
 *
 * @param [operation] function that takes the index of an element, current accumulator value
 * and the element itself, and calculates the next accumulator value.
 */


public inline fun ComplexDoubleArray . runningReduceIndexed ( operation : ( index : Int , acc : ComplexDouble , ComplexDouble ) -> ComplexDouble ) : List < ComplexDouble >

{ <EOL> if ( isEmpty ( ) ) return emptyList ( ) <EOL> var accumulator = this [ <NUM_LIT:0> ] <EOL> val result = ArrayList < ComplexDouble > ( size ) . apply { add ( accumulator ) } <EOL> for ( index in <NUM_LIT:1> until size ) { <EOL> accumulator = operation ( index , accumulator , this [ index ] ) <EOL> result . add ( accumulator ) <EOL> } <EOL> return result <EOL> }


public inline fun < R > ComplexFloatArray . scan ( initial : R , operation : ( acc : R , ComplexFloat ) -> R ) : List < R >

= <EOL> runningFold ( initial , operation )


public inline fun < R > ComplexDoubleArray . scan ( initial : R , operation : ( acc : R , ComplexDouble ) -> R ) : List < R >


public inline fun < R > ComplexFloatArray . scanIndexed ( initial : R , operation : ( index : Int , acc : R , ComplexFloat ) -> R ) : List < R >

= <EOL> runningFoldIndexed ( initial , operation )


public inline fun < R > ComplexDoubleArray . scanIndexed ( initial : R , operation : ( index : Int , acc : R , ComplexDouble ) -> R ) : List < R >


public inline fun ComplexFloatArray . partition ( predicate : ( ComplexFloat ) -> Boolean ) : Pair < List < ComplexFloat > , List < ComplexFloat > >

{ <EOL> val first = ArrayList < ComplexFloat > ( ) <EOL> val second = ArrayList < ComplexFloat > ( ) <EOL> for ( element in this ) { <EOL> if ( predicate ( element ) ) { <EOL> first . add ( element ) <EOL> } else { <EOL> second . add ( element ) <EOL> } <EOL> } <EOL> return Pair ( first , second ) <EOL> }

/**
 * Splits the original array into pair of lists,
 * where *first* list contains elements for which [predicate] yielded `true`,
 * while *second* list contains elements for which [predicate] yielded `false`.
 */


public inline fun ComplexDoubleArray . partition ( predicate : ( ComplexDouble ) -> Boolean ) : Pair < List < ComplexDouble > , List < ComplexDouble > >

{ <EOL> val first = ArrayList < ComplexDouble > ( ) <EOL> val second = ArrayList < ComplexDouble > ( ) <EOL> for ( element in this ) { <EOL> if ( predicate ( element ) ) { <EOL> first . add ( element ) <EOL> } else { <EOL> second . add ( element ) <EOL> } <EOL> } <EOL> return Pair ( first , second ) <EOL> }


public infix fun < R > ComplexFloatArray . zip ( other : Array < out R > ) : List < Pair < ComplexFloat , R > >

= <EOL> zip ( other ) { t1 , t2 -> t1 to t2 }

/**
 * Returns a list of pairs built from the elements of `this` array and the [other] array with the same index.
 * The returned list has length of the shortest collection.
 */


public infix fun < R > ComplexDoubleArray . zip ( other : Array < out R > ) : List < Pair < ComplexDouble , R > >


public inline fun < R , V > ComplexFloatArray . zip ( other : Array < out R > , transform : ( a : ComplexFloat , b : R ) -> V ) : List < V >

{ <EOL> val size = minOf ( size , other . size ) <EOL> val list = ArrayList < V > ( size ) <EOL> for ( i in <NUM_LIT:0> until size ) { <EOL> list . add ( transform ( this [ i ] , other [ i ] ) ) <EOL> } <EOL> return list <EOL> }

/**
 * Returns a list of values built from the elements of `this` array and the [other] array with the same index
 * using the provided [transform] function applied to each pair of elements.
 * The returned list has length of the shortest collection.
 */


public inline fun < R , V > ComplexDoubleArray . zip ( other : Array < out R > , transform : ( a : ComplexDouble , b : R ) -> V ) : List < V >


public infix fun < R > ComplexFloatArray . zip ( other : Iterable < R > ) : List < Pair < ComplexFloat , R > >

/**
 * Returns a list of pairs built from the elements of `this` collection and [other] array with the same index.
 * The returned list has length of the shortest collection.
 */


public infix fun < R > ComplexDoubleArray . zip ( other : Iterable < R > ) : List < Pair < ComplexDouble , R > >


public inline fun < R , V > ComplexFloatArray . zip ( other : Iterable < R > , transform : ( a : ComplexFloat , b : R ) -> V ) : List < V >

{ <EOL> val arraySize = size <EOL> val list = ArrayList < V > ( minOf ( if ( other is Collection < * > ) other . size else <NUM_LIT:10> , arraySize ) ) <EOL> var i = <NUM_LIT:0> <EOL> for ( element in other ) { <EOL> if ( i >= arraySize ) break <EOL> list . add ( transform ( this [ i ++ ] , element ) ) <EOL> } <EOL> return list <EOL> }

/**
 * Returns a list of values built from the elements of `this` array and the [other] collection with the same index
 * using the provided [transform] function applied to each pair of elements.
 * The returned list has length of the shortest collection.
 */


public inline fun < R , V > ComplexDoubleArray . zip ( other : Iterable < R > , transform : ( a : ComplexDouble , b : R ) -> V ) : List < V >


public infix fun ComplexFloatArray . zip ( other : ComplexFloatArray ) : List < Pair < ComplexFloat , ComplexFloat > >


public infix fun ComplexDoubleArray . zip ( other : ComplexDoubleArray ) : List < Pair < ComplexDouble , ComplexDouble > >


public inline fun < V > ComplexFloatArray . zip ( other : ComplexFloatArray , transform : ( a : ComplexFloat , b : ComplexFloat ) -> V ) : List < V >

/**
 * Returns a list of values built from the elements of `this` array and the [other] array with the same index
 * using the provided [transform] function applied to each pair of elements.
 * The returned list has length of the shortest array.
 */


public inline fun < V > ComplexDoubleArray . zip ( other : ComplexDoubleArray , transform : ( a : ComplexDouble , b : ComplexDouble ) -> V ) : List < V >


public fun < A : Appendable > ComplexFloatArray . joinTo ( buffer : A , separator : CharSequence = "<STR_LIT:U+002CU+0020>" , prefix : CharSequence = "<STR_LIT>" , postfix : CharSequence = "<STR_LIT>" , limit : Int = - <NUM_LIT:1> , truncated : CharSequence = "<STR_LIT:...>" , transform : ( ( ComplexFloat ) -> CharSequence ) ? = null ) : A

{ <EOL> buffer . append ( prefix ) <EOL> var count = <NUM_LIT:0> <EOL> for ( element in this ) { <EOL> if ( ++ count > <NUM_LIT:1> ) buffer . append ( separator ) <EOL> if ( limit < <NUM_LIT:0> || count <= limit ) { <EOL> if ( transform != null ) <EOL> buffer . append ( transform ( element ) ) <EOL> else <EOL> buffer . append ( element . toString ( ) ) <EOL> } else break <EOL> } <EOL> if ( limit in <NUM_LIT:0> until count ) buffer . append ( truncated ) <EOL> buffer . append ( postfix ) <EOL> return buffer <EOL> }

/**
 * Appends the string from all the elements separated using [separator] and using the given [prefix] and [postfix] if supplied.
 *
 * If the collection could be huge, you can specify a non-negative value of [limit], in which case only the first [limit]
 * elements will be appended, followed by the [truncated] string (which defaults to "...").
 */


public fun < A : Appendable > ComplexDoubleArray . joinTo ( buffer : A , separator : CharSequence = "<STR_LIT:U+002CU+0020>" , prefix : CharSequence = "<STR_LIT>" , postfix : CharSequence = "<STR_LIT>" , limit : Int = - <NUM_LIT:1> , truncated : CharSequence = "<STR_LIT:...>" , transform : ( ( ComplexDouble ) -> CharSequence ) ? = null ) : A


public fun ComplexFloatArray . joinToString ( separator : CharSequence = "<STR_LIT:U+002CU+0020>" , prefix : CharSequence = "<STR_LIT>" , postfix : CharSequence = "<STR_LIT>" , limit : Int = - <NUM_LIT:1> , truncated : CharSequence = "<STR_LIT:...>" , transform : ( ( ComplexFloat ) -> CharSequence ) ? = null ) : String

= <EOL> joinTo ( StringBuilder ( ) , separator , prefix , postfix , limit , truncated , transform ) . toString ( )

/**
 * Creates a string from all the elements separated using [separator] and using the given [prefix] and [postfix] if supplied.
 *
 * If the collection could be huge, you can specify a non-negative value of [limit], in which case only the first [limit]
 * elements will be appended, followed by the [truncated] string (which defaults to "...").
 */


public fun ComplexDoubleArray . joinToString ( separator : CharSequence = "<STR_LIT:U+002CU+0020>" , prefix : CharSequence = "<STR_LIT>" , postfix : CharSequence = "<STR_LIT>" , limit : Int = - <NUM_LIT:1> , truncated : CharSequence = "<STR_LIT:...>" , transform : ( ( ComplexDouble ) -> CharSequence ) ? = null ) : String


public fun ComplexFloatArray . asIterable ( ) : Iterable < ComplexFloat >

{ <EOL> if ( isEmpty ( ) ) return emptyList ( ) <EOL> return Iterable { this . iterator ( ) } <EOL> }

/**
 * Creates an [Iterable] instance that wraps the original array returning its elements when being iterated.
 */


public fun ComplexDoubleArray . asIterable ( ) : Iterable < ComplexDouble >


public fun ComplexFloatArray . asSequence ( ) : Sequence < ComplexFloat >

{ <EOL> if ( isEmpty ( ) ) return emptySequence ( ) <EOL> return Sequence { this . iterator ( ) } <EOL> }

/**
 * Creates a [Sequence] instance that wraps the original array returning its elements when being iterated.
 */


public fun ComplexDoubleArray . asSequence ( ) : Sequence < ComplexDouble >


public fun ComplexFloatArray . sum ( ) : ComplexFloat

{ <EOL> var sum = ComplexFloat ( <NUM_LIT> , <NUM_LIT> ) <EOL> for ( element in this ) { <EOL> sum += element <EOL> } <EOL> return sum <EOL> }

/**
 * Returns the sum of all elements in the array.
 */


public fun ComplexDoubleArray . sum ( ) : ComplexDouble

{ <EOL> var sum = ComplexDouble ( <NUM_LIT:0.0> , <NUM_LIT:0.0> ) <EOL> for ( element in this ) { <EOL> sum += element <EOL> } <EOL> return sum <EOL> }


fun genAnnotations ( annotated : IrAnnotationContainer ? , returnType : Type ? , typeForTypeAnnotations : IrType ? <EOL> )

{ <EOL> if ( annotated == null ) return <EOL> val annotationDescriptorsAlreadyPresent = mutableSetOf < String > ( ) <EOL> val annotations = annotated . annotations <EOL> for ( annotation in annotations ) { <EOL> val applicableTargets = annotation . applicableTargetSet ( ) <EOL> if ( annotated is IrSimpleFunction && annotated . origin === IrDeclarationOrigin . LOCAL_FUNCTION_FOR_LAMBDA && KotlinTarget . FUNCTION !in applicableTargets && KotlinTarget . PROPERTY_GETTER !in applicableTargets && KotlinTarget . PROPERTY_SETTER !in applicableTargets ) { <EOL> assert ( KotlinTarget . EXPRESSION in applicableTargets ) { <EOL> "<STR_LIT>" <EOL> } <EOL> continue <EOL> } <EOL> if ( annotated is IrClass && KotlinTarget . CLASS !in applicableTargets && KotlinTarget . ANNOTATION_CLASS !in applicableTargets ) { <EOL> if ( annotated . visibility == DescriptorVisibilities . LOCAL ) { <EOL> assert ( KotlinTarget . EXPRESSION in applicableTargets ) { <EOL> "<STR_LIT>" <EOL> } <EOL> continue <EOL> } <EOL> } <EOL> genAnnotation ( annotation , null , false ) ? . let { descriptor -> <EOL> annotationDescriptorsAlreadyPresent . add ( descriptor ) <EOL> } <EOL> } <EOL> if ( ! skipNullabilityAnnotations && annotated is IrDeclaration && returnType != null && ! AsmUtil . isPrimitive ( returnType ) ) { <EOL> generateNullabilityAnnotationForCallable ( annotated , annotationDescriptorsAlreadyPresent ) <EOL> } <EOL> generateTypeAnnotations ( annotated , typeForTypeAnnotations ) <EOL> }

/**
 * @param returnType can be null if not applicable (e.g. [annotated] is a class)
 */


private fun isCastToAForwardDeclaration ( session : FirSession , forwardDeclarationType : ConeKotlinType ) : Boolean

{ <EOL> return forwardDeclarationType . toRegularClassSymbol ( session ) ? . forwardDeclarationKindOrNull ( ) != null <EOL> }

/**
 * Here, we only check that we are casting to a forward declaration to suppress a CAST_NEVER_SUCCEEDS warning.
 * The cast would be further checked with FirNativeForwardDeclarationTypeOperatorChecker and FirNativeForwardDeclarationGetClassCallChecker.
 */


@ Test <EOL> fun `should no merge prop and method with the same name` ( )

{ <EOL> testInline ( """<STR_LIT>""" . trimMargin ( ) , configuration ( true ) , cleanupOutput = true ) { <EOL> pagesTransformationStage = { root -> <EOL> val allChildren = root . childrenRec ( ) . filterIsInstance < MemberPageNode > ( ) <EOL> assertEquals ( <NUM_LIT:1> , allChildren . filter { it . name == "<STR_LIT>" } . size , "<STR_LIT>" ) <EOL> } <EOL> } <EOL> }

/**
 * There is a case when a property and fun from different source sets
 * have the same name so pages have the same urls respectively.
 */


fun String . decapitalizeSmartForCompiler ( asciiOnly : Boolean = false ) : String

{ <EOL> if ( isEmpty ( ) || ! isUpperCaseCharAt ( <NUM_LIT:0> , asciiOnly ) ) return this <EOL> if ( length == <NUM_LIT:1> || ! isUpperCaseCharAt ( <NUM_LIT:1> , asciiOnly ) ) { <EOL> return if ( asciiOnly ) decapitalizeAsciiOnly ( ) else replaceFirstChar ( Char :: lowercaseChar ) <EOL> } <EOL> val secondWordStart = ( indices . firstOrNull { ! isUpperCaseCharAt ( it , asciiOnly ) } ? : return toLowerCase ( this , asciiOnly ) ) - <NUM_LIT:1> <EOL> return toLowerCase ( substring ( <NUM_LIT:0> , secondWordStart ) , asciiOnly ) + substring ( secondWordStart ) <EOL> }

/**
 * "FooBar" -> "fooBar"
 * "FOOBar" -> "fooBar"
 * "FOO" -> "foo"
 * "FOO_BAR" -> "foO_BAR"
 */


fun String . decapitalizeSmart ( asciiOnly : Boolean = false ) : String

{ <EOL> return decapitalizeWithUnderscores ( this , asciiOnly ) <EOL> ? : decapitalizeSmartForCompiler ( asciiOnly ) <EOL> }

/**
 * "FooBar" -> "fooBar"
 * "FOOBar" -> "fooBar"
 * "FOO" -> "foo"
 * "FOO_BAR" -> "fooBar"
 * "__F_BAR" -> "fBar"
 */


fun String . capitalizeFirstWord ( asciiOnly : Boolean = false ) : String

{ <EOL> val secondWordStart = indices . drop ( <NUM_LIT:1> ) . firstOrNull { ! isLowerCaseCharAt ( it , asciiOnly ) } <EOL> ? : return toUpperCase ( this , asciiOnly ) <EOL> return toUpperCase ( substring ( <NUM_LIT:0> , secondWordStart ) , asciiOnly ) + substring ( secondWordStart ) <EOL> }

/**
 * "fooBar" -> "FOOBar"
 * "FooBar" -> "FOOBar"
 * "foo" -> "FOO"
 */


private fun decapitalizeWithUnderscores ( str : String , asciiOnly : Boolean ) : String ?

{ <EOL> val words = str . split ( "<STR_LIT:_>" ) . filter { it . isNotEmpty ( ) } <EOL> if ( words . size <= <NUM_LIT:1> ) return null <EOL> val builder = StringBuilder ( ) <EOL> words . forEachIndexed { index , word -> <EOL> if ( index == <NUM_LIT:0> ) { <EOL> builder . append ( toLowerCase ( word , asciiOnly ) ) <EOL> } else { <EOL> builder . append ( toUpperCase ( word . first ( ) . toString ( ) , asciiOnly ) ) <EOL> builder . append ( toLowerCase ( word . drop ( <NUM_LIT:1> ) , asciiOnly ) ) <EOL> } <EOL> } <EOL> return builder . toString ( ) <EOL> }

/**
 * FOOBAR -> null
 * FOO_BAR -> "fooBar"
 * FOO_BAR_BAZ -> "fooBarBaz"
 * "__F_BAR" -> "fBar"
 * "_F_BAR" -> "fBar"
 * "F_BAR" -> "fBar"
 */


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . a ( href : String ? = null , target : String ? = null , classes : String ? = null , crossinline block : A . ( ) -> Unit = { } , ) : HTMLAnchorElement

= A ( attributesMapOf ( "<STR_LIT>" , href , "<STR_LIT>" , target , "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLAnchorElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . abbr ( classes : String ? = null , crossinline block : ABBR . ( ) -> Unit = { } ) : HTMLElement

= ABBR ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )

/**
 * Abbreviated form (e.g., WWW, HTTP,etc.)
 */


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . address ( classes : String ? = null , crossinline block : ADDRESS . ( ) -> Unit = { } ) : HTMLElement

= ADDRESS ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . area ( shape : AreaShape ? = null , alt : String ? = null , classes : String ? = null , crossinline block : AREA . ( ) -> Unit = { } , ) : HTMLAreaElement

= AREA ( attributesMapOf ( "<STR_LIT>" , shape ? . enumEncode ( ) , "<STR_LIT>" , alt , "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLAreaElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . article ( classes : String ? = null , crossinline block : ARTICLE . ( ) -> Unit = { } ) : HTMLElement

= ARTICLE ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )

/**
 * Self-contained syndicatable or reusable composition
 */


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . aside ( classes : String ? = null , crossinline block : ASIDE . ( ) -> Unit = { } ) : HTMLElement

= ASIDE ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )

/**
 * Sidebar for tangentially related content
 */


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . audio ( classes : String ? = null , crossinline block : AUDIO . ( ) -> Unit = { } ) : HTMLAudioElement

= AUDIO ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLAudioElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . b ( classes : String ? = null , crossinline block : B . ( ) -> Unit = { } ) : HTMLElement

= B ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . base ( classes : String ? = null , crossinline block : BASE . ( ) -> Unit = { } ) : HTMLBaseElement

= BASE ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLBaseElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . bdi ( classes : String ? = null , crossinline block : BDI . ( ) -> Unit = { } ) : HTMLElement

= BDI ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )

/**
 * Text directionality isolation
 */


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . bdo ( classes : String ? = null , crossinline block : BDO . ( ) -> Unit = { } ) : HTMLElement

= BDO ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . blockQuote ( classes : String ? = null , crossinline block : BLOCKQUOTE . ( ) -> Unit = { } ) : HTMLElement

= BLOCKQUOTE ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . body ( classes : String ? = null , crossinline block : BODY . ( ) -> Unit = { } ) : HTMLBodyElement

= BODY ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLBodyElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . br ( classes : String ? = null , crossinline block : BR . ( ) -> Unit = { } ) : HTMLBRElement

= BR ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLBRElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . button ( formEncType : ButtonFormEncType ? = null , formMethod : ButtonFormMethod ? = null , name : String ? = null , type : ButtonType ? = null , classes : String ? = null , crossinline block : BUTTON . ( ) -> Unit = { } , ) : HTMLButtonElement

= BUTTON ( attributesMapOf ( "<STR_LIT>" , formEncType ? . enumEncode ( ) , "<STR_LIT>" , formMethod ? . enumEncode ( ) , "<STR_LIT:name>" , name , "<STR_LIT:type>" , type ? . enumEncode ( ) , "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLButtonElement


@ HtmlTagMarker <EOL> public fun TagConsumer < HTMLElement > . canvas ( classes : String ? = null , content : String = "<STR_LIT>" ) : <EOL> HTMLCanvasElement

= CANVAS ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , { + content } ) as HTMLCanvasElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . canvas ( classes : String ? = null , crossinline block : CANVAS . ( ) -> Unit = { } ) : HTMLCanvasElement

= CANVAS ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLCanvasElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . caption ( classes : String ? = null , crossinline block : CAPTION . ( ) -> Unit = { } ) : HTMLElement

= CAPTION ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . cite ( classes : String ? = null , crossinline block : CITE . ( ) -> Unit = { } ) : HTMLElement

= CITE ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . code ( classes : String ? = null , crossinline block : CODE . ( ) -> Unit = { } ) : HTMLElement

= CODE ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . col ( classes : String ? = null , crossinline block : COL . ( ) -> Unit = { } ) : HTMLTableColElement

= COL ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLTableColElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . colGroup ( classes : String ? = null , crossinline block : COLGROUP . ( ) -> Unit = { } ) : HTMLTableColElement

= COLGROUP ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLTableColElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . dataList ( classes : String ? = null , crossinline block : DATALIST . ( ) -> Unit = { } ) : HTMLDataListElement

= DATALIST ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLDataListElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . dd ( classes : String ? = null , crossinline block : DD . ( ) -> Unit = { } ) : HTMLElement

= DD ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . del ( classes : String ? = null , crossinline block : DEL . ( ) -> Unit = { } ) : HTMLElement

= DEL ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . details ( classes : String ? = null , crossinline block : DETAILS . ( ) -> Unit = { } ) : HTMLDetailsElement

= DETAILS ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLDetailsElement

/**
 * Disclosure control for hiding details
 */


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . dfn ( classes : String ? = null , crossinline block : DFN . ( ) -> Unit = { } ) : HTMLElement

= DFN ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . dialog ( classes : String ? = null , crossinline block : DIALOG . ( ) -> Unit = { } ) : HTMLDialogElement

= DIALOG ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLDialogElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . div ( classes : String ? = null , crossinline block : DIV . ( ) -> Unit = { } ) : HTMLDivElement

= DIV ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLDivElement

/**
 * Generic language/style container
 */


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . dl ( classes : String ? = null , crossinline block : DL . ( ) -> Unit = { } ) : HTMLElement

= DL ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . dt ( classes : String ? = null , crossinline block : DT . ( ) -> Unit = { } ) : HTMLElement

= DT ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . em ( classes : String ? = null , crossinline block : EM . ( ) -> Unit = { } ) : HTMLElement

= EM ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . embed ( classes : String ? = null , crossinline block : EMBED . ( ) -> Unit = { } ) : HTMLEmbedElement

= EMBED ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLEmbedElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . fieldSet ( classes : String ? = null , crossinline block : FIELDSET . ( ) -> Unit = { } ) : HTMLFieldSetElement

= FIELDSET ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLFieldSetElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . figcaption ( classes : String ? = null , crossinline block : FIGCAPTION . ( ) -> Unit = { } ) : HTMLElement

= FIGCAPTION ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . figure ( classes : String ? = null , crossinline block : FIGURE . ( ) -> Unit = { } ) : HTMLElement

= FIGURE ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . footer ( classes : String ? = null , crossinline block : FOOTER . ( ) -> Unit = { } ) : HTMLElement

= FOOTER ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . form ( action : String ? = null , encType : FormEncType ? = null , method : FormMethod ? = null , classes : String ? = null , crossinline block : FORM . ( ) -> Unit = { } , ) : HTMLFormElement

= FORM ( attributesMapOf ( "<STR_LIT>" , action , "<STR_LIT>" , encType ? . enumEncode ( ) , "<STR_LIT>" , method ? . enumEncode ( ) , "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLFormElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . h1 ( classes : String ? = null , crossinline block : H1 . ( ) -> Unit = { } ) : HTMLHeadingElement

= H1 ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLHeadingElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . h2 ( classes : String ? = null , crossinline block : H2 . ( ) -> Unit = { } ) : HTMLHeadingElement

= H2 ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLHeadingElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . h3 ( classes : String ? = null , crossinline block : H3 . ( ) -> Unit = { } ) : HTMLHeadingElement

= H3 ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLHeadingElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . h4 ( classes : String ? = null , crossinline block : H4 . ( ) -> Unit = { } ) : HTMLHeadingElement

= H4 ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLHeadingElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . h5 ( classes : String ? = null , crossinline block : H5 . ( ) -> Unit = { } ) : HTMLHeadingElement

= H5 ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLHeadingElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . h6 ( classes : String ? = null , crossinline block : H6 . ( ) -> Unit = { } ) : HTMLHeadingElement

= H6 ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLHeadingElement


@ HtmlTagMarker <EOL> @ Suppress ( "<STR_LIT:DEPRECATION>" ) <EOL> @ Deprecated ( "<STR_LIT>" ) <EOL> public fun TagConsumer < HTMLElement > . head ( content : String = "<STR_LIT>" ) : HTMLHeadElement

= HEAD ( emptyMap , this ) <EOL> . visitAndFinalize ( this , { + content } ) as HTMLHeadElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . head ( crossinline block : HEAD . ( ) -> Unit = { } ) : <EOL> HTMLHeadElement

= HEAD ( emptyMap , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLHeadElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . `header` ( classes : String ? = null , crossinline block : HEADER . ( ) -> Unit = { } ) : HTMLElement

= HEADER ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )

/**
 * Introductory or navigational aids for a page or section
 */


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . hr ( classes : String ? = null , crossinline block : HR . ( ) -> Unit = { } ) : HTMLHRElement

= HR ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLHRElement


@ HtmlTagMarker <EOL> @ Suppress ( "<STR_LIT:DEPRECATION>" ) <EOL> @ Deprecated ( "<STR_LIT>" ) <EOL> public fun TagConsumer < HTMLElement > . html ( content : String = "<STR_LIT>" , namespace : String ? = null ) : <EOL> HTMLHtmlElement

= HTML ( emptyMap , this , namespace ) <EOL> . visitAndFinalize ( this , { + content } ) as HTMLHtmlElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . html ( namespace : String ? = null , crossinline block : HTML . ( ) -> Unit = { } ) : HTMLHtmlElement

= HTML ( emptyMap , this , namespace ) <EOL> . visitAndFinalize ( this , block ) as HTMLHtmlElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . i ( classes : String ? = null , crossinline block : I . ( ) -> Unit = { } ) : HTMLElement

= I ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )


@ HtmlTagMarker <EOL> public fun TagConsumer < HTMLElement > . iframe ( sandbox : IframeSandbox ? = null , classes : String ? = null , content : String = "<STR_LIT>" , ) : HTMLElement

= IFRAME ( attributesMapOf ( "<STR_LIT>" , sandbox ? . enumEncode ( ) , "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , { + content } )


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . iframe ( sandbox : IframeSandbox ? = null , classes : String ? = null , crossinline block : IFRAME . ( ) -> Unit = { } , ) : HTMLElement

= IFRAME ( attributesMapOf ( "<STR_LIT>" , sandbox ? . enumEncode ( ) , "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . img ( alt : String ? = null , src : String ? = null , loading : ImgLoading ? = null , classes : String ? = null , crossinline block : IMG . ( ) -> Unit = { } , ) : HTMLImageElement

= IMG ( attributesMapOf ( "<STR_LIT>" , alt , "<STR_LIT:src>" , src , "<STR_LIT>" , loading ? . enumEncode ( ) , "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLImageElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . input ( type : InputType ? = null , formEncType : InputFormEncType ? = null , formMethod : InputFormMethod ? = null , name : String ? = null , classes : String ? = null , crossinline block : INPUT . ( ) -> Unit = { } , ) : HTMLInputElement

= INPUT ( attributesMapOf ( "<STR_LIT:type>" , type ? . enumEncode ( ) , "<STR_LIT>" , formEncType ? . enumEncode ( ) , "<STR_LIT>" , formMethod ? . enumEncode ( ) , "<STR_LIT:name>" , name , "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLInputElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . ins ( classes : String ? = null , crossinline block : INS . ( ) -> Unit = { } ) : HTMLElement

= INS ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . kbd ( classes : String ? = null , crossinline block : KBD . ( ) -> Unit = { } ) : HTMLElement

= KBD ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )

/**
 * Text to be entered by the user
 */


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . keyGen ( keyType : KeyGenKeyType ? = null , classes : String ? = null , crossinline block : KEYGEN . ( ) -> Unit = { } , ) : HTMLElement

= KEYGEN ( attributesMapOf ( "<STR_LIT>" , keyType ? . enumEncode ( ) , "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )

/**
 * Cryptographic key-pair generator form control
 */


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . label ( classes : String ? = null , crossinline block : LABEL . ( ) -> Unit = { } ) : HTMLLabelElement

= LABEL ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLLabelElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . legend ( classes : String ? = null , crossinline block : LEGEND . ( ) -> Unit = { } ) : HTMLLegendElement

= LEGEND ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLLegendElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . li ( classes : String ? = null , crossinline block : LI . ( ) -> Unit = { } ) : HTMLLIElement

= LI ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLLIElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . link ( href : String ? = null , rel : String ? = null , type : String ? = null , crossinline block : LINK . ( ) -> Unit = { } , ) : HTMLLinkElement

= LINK ( attributesMapOf ( "<STR_LIT>" , href , "<STR_LIT>" , rel , "<STR_LIT:type>" , type ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLLinkElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . main ( classes : String ? = null , crossinline block : MAIN . ( ) -> Unit = { } ) : HTMLElement

= MAIN ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )

/**
 * Container for the dominant contents of another element
 */


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . map ( name : String ? = null , classes : String ? = null , crossinline block : MAP . ( ) -> Unit = { } , ) : HTMLMapElement

= MAP ( attributesMapOf ( "<STR_LIT:name>" , name , "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLMapElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . mark ( classes : String ? = null , crossinline block : MARK . ( ) -> Unit = { } ) : HTMLElement

= MARK ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . meta ( name : String ? = null , content : String ? = null , charset : String ? = null , crossinline block : META . ( ) -> Unit = { } , ) : HTMLMetaElement

= META ( attributesMapOf ( "<STR_LIT:name>" , name , "<STR_LIT>" , content , "<STR_LIT>" , charset ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLMetaElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . meter ( classes : String ? = null , crossinline block : METER . ( ) -> Unit = { } ) : HTMLMeterElement

= METER ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLMeterElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . nav ( classes : String ? = null , crossinline block : NAV . ( ) -> Unit = { } ) : HTMLElement

= NAV ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )

/**
 * Section with navigational links
 */


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . noScript ( classes : String ? = null , crossinline block : NOSCRIPT . ( ) -> Unit = { } ) : HTMLElement

= NOSCRIPT ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . htmlObject ( classes : String ? = null , crossinline block : OBJECT . ( ) -> Unit = { } ) : HTMLElement

= OBJECT ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . ol ( classes : String ? = null , crossinline block : OL . ( ) -> Unit = { } ) : HTMLElement

= OL ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . optGroup ( label : String ? = null , classes : String ? = null , crossinline block : OPTGROUP . ( ) -> Unit = { } , ) : HTMLOptGroupElement

= OPTGROUP ( attributesMapOf ( "<STR_LIT>" , label , "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLOptGroupElement


@ HtmlTagMarker <EOL> public fun TagConsumer < HTMLElement > . option ( classes : String ? = null , content : String = "<STR_LIT>" ) : <EOL> HTMLOptionElement

= OPTION ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , { + content } ) as HTMLOptionElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . option ( classes : String ? = null , crossinline block : OPTION . ( ) -> Unit = { } ) : HTMLOptionElement

= OPTION ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLOptionElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . output ( classes : String ? = null , crossinline block : OUTPUT . ( ) -> Unit = { } ) : HTMLOutputElement

= OUTPUT ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLOutputElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . p ( classes : String ? = null , crossinline block : P . ( ) -> Unit = { } ) : HTMLParagraphElement

= P ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLParagraphElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . `param` ( name : String ? = null , `value` : String ? = null , crossinline block : PARAM . ( ) -> Unit = { } , ) : HTMLParamElement

= PARAM ( attributesMapOf ( "<STR_LIT:name>" , name , "<STR_LIT:value>" , value ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLParamElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . picture ( crossinline block : PICTURE . ( ) -> Unit = { } ) : <EOL> HTMLPictureElement

= PICTURE ( emptyMap , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLPictureElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . pre ( classes : String ? = null , crossinline block : PRE . ( ) -> Unit = { } ) : HTMLPreElement

= PRE ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLPreElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . progress ( classes : String ? = null , crossinline block : PROGRESS . ( ) -> Unit = { } ) : HTMLProgressElement

= PROGRESS ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLProgressElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . q ( classes : String ? = null , crossinline block : Q . ( ) -> Unit = { } ) : HTMLElement

= Q ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . rp ( classes : String ? = null , crossinline block : RP . ( ) -> Unit = { } ) : HTMLElement

= RP ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )

/**
 * Parenthesis for ruby annotation text
 */


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . rt ( classes : String ? = null , crossinline block : RT . ( ) -> Unit = { } ) : HTMLElement

= RT ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . ruby ( classes : String ? = null , crossinline block : RUBY . ( ) -> Unit = { } ) : HTMLElement

= RUBY ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . s ( classes : String ? = null , crossinline block : S . ( ) -> Unit = { } ) : HTMLElement

= S ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . samp ( classes : String ? = null , crossinline block : SAMP . ( ) -> Unit = { } ) : HTMLElement

= SAMP ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )


@ HtmlTagMarker <EOL> @ Suppress ( "<STR_LIT:DEPRECATION>" ) <EOL> @ Deprecated ( "<STR_LIT>" ) <EOL> public fun TagConsumer < HTMLElement > . script ( type : String ? = null , src : String ? = null , crossorigin : ScriptCrossorigin ? = null , content : String = "<STR_LIT>" , ) : HTMLScriptElement

= SCRIPT ( attributesMapOf ( "<STR_LIT:type>" , type , "<STR_LIT:src>" , src , "<STR_LIT>" , crossorigin ? . enumEncode ( ) ) , this ) <EOL> . visitAndFinalize ( this , { + content } ) as HTMLScriptElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . script ( type : String ? = null , src : String ? = null , crossorigin : ScriptCrossorigin ? = null , crossinline block : SCRIPT . ( ) -> Unit = { } , ) : HTMLScriptElement

= SCRIPT ( attributesMapOf ( "<STR_LIT:type>" , type , "<STR_LIT:src>" , src , "<STR_LIT>" , crossorigin ? . enumEncode ( ) ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLScriptElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . section ( classes : String ? = null , crossinline block : SECTION . ( ) -> Unit = { } ) : HTMLElement

= SECTION ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )

/**
 * Generic document or application section
 */


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . select ( classes : String ? = null , crossinline block : SELECT . ( ) -> Unit = { } ) : HTMLSelectElement

= SELECT ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLSelectElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . small ( classes : String ? = null , crossinline block : SMALL . ( ) -> Unit = { } ) : HTMLElement

= SMALL ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . source ( classes : String ? = null , crossinline block : SOURCE . ( ) -> Unit = { } ) : HTMLSourceElement

= SOURCE ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLSourceElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . span ( classes : String ? = null , crossinline block : SPAN . ( ) -> Unit = { } ) : HTMLSpanElement

= SPAN ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLSpanElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . strong ( classes : String ? = null , crossinline block : STRONG . ( ) -> Unit = { } ) : HTMLElement

= STRONG ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )


@ HtmlTagMarker <EOL> @ Suppress ( "<STR_LIT:DEPRECATION>" ) <EOL> @ Deprecated ( "<STR_LIT>" ) <EOL> public fun TagConsumer < HTMLElement > . style ( type : String ? = null , content : String = "<STR_LIT>" ) : <EOL> HTMLStyleElement

= STYLE ( attributesMapOf ( "<STR_LIT:type>" , type ) , this ) <EOL> . visitAndFinalize ( this , { + content } ) as HTMLStyleElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . style ( type : String ? = null , crossinline block : STYLE . ( ) -> Unit = { } ) : HTMLStyleElement

= STYLE ( attributesMapOf ( "<STR_LIT:type>" , type ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLStyleElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . sub ( classes : String ? = null , crossinline block : SUB . ( ) -> Unit = { } ) : HTMLElement

= SUB ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . summary ( classes : String ? = null , crossinline block : SUMMARY . ( ) -> Unit = { } ) : HTMLElement

= SUMMARY ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . sup ( classes : String ? = null , crossinline block : SUP . ( ) -> Unit = { } ) : HTMLElement

= SUP ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . table ( classes : String ? = null , crossinline block : TABLE . ( ) -> Unit = { } ) : HTMLTableElement

= TABLE ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLTableElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . tbody ( classes : String ? = null , crossinline block : TBODY . ( ) -> Unit = { } ) : HTMLTableSectionElement

= TBODY ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLTableSectionElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . td ( classes : String ? = null , crossinline block : TD . ( ) -> Unit = { } ) : HTMLTableCellElement

= TD ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLTableCellElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . template ( classes : String ? = null , crossinline block : TEMPLATE . ( ) -> Unit = { } ) : HTMLTemplateElement

= TEMPLATE ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLTemplateElement


@ HtmlTagMarker <EOL> public fun TagConsumer < HTMLElement > . textArea ( rows : String ? = null , cols : String ? = null , wrap : TextAreaWrap ? = null , classes : String ? = null , content : String = "<STR_LIT>" , ) : HTMLTextAreaElement

= TEXTAREA ( attributesMapOf ( "<STR_LIT>" , rows , "<STR_LIT>" , cols , "<STR_LIT>" , wrap ? . enumEncode ( ) , "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , { + content } ) as HTMLTextAreaElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . textArea ( rows : String ? = null , cols : String ? = null , wrap : TextAreaWrap ? = null , classes : String ? = null , crossinline block : TEXTAREA . ( ) -> Unit = { } , ) : HTMLTextAreaElement

= TEXTAREA ( attributesMapOf ( "<STR_LIT>" , rows , "<STR_LIT>" , cols , "<STR_LIT>" , wrap ? . enumEncode ( ) , "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLTextAreaElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . tfoot ( classes : String ? = null , crossinline block : TFOOT . ( ) -> Unit = { } ) : HTMLTableSectionElement

= TFOOT ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLTableSectionElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . th ( scope : ThScope ? = null , classes : String ? = null , crossinline block : TH . ( ) -> Unit = { } , ) : HTMLTableCellElement

= TH ( attributesMapOf ( "<STR_LIT>" , scope ? . enumEncode ( ) , "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLTableCellElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . thead ( classes : String ? = null , crossinline block : THEAD . ( ) -> Unit = { } ) : HTMLTableSectionElement

= THEAD ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLTableSectionElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . time ( classes : String ? = null , crossinline block : TIME . ( ) -> Unit = { } ) : HTMLTimeElement

= TIME ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLTimeElement

/**
 * Machine-readable equivalent of date- or time-related data
 */


@ HtmlTagMarker <EOL> public fun TagConsumer < HTMLElement > . title ( content : String = "<STR_LIT>" ) : HTMLTitleElement

= TITLE ( emptyMap , this ) <EOL> . visitAndFinalize ( this , { + content } ) as HTMLTitleElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . title ( crossinline block : TITLE . ( ) -> Unit = { } ) : <EOL> HTMLTitleElement

= TITLE ( emptyMap , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLTitleElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . tr ( classes : String ? = null , crossinline block : TR . ( ) -> Unit = { } ) : HTMLTableRowElement

= TR ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLTableRowElement


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . u ( classes : String ? = null , crossinline block : U . ( ) -> Unit = { } ) : HTMLElement

= U ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . ul ( classes : String ? = null , crossinline block : UL . ( ) -> Unit = { } ) : HTMLElement

= UL ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . htmlVar ( classes : String ? = null , crossinline block : VAR . ( ) -> Unit = { } ) : HTMLElement

= VAR ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block )


@ HtmlTagMarker <EOL> public inline fun TagConsumer < HTMLElement > . video ( classes : String ? = null , crossinline block : VIDEO . ( ) -> Unit = { } ) : HTMLVideoElement

= VIDEO ( attributesMapOf ( "<STR_LIT:class>" , classes ) , this ) <EOL> . visitAndFinalize ( this , block ) as HTMLVideoElement


public abstract fun getModule ( element : PsiElement , contextualModule : KtModule ? ) : KtModule

/**
 * Returns a [KtModule] for a given [element] in the context of the [contextualModule].
 *
 * The contextual module is the [KtModule] from which [getModule] is called. It is a way to disambiguate the [KtModule] of [element]s
 * with whom multiple modules might be associated. In particular:
 *
 * 1. It allows replacing the original [KtModule] of [element] with another module, e.g. for supporting outsider files (see below).
 * 2. It helps to distinguish between multiple possible [KtModule]s for library elements.
 *
 * #### Outsider Modules
 *
 * Normally, every Kotlin source file either belongs to some module (e.g. a source module, or a library module), or is self-contained
 * (a script file, or a file outside content roots). However, in certain cases there might be special modules that include both
 * existing source files, and also some additional files.
 *
 * An example of such a module is one that owns an 'outsider' source file. Outsiders are used in IntelliJ for displaying files that
 * technically belong to some module, but are not included in the module's content roots (e.g. a file from a previous VCS revision).
 * As there might be cross-references between the outsider file and other files in the module, they need to be analyzed as a single
 * synthetic module. Inside an analysis session for such a module (which would be the [contextualModule]), sources that originally
 * belong to a source module should be treated rather as a part of the synthetic one.
 */


@ KtModuleStructureInternals <EOL> public fun < R > withDanglingFileResolutionMode ( file : KtFile , mode : DanglingFileResolutionMode , action : ( ) -> R ) : R

{ <EOL> require ( file . isDangling ) { "<STR_LIT>" } <EOL> require ( file . originalFile != file ) { "<STR_LIT>" } <EOL> val modeState = getOrCreateDanglingFileResolutionModeState ( file ) <EOL> val oldValue = modeState . get ( ) <EOL> try { <EOL> modeState . set ( mode ) <EOL> return action ( ) <EOL> } finally { <EOL> modeState . set ( oldValue ) <EOL> } <EOL> }

/**
 * Runs the [action] with a resolution mode being explicitly set for the dangling [file].
 *
 * Avoid using this function in client-side code. Use `analyzeCopy {}` from Analysis API instead.
 */


actual override public fun addAll ( elements : Collection < E > ) : Boolean

{ <EOL> var changed = false <EOL> for ( v in elements ) { <EOL> if ( add ( v ) ) changed = true <EOL> } <EOL> return changed <EOL> }

/**
 * Adds all of the elements of the specified collection to this collection.
 *
 * @return `true` if any of the specified elements was added to the collection, `false` if the collection was not modified.
 */


actual override fun remove ( element : E ) : Boolean

{ <EOL> val it = iterator ( ) <EOL> while ( it . hasNext ( ) ) { <EOL> if ( it . next ( ) == element ) { <EOL> it . remove ( ) <EOL> return true <EOL> } <EOL> } <EOL> return false <EOL> }

/**
 * Removes a single instance of the specified element from this
 * collection, if it is present.
 *
 * @return `true` if the element has been successfully removed; `false` if it was not present in the collection.
 */


actual override public fun removeAll ( elements : Collection < E > ) : Boolean

= ( this as MutableIterable < E > ) . removeAll { it in elements }

/**
 * Removes all of this collection's elements that are also contained in the specified collection.
 *
 * @return `true` if any of the specified elements was removed from the collection, `false` if the collection was not modified.
 */


actual override public fun retainAll ( elements : Collection < E > ) : Boolean

= ( this as MutableIterable < E > ) . retainAll { it in elements }

/**
 * Retains only the elements in this collection that are contained in the specified collection.
 *
 * @return `true` if any element was removed from the collection, `false` if the collection was not modified.
 */


{ <EOL> val it = iterator ( ) <EOL> while ( it . hasNext ( ) ) { <EOL> it . next ( ) <EOL> it . remove ( ) <EOL> } <EOL> }

/**
 * Removes all elements from this collection.
 */


fun Canvas . drawObject ( detectedObject : DetectedObject , paint : Paint , labelPaint : TextPaint , bounds : PreviewImageBounds = bounds ( ) )

{ <EOL> val rect = RectF ( bounds . toViewX ( detectedObject . xMin ) , bounds . toViewY ( detectedObject . yMin ) , bounds . toViewX ( detectedObject . xMax ) , bounds . toViewY ( detectedObject . yMax ) ) <EOL> val frameWidth = paint . strokeWidth * detectedObject . probability <EOL> drawRect ( rect , Paint ( paint ) . apply { strokeWidth = frameWidth } ) <EOL> if ( detectedObject . label != null ) { <EOL> val label = "<STR_LIT>" + "<STR_LIT>" . format ( detectedObject . probability ) <EOL> drawText ( label , rect . left , rect . top - labelPaint . fontMetrics . descent - frameWidth / <NUM_LIT:2> , labelPaint ) <EOL> } <EOL> }

/**
 * Draw given [detectedObject] on the [Canvas] using [paint] for the bounding box and [labelPaint] for the label.
 *
 * If the preview image coordinates do not match the [Canvas] coordinates,
 * [bounds] of the image preview should be provided.
 *
 * @see [PreviewImageBounds]
 */


fun Canvas . drawObjects ( detectedObjects : List < DetectedObject > , paint : Paint , labelPaint : TextPaint , bounds : PreviewImageBounds = bounds ( ) )

{ <EOL> detectedObjects . forEach { drawObject ( it , paint , labelPaint , bounds ) } <EOL> }

/**
 * Draw given [detectedObjects] on the [Canvas] using [paint] for the bounding box and [labelPaint] for the label.
 *
 * If the preview image coordinates do not match the [Canvas] coordinates,
 * [bounds] of the image preview should be provided.
 *
 * @see [PreviewImageBounds]
 */


fun Canvas . drawPose ( detectedPose : DetectedPose , landmarkPaint : Paint , edgePaint : Paint , landmarkRadius : Float , bounds : PreviewImageBounds = bounds ( ) )

{ <EOL> detectedPose . edges . forEach { edge -> <EOL> drawLine ( bounds . toViewX ( edge . start . x ) , bounds . toViewY ( edge . start . y ) , bounds . toViewX ( edge . end . x ) , bounds . toViewY ( edge . end . y ) , edgePaint ) <EOL> } <EOL> detectedPose . landmarks . forEach { landmark -> <EOL> drawCircle ( bounds . toViewX ( landmark . x ) , bounds . toViewY ( landmark . y ) , landmarkRadius , landmarkPaint ) <EOL> } <EOL> }

/**
 * Draw given [detectedPose] on the [Canvas] using [landmarkPaint] and [landmarkRadius] for the pose vertices,
 * and [edgePaint] for the pose edges.
 *
 * If the preview image coordinates do not match the [Canvas] coordinates,
 * [bounds] of the image preview should be provided.
 *
 * @see [PreviewImageBounds]
 */


fun Canvas . drawMultiplePoses ( detectedPoses : MultiPoseDetectionResult , landmarkPaint : Paint , edgePaint : Paint , objectPaint : Paint , labelPaint : TextPaint , landmarkRadius : Float , bounds : PreviewImageBounds = bounds ( ) )

{ <EOL> detectedPoses . poses . forEach { ( detectedObject , detectedPose ) -> <EOL> drawPose ( detectedPose , landmarkPaint , edgePaint , landmarkRadius , bounds ) <EOL> drawObject ( detectedObject , objectPaint , labelPaint , bounds ) <EOL> } <EOL> }

/**
 * Draw given [detectedPoses] on the [Canvas] using [landmarkPaint] and [landmarkRadius] for the pose vertices,
 * [edgePaint] for the poses edges, [objectPaint] for the bounding box and [labelPaint] for the label.
 *
 * If the preview image coordinates do not match the [Canvas] coordinates,
 * [bounds] of the image preview should be provided.
 *
 * @see [PreviewImageBounds]
 */


fun Canvas . drawLandmarks ( landmarks : List < Landmark > , paint : Paint , radius : Float , bounds : PreviewImageBounds = bounds ( ) )

{ <EOL> landmarks . forEach { landmark -> drawLandmark ( landmark , paint , radius , bounds ) } <EOL> }

/**
 * Draw given [landmarks] on the [Canvas] using [paint] and [radius].
 *
 * If the preview image coordinates do not match the [Canvas] coordinates,
 * [bounds] of the image preview should be provided.
 *
 * @see [PreviewImageBounds]
 */


fun Canvas . drawLandmark ( landmark : Landmark , paint : Paint , radius : Float , bounds : PreviewImageBounds = bounds ( ) )

{ <EOL> drawCircle ( bounds . toViewX ( landmark . x ) , bounds . toViewY ( landmark . y ) , radius , paint ) <EOL> }

/**
 * Draw a given [landmark] on the [Canvas] using [paint] and [radius].
 *
 * If the preview image coordinates do not match the [Canvas] coordinates,
 * [bounds] of the image preview should be provided.
 *
 * @see [PreviewImageBounds]
 */


= PreviewImageBounds ( <NUM_LIT> , <NUM_LIT> , width . toFloat ( ) , height . toFloat ( ) )

/**
 * Create [PreviewImageBounds] originating in the top-left corner of this [Canvas] object and matching its dimensions.
 */


override fun transform ( internalClassName : String , methodNode : MethodNode )

{ <EOL> val insns = methodNode . instructions . toArray ( ) . apply { reverse ( ) } <EOL> val insnsToRemove = arrayListOf < AbstractInsnNode > ( ) <EOL> val currentLabels = hashSetOf < LabelNode > ( ) <EOL> val labelsToReplace = hashMapOf < LabelNode , JumpInsnNode > ( ) <EOL> var pendingGoto : JumpInsnNode ? = null <EOL> for ( insn in insns ) { <EOL> when { <EOL> insn is LabelNode -> { <EOL> currentLabels . add ( insn ) <EOL> pendingGoto ? . let { labelsToReplace [ insn ] = it } <EOL> } <EOL> insn . opcode == Opcodes . GOTO -> { <EOL> pendingGoto = insn as JumpInsnNode <EOL> if ( insn . label in currentLabels ) { <EOL> insnsToRemove . add ( insn ) <EOL> } else { <EOL> currentLabels . clear ( ) <EOL> } <EOL> } <EOL> insn is LineNumberNode || ( insn . isMeaningful && insn . opcode != Opcodes . NOP ) -> { <EOL> currentLabels . clear ( ) <EOL> pendingGoto = null <EOL> } <EOL> } <EOL> } <EOL> if ( labelsToReplace . isNotEmpty ( ) ) { <EOL> insns . filterIsInstance < JumpInsnNode > ( ) . forEach { rewriteLabelIfNeeded ( it , labelsToReplace ) } <EOL> } <EOL> for ( insnToRemove in insnsToRemove ) { <EOL> methodNode . instructions . insertBefore ( insnToRemove , InsnNode ( Opcodes . NOP ) ) <EOL> methodNode . instructions . remove ( insnToRemove ) <EOL> } <EOL> }

/**
 * Removes redundant GOTO's in the following cases:
 * (1) subsequent labels
 * ...
 * goto Label (can be removed)
 * nop (any number of them, or maybe none; will be removed by RedundantNopsCleanupMethodTransformer)
 * Label:
 * ...
 * (2) indirect goto
 * ...
 * <branch instruction> Label (can be rewrote to <branch instruction> Label2)
 * ...
 * Label:
 * goto Label2 (must not be removed due to the previous instruction that can fallthrough on this goto)
 * ...
 */


fun reluLenetOnMnistWithIntermediateSave ( )

{ <EOL> val ( train , test ) = mnist ( ) <EOL> SaveTrainedModelHelper ( ) . trainAndSave ( train , test , lenet5 ( ) , MODEL_SAVE_PATH , <NUM_LIT> ) <EOL> Sequential . loadDefaultModelConfiguration ( File ( MODEL_SAVE_PATH ) ) . use { <EOL> it . compile ( optimizer = SGD ( learningRate = <NUM_LIT> ) , loss = Losses . SOFT_MAX_CROSS_ENTROPY_WITH_LOGITS , metric = Metrics . ACCURACY ) <EOL> it . loadWeights ( File ( MODEL_SAVE_PATH ) ) <EOL> val accuracy = it . evaluate ( test ) . metrics [ Metrics . ACCURACY ] ? : <NUM_LIT:0.0> <EOL> println ( "<STR_LIT>" ) <EOL> } <EOL> }

/**
 * This examples demonstrates running Save and Load for prediction on [mnist] dataset.
 */


override fun tryToMatch ( startIndex : Int , testString : CharSequence , matchResult : MatchResultImpl ) : Int

{ <EOL> children . forEach { <EOL> val shift = it . matches ( startIndex , testString , matchResult ) <EOL> if ( shift >= <NUM_LIT:0> ) { <EOL> return next . matches ( startIndex , testString , matchResult ) <EOL> } <EOL> } <EOL> return - <NUM_LIT:1> <EOL> }

/** Returns startIndex+shift, the next position to match */


{ <EOL> children . forEach { <EOL> if ( it . matches ( startIndex , testString , matchResult ) >= <NUM_LIT:0> ) { <EOL> return - <NUM_LIT:1> <EOL> } <EOL> } <EOL> return next . matches ( startIndex , testString , matchResult ) <EOL> }


fun KotlinTypeMarker . getAnnotationFirstArgumentValue ( fqName : FqName ) : Any ?

/**
 * @return value of the first argument of the annotation with the given [fqName], if the annotation is present and
 * the argument is of a primitive type or a String, or null otherwise.
 *
 * Note that this method returns null if no arguments are provided, even if the corresponding annotation parameter has a default value.
 *
 * TODO: provide a more granular & elaborate API here to reduce confusion
 */


override fun createCandidate ( towerCandidate : CandidateWithBoundDispatchReceiver , explicitReceiverKind : ExplicitReceiverKind , extensionReceiverCandidates : List < ReceiverValueWithSmartCastInfo > ) : MyCandidate

= error ( "<STR_LIT>" )

/**
 * The function is called only inside [NoExplicitReceiverScopeTowerProcessor] with [TowerData.BothTowerLevelAndContextReceiversGroup].
 * This case involves only [SimpleCandidateFactory].
 */


@ kotlin . internal . InlineOnly <EOL> internal actual inline fun String . nativeIndexOf ( ch : Char , fromIndex : Int ) : Int

= ( this as java . lang . String ) . indexOf ( ch . code , fromIndex )

/**
 * Returns the index within this string of the first occurrence of the specified character, starting from the specified offset.
 */


@ kotlin . internal . InlineOnly <EOL> internal actual inline fun String . nativeIndexOf ( str : String , fromIndex : Int ) : Int

= ( this as java . lang . String ) . indexOf ( str , fromIndex )

/**
 * Returns the index within this string of the first occurrence of the specified substring, starting from the specified offset.
 */


@ kotlin . internal . InlineOnly <EOL> internal actual inline fun String . nativeLastIndexOf ( ch : Char , fromIndex : Int ) : Int

= ( this as java . lang . String ) . lastIndexOf ( ch . code , fromIndex )

/**
 * Returns the index within this string of the last occurrence of the specified character.
 */


@ kotlin . internal . InlineOnly <EOL> internal actual inline fun String . nativeLastIndexOf ( str : String , fromIndex : Int ) : Int

= ( this as java . lang . String ) . lastIndexOf ( str , fromIndex )

/**
 * Returns the index within this string of the last occurrence of the specified character, starting from the specified offset.
 */


@ Suppress ( "<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>" ) <EOL> public actual fun String ? . equals ( other : String ? , ignoreCase : Boolean = false ) : Boolean

{ <EOL> if ( this === null ) <EOL> return other === null <EOL> return if ( ! ignoreCase ) <EOL> ( this as java . lang . String ) . equals ( other ) <EOL> else <EOL> ( this as java . lang . String ) . equalsIgnoreCase ( other ) <EOL> }

/**
 * Returns `true` if this string is equal to [other], optionally ignoring character case.
 *
 * Two strings are considered to be equal if they have the same length and the same character at the same index.
 * If [ignoreCase] is true, the result of `Char.uppercaseChar().lowercaseChar()` on each character is compared.
 *
 * @param ignoreCase `true` to ignore character case when comparing strings. By default `false`.
 */


@ Suppress ( "<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>" ) <EOL> public actual fun String . replace ( oldChar : Char , newChar : Char , ignoreCase : Boolean = false ) : String

{ <EOL> if ( ! ignoreCase ) return ( this as java . lang . String ) . replace ( oldChar , newChar ) <EOL> return buildString ( length ) { <EOL> this@replace . forEach { c -> <EOL> append ( if ( c . equals ( oldChar , ignoreCase ) ) newChar else c ) <EOL> } <EOL> } <EOL> }

/**
 * Returns a new string with all occurrences of [oldChar] replaced with [newChar].
 *
 * @sample samples.text.Strings.replace
 */


@ Suppress ( "<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>" ) <EOL> public actual fun String . replace ( oldValue : String , newValue : String , ignoreCase : Boolean = false ) : String

{ <EOL> run { <EOL> var occurrenceIndex : Int = indexOf ( oldValue , <NUM_LIT:0> , ignoreCase ) <EOL> if ( occurrenceIndex < <NUM_LIT:0> ) return this <EOL> val oldValueLength = oldValue . length <EOL> val searchStep = oldValueLength . coerceAtLeast ( <NUM_LIT:1> ) <EOL> val newLengthHint = length - oldValueLength + newValue . length <EOL> if ( newLengthHint < <NUM_LIT:0> ) throw OutOfMemoryError ( ) <EOL> val stringBuilder = StringBuilder ( newLengthHint ) <EOL> var i = <NUM_LIT:0> <EOL> do { <EOL> stringBuilder . append ( this , i , occurrenceIndex ) . append ( newValue ) <EOL> i = occurrenceIndex + oldValueLength <EOL> if ( occurrenceIndex >= length ) break <EOL> occurrenceIndex = indexOf ( oldValue , occurrenceIndex + searchStep , ignoreCase ) <EOL> } while ( occurrenceIndex > <NUM_LIT:0> ) <EOL> return stringBuilder . append ( this , i , length ) . toString ( ) <EOL> } <EOL> }

/**
 * Returns a new string obtained by replacing all occurrences of the [oldValue] substring in this string
 * with the specified [newValue] string.
 *
 * @sample samples.text.Strings.replace
 */


@ Suppress ( "<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>" ) <EOL> public actual fun String . replaceFirst ( oldChar : Char , newChar : Char , ignoreCase : Boolean = false ) : String

{ <EOL> val index = indexOf ( oldChar , ignoreCase = ignoreCase ) <EOL> return if ( index < <NUM_LIT:0> ) this else this . replaceRange ( index , index + <NUM_LIT:1> , newChar . toString ( ) ) <EOL> }

/**
 * Returns a new string with the first occurrence of [oldChar] replaced with [newChar].
 */


@ Suppress ( "<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>" ) <EOL> public actual fun String . replaceFirst ( oldValue : String , newValue : String , ignoreCase : Boolean = false ) : String

{ <EOL> val index = indexOf ( oldValue , ignoreCase = ignoreCase ) <EOL> return if ( index < <NUM_LIT:0> ) this else this . replaceRange ( index , index + oldValue . length , newValue ) <EOL> }

/**
 * Returns a new string obtained by replacing the first occurrence of the [oldValue] substring in this string
 * with the specified [newValue] string.
 */


@ Deprecated ( "<STR_LIT>" , ReplaceWith ( "<STR_LIT>" , "<STR_LIT>" ) ) <EOL> @ DeprecatedSinceKotlin ( warningSince = "<STR_LIT:1.5>" ) <EOL> @ kotlin . internal . InlineOnly <EOL> public actual inline fun String . toUpperCase ( ) : String

= ( this as java . lang . String ) . toUpperCase ( )

/**
 * Returns a copy of this string converted to upper case using the rules of the default locale.
 */


@ SinceKotlin ( "<STR_LIT:1.5>" ) <EOL> @ WasExperimental ( ExperimentalStdlibApi :: class ) <EOL> @ kotlin . internal . InlineOnly <EOL> public actual inline fun String . uppercase ( ) : String

= ( this as java . lang . String ) . toUpperCase ( Locale . ROOT )

/**
 * Returns a copy of this string converted to upper case using Unicode mapping rules of the invariant locale.
 *
 * This function supports one-to-many and many-to-one character mapping,
 * thus the length of the returned string can be different from the length of the original string.
 *
 * @sample samples.text.Strings.uppercase
 */


@ Deprecated ( "<STR_LIT>" , ReplaceWith ( "<STR_LIT>" , "<STR_LIT>" ) ) <EOL> @ DeprecatedSinceKotlin ( warningSince = "<STR_LIT:1.5>" ) <EOL> @ kotlin . internal . InlineOnly <EOL> public actual inline fun String . toLowerCase ( ) : String

= ( this as java . lang . String ) . toLowerCase ( )

/**
 * Returns a copy of this string converted to lower case using the rules of the default locale.
 */


@ SinceKotlin ( "<STR_LIT:1.5>" ) <EOL> @ WasExperimental ( ExperimentalStdlibApi :: class ) <EOL> @ kotlin . internal . InlineOnly <EOL> public actual inline fun String . lowercase ( ) : String

= ( this as java . lang . String ) . toLowerCase ( Locale . ROOT )

/**
 * Returns a copy of this string converted to lower case using Unicode mapping rules of the invariant locale.
 *
 * This function supports one-to-many and many-to-one character mapping,
 * thus the length of the returned string can be different from the length of the original string.
 *
 * @sample samples.text.Strings.lowercase
 */


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> public actual fun CharArray . concatToString ( ) : String

{ <EOL> return String ( this ) <EOL> }

/**
 * Concatenates characters in this [CharArray] into a String.
 */


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> @ Suppress ( "<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>" ) <EOL> public actual fun CharArray . concatToString ( startIndex : Int = <NUM_LIT:0> , endIndex : Int = this . size ) : String

{ <EOL> AbstractList . checkBoundsIndexes ( startIndex , endIndex , this . size ) <EOL> return String ( this , startIndex , endIndex - startIndex ) <EOL> }

/**
 * Concatenates characters in this [CharArray] or its subrange into a String.
 *
 * @param startIndex the beginning (inclusive) of the subrange of characters, 0 by default.
 * @param endIndex the end (exclusive) of the subrange of characters, size of this array by default.
 *
 * @throws IndexOutOfBoundsException if [startIndex] is less than zero or [endIndex] is greater than the size of this array.
 * @throws IllegalArgumentException if [startIndex] is greater than [endIndex].
 */


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> @ Suppress ( "<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>" ) <EOL> public actual fun String . toCharArray ( startIndex : Int = <NUM_LIT:0> , endIndex : Int = this . length ) : CharArray

{ <EOL> AbstractList . checkBoundsIndexes ( startIndex , endIndex , length ) <EOL> return toCharArray ( CharArray ( endIndex - startIndex ) , <NUM_LIT:0> , startIndex , endIndex ) <EOL> }

/**
 * Returns a [CharArray] containing characters of this string or its substring.
 *
 * @param startIndex the beginning (inclusive) of the substring, 0 by default.
 * @param endIndex the end (exclusive) of the substring, length of this string by default.
 *
 * @throws IndexOutOfBoundsException if [startIndex] is less than zero or [endIndex] is greater than the length of this string.
 * @throws IllegalArgumentException if [startIndex] is greater than [endIndex].
 */