private fun TypeSystemCommonSuperTypesContext . checkRecursion ( originalTypesForCst : List < SimpleTypeMarker > , typeArgumentsForSuperConstructorParameter : List < TypeArgumentMarker > , parameter : TypeParameterMarker , ) : Boolean

{ <EOL> if ( parameter . getVariance ( ) == TypeVariance . IN ) <EOL> return false <EOL> val originalTypesSet = originalTypesForCst . mapTo ( mutableSetOf ( ) ) { it . lowerBoundIfFlexible ( ) . originalIfDefinitelyNotNullable ( ) } <EOL> val typeArgumentsTypeSet = typeArgumentsForSuperConstructorParameter . mapTo ( mutableSetOf ( ) ) { it . getType ( ) . lowerBoundIfFlexible ( ) . originalIfDefinitelyNotNullable ( ) } <EOL> if ( originalTypesSet . size != typeArgumentsTypeSet . size ) <EOL> return false <EOL> val originalTypeConstructorSet by lazy { typeConstructorsWithExpandedStarProjections ( originalTypesSet ) . toSet ( ) } <EOL> for ( argumentType in typeArgumentsTypeSet ) { <EOL> if ( argumentType in originalTypesSet ) continue <EOL> var starProjectionFound = false <EOL> for ( supertype in supertypesIfCapturedStarProjection ( argumentType ) . orEmpty ( ) ) { <EOL> if ( supertype . lowerBoundIfFlexible ( ) . originalIfDefinitelyNotNullable ( ) . typeConstructor ( ) !in originalTypeConstructorSet ) <EOL> return false <EOL> else starProjectionFound = true <EOL> } <EOL> if ( ! starProjectionFound ) <EOL> return false <EOL> } <EOL> return true <EOL> }

/**
 * This function returns true in case of detected recursion in type arguments.
 *
 * For situations with self type arguments (or similar ones), the call of this function
 * prevents too deep type argument analysis during super type calculation.
 * Typical examples use something like this interface in hierarchy:
 * ```
 * interface Some<T : Some<T>>
 * ```
 * From point of view of this function we have here something like `Some<CapturedType>` in [originalTypesForCst],
 * and the captured type in argument has the same `Some<CapturedType>` as its constructor supertype.
 *
 * See also the test 'multirecursion.kt' and comment to the fix of [KT-38544](https://youtrack.jetbrains.com/issue/KT-38544):
 * for single super type constructor create star projection argument when types for that argument are equal to the original types.
 * Captured star projections are replaced with their corresponding supertypes during this check.
 * The check is skipped for contravariant parameters, for which recursive cst calculation never happens.
 */


fun < T , R > Iterator < T > . transformAsSequence ( func : Sequence < T > . ( ) -> Sequence < R > ) : Iterator < R >

= <EOL> func ( this . asSequence ( ) ) . iterator ( )

/** Allows to transform an Iterator using the Sequence functions. */


fun < T > Iterator < Iterator < T > > . flatten ( ) : Iterator < T >

= transformAsSequence { flatMap { it . asSequence ( ) } }


fun < T , R > Iterator < T > . map ( func : ( T ) -> R ) : Iterator < R >

= transformAsSequence { map ( func ) }

/** Maps the values of the iterator lazily using [func]. */


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

= transformAsSequence { filter ( predicate ) }

/** Filters the values of the iterator lazily using [predicate]. */


fun < T > Iterator < T > . partition ( size : Int , cutIncomplete : Boolean = false ) : Iterator < List < T > >

= <EOL> PartitioningIterator ( this , size , cutIncomplete )

/** Partitions the values of the iterator lazily in groups of [size]. */


private fun checkAndReportDeprecatedMppProperties ( project : Project )

{ <EOL> val projectProperties = project . kotlinPropertiesProvider <EOL> val usedProperties = deprecatedMppProperties . mapNotNull { propertyName -> <EOL> if ( propertyName in propertiesSetByPlugin && projectProperties . mpp13XFlagsSetByPlugin ) <EOL> return@mapNotNull null <EOL> propertyName . takeIf { projectProperties . property ( propertyName ) . orNull != null } <EOL> } <EOL> if ( usedProperties . isEmpty ( ) ) return <EOL> project . kotlinToolingDiagnosticsCollector . reportOncePerGradleBuild ( project , KotlinToolingDiagnostics . PreHMPPFlagsError ( usedProperties ) ) <EOL> }

/**
 * Declared properties have to be captured during plugin application phase before the HMPP migration util sets them.
 * Warnings have to be reported only for successfully evaluated projects without errors.
 */


protected open fun defaultLanguageVersionSettings ( ) : LanguageVersionSettings

{ <EOL> return CompilerTestLanguageVersionSettings ( DEFAULT_DIAGNOSTIC_TESTS_FEATURES , LanguageVersionSettingsImpl . DEFAULT . apiVersion , LanguageVersionSettingsImpl . DEFAULT . languageVersion ) <EOL> }

/**
 * Version settings used when no test data files have overriding version directives
 */


@ Test <EOL> fun testCancelAndResumeWithException ( )

= runTest { <EOL> var continuation : Continuation < Unit > ? = null <EOL> val job = launch { <EOL> try { <EOL> expect ( <NUM_LIT:2> ) <EOL> suspendCancellableCoroutine < Unit > { c -> <EOL> continuation = c <EOL> } <EOL> } catch ( e : CancellationException ) { <EOL> expect ( <NUM_LIT:3> ) <EOL> } <EOL> } <EOL> expect ( <NUM_LIT:1> ) <EOL> yield ( ) <EOL> job . cancel ( ) <EOL> yield ( ) <EOL> continuation ! ! . resumeWithException ( TestException ( ) ) <EOL> finish ( <NUM_LIT:4> ) <EOL> }

/**
 * Cancelling outer job may, in practise, race with attempt to resume continuation and resumes
 * should be ignored. Here suspended coroutine is cancelled but then resumed with exception.
 */


@ Test <EOL> fun testCancelAndResume ( )

= runTest { <EOL> var continuation : Continuation < Unit > ? = null <EOL> val job = launch { <EOL> try { <EOL> expect ( <NUM_LIT:2> ) <EOL> suspendCancellableCoroutine < Unit > { c -> <EOL> continuation = c <EOL> } <EOL> } catch ( e : CancellationException ) { <EOL> expect ( <NUM_LIT:3> ) <EOL> } <EOL> } <EOL> expect ( <NUM_LIT:1> ) <EOL> yield ( ) <EOL> job . cancel ( ) <EOL> yield ( ) <EOL> continuation ! ! . resume ( Unit ) <EOL> finish ( <NUM_LIT:4> ) <EOL> }


fun printAllImports ( printer : Appendable ) : Boolean

{ <EOL> var atLeastOneImport = false <EOL> for ( ( packageName , entities ) in imports ) { <EOL> for ( entity in entities ) { <EOL> atLeastOneImport = true <EOL> printer . append ( "<STR_LIT>" , packageName , "<STR_LIT:.>" , entity , "<STR_LIT:\n>" ) <EOL> } <EOL> } <EOL> return atLeastOneImport <EOL> }

/**
 * Prints all the collected imports in alphabetical order.
 *
 * @return `true` if at least one import was printed, `false` if no imports were printed.
 */


public fun Operation < BufferedImage , FloatData > . fileLoader ( ) : DataLoader < File >

= <EOL> PreprocessingFileDataLoader ( this )

/**
 * Returns a [DataLoader] instance which loads images from files and uses this [Operation] to process them.
 */


public fun Operation < BufferedImage , FloatData > . inputStreamLoader ( ) : DataLoader < InputStream >

= <EOL> PreprocessingInputStreamDataLoader ( this )

/**
 * Returns a [DataLoader] instance which loads images from input streams and uses this [Operation] to process them.
 */


fun getReplResult ( id : String ) : Any ?

/**
 * Returns the REPL result for a given id or `null` if no result exists or `null` was the result.
 * @param id unique id for the given REPL result. Normally this is [DisplayResult.id].
 * @return the repl result associated with the given [id] or `null` if no result was found.
 */


fun addReplResult ( result : Any ? ) : String

/**
 * Add a REPL result without an ID. An ID will be auto-generated and returned.
 *
 * @param result the REPL result to store.
 * @return the id the [result] was stored under.
 */


fun setReplResult ( id : String , result : Any ? , )

/**
 * Sets the REPL result for a given id.
 * @param id unique id for the given REPL result. Normally this is [DisplayResult.id].
 * @param result the REPL result to store.
 */


fun removeReplResult ( id : String ) : Boolean

/**
 * Removes the REPL result with the given [id] from the holder.
 * Returns `true` if an entry was removed, `false` if not.
 */


private fun getCombinedFirKotlinDeclaredMemberScope ( symbolWithMembers : KtSymbolWithMembers ) : FirContainingNamesAwareScope

{ <EOL> val useSiteSession = analysisSession . useSiteSession <EOL> return when ( symbolWithMembers ) { <EOL> is KtFirScriptSymbol -> FirScriptDeclarationsScope ( useSiteSession , symbolWithMembers . firSymbol . fir ) <EOL> else -> useSiteSession . declaredMemberScope ( symbolWithMembers . getFirForScope ( ) , memberRequiredPhase = null ) <EOL> } <EOL> }

/**
 * Returns a declared member scope which contains both static and non-static callables, as well as all classifiers. Java classes need to
 * be handled specially, because [declaredMemberScope] doesn't handle Java enhancement properly.
 */


fun registerServices ( project : Project )

{ <EOL> val mbs : MBeanServer = ManagementFactory . getPlatformMBeanServer ( ) <EOL> registerStatsService ( mbs , DefaultKotlinBuildStatsBeanService ( project , getBeanName ( DEFAULT_SERVICE_QUALIFIER ) ) , KotlinBuildStatsMXBean :: class . java , DEFAULT_SERVICE_QUALIFIER ) <EOL> registerStatsService ( mbs , Pre232IdeaKotlinBuildStatsBeanService ( project , getBeanName ( LEGACY_SERVICE_QUALIFIER ) ) , Pre232IdeaKotlinBuildStatsMXBean :: class . java , LEGACY_SERVICE_QUALIFIER ) <EOL> }

/**
 * Registers the Kotlin build stats services for the given project.
 *
 * The registry must be closed at the end of the usage.
 */


{ <EOL> for ( service in services . values ) { <EOL> service . close ( ) <EOL> } <EOL> services . clear ( ) <EOL> }

/**
 * Unregisters all the registered JMX services and may release other resources allocated by a service.
 */


{ <EOL> val verb = when ( this ) { <EOL> is KeepOriginalDependency -> "<STR_LIT>" <EOL> is Exclude -> "<STR_LIT>" <EOL> is ChooseVisibleSourceSets -> "<STR_LIT>" <EOL> } <EOL> return "<STR_LIT>" <EOL> }

/** Evaluate and store the value, as the [dependency] will be lost during Gradle instant execution */


= <EOL> super . toString ( ) + "<STR_LIT>" + allVisibleSourceSetNames . joinToString ( "<STR_LIT:U+002CU+0020>" , "<STR_LIT:[>" , "<STR_LIT:]>" ) { <EOL> ( if ( it in visibleSourceSetNamesExcludingDependsOn ) "<STR_LIT:*>" else "<STR_LIT>" ) + it <EOL> }


= "<STR_LIT>"


private fun processDependency ( dependency : ResolvedDependencyResult , sourceSetsVisibleInParents : Set < String > , ) : MetadataDependencyResolution

{ <EOL> val module = dependency . selected <EOL> val moduleId = module . id <EOL> val compositeMetadataArtifact = params <EOL> . resolvedMetadataConfiguration <EOL> . getArtifacts ( dependency ) <EOL> . singleOrNull ( ) <EOL> ? . takeIf { it . variant . attributes . containsMultiplatformAttributes } <EOL> ? : return MetadataDependencyResolution . KeepOriginalDependency ( module ) <EOL> logger . debug ( "<STR_LIT>" ) <EOL> val mppDependencyMetadataExtractor = params . projectStructureMetadataExtractorFactory . create ( compositeMetadataArtifact ) <EOL> val projectStructureMetadata = mppDependencyMetadataExtractor . getProjectStructureMetadata ( ) <EOL> ? : return MetadataDependencyResolution . KeepOriginalDependency ( module ) <EOL> if ( ! projectStructureMetadata . isPublishedAsRoot ) { <EOL> error ( "<STR_LIT>" ) <EOL> } <EOL> val isResolvedToProject = moduleId in params . build <EOL> val sourceSetVisibility = <EOL> params . sourceSetVisibilityProvider . getVisibleSourceSets ( params . sourceSetName , dependency , projectStructureMetadata , isResolvedToProject ) <EOL> val allVisibleSourceSets = sourceSetVisibility . visibleSourceSetNames <EOL> val requestedTransitiveDependencies : Set < ModuleDependencyIdentifier > = <EOL> mutableSetOf < ModuleDependencyIdentifier > ( ) . apply { <EOL> projectStructureMetadata . sourceSetModuleDependencies . forEach { ( sourceSetName , moduleDependencies ) -> <EOL> if ( sourceSetName in allVisibleSourceSets ) { <EOL> addAll ( moduleDependencies ) <EOL> } <EOL> } <EOL> } <EOL> val transitiveDependenciesToVisit = module . dependencies <EOL> . filterIsInstance < ResolvedDependencyResult > ( ) <EOL> . filterTo ( mutableSetOf ( ) ) { it . toModuleDependencyIdentifier ( ) in requestedTransitiveDependencies } <EOL> if ( params . sourceSetName in params . platformCompilationSourceSets && ! isResolvedToProject ) <EOL> return MetadataDependencyResolution . Exclude . PublishedPlatformSourceSetDependency ( module , transitiveDependenciesToVisit ) <EOL> val visibleSourceSetsExcludingDependsOn = allVisibleSourceSets . filterTo ( mutableSetOf ( ) ) { it !in sourceSetsVisibleInParents } <EOL> val metadataProvider = when ( mppDependencyMetadataExtractor ) { <EOL> is ProjectMppDependencyProjectStructureMetadataExtractor -> ProjectMetadataProvider ( sourceSetMetadataOutputs = params . projectData [ mppDependencyMetadataExtractor . projectPath ] ? . sourceSetMetadataOutputs ? . getOrThrow ( ) ? : error ( "<STR_LIT>" ) ) <EOL> is JarMppDependencyProjectStructureMetadataExtractor -> ArtifactMetadataProvider ( CompositeMetadataArtifactImpl ( moduleDependencyIdentifier = dependency . toModuleDependencyIdentifier ( ) , moduleDependencyVersion = module . moduleVersion ? . version ? : "<STR_LIT>" , kotlinProjectStructureMetadata = projectStructureMetadata , primaryArtifactFile = mppDependencyMetadataExtractor . primaryArtifactFile , hostSpecificArtifactFilesBySourceSetName = sourceSetVisibility . hostSpecificMetadataArtifactBySourceSet ) ) <EOL> } <EOL> return MetadataDependencyResolution . ChooseVisibleSourceSets ( dependency = module , projectStructureMetadata = projectStructureMetadata , allVisibleSourceSetNames = allVisibleSourceSets , visibleSourceSetNamesExcludingDependsOn = visibleSourceSetsExcludingDependsOn , visibleTransitiveDependencies = transitiveDependenciesToVisit , metadataProvider = metadataProvider ) <EOL> }

/**
 * If the [module] is an MPP metadata module, we extract [KotlinProjectStructureMetadata] and do the following:
 *
 * * get the [KotlinProjectStructureMetadata] from the dependency (either deserialize from the artifact or build from the project)
 *
 * * determine the set *S* of source sets that should be seen in the [kotlinSourceSet] by finding which variants the [parent]
 * dependency got resolved for the compilations where [kotlinSourceSet] participates:
 *
 * * transform the single Kotlin metadata artifact into a set of Kotlin metadata artifacts for the particular source sets in
 * *S* and add the results as [MetadataDependencyResolution.ChooseVisibleSourceSets]
 *
 * * based on the project structure metadata, determine which of the module's dependencies are requested by the
 * source sets in *S*, then consider only these transitive dependencies, ignore the others;
 */


private fun ResolvedDependencyResult . toModuleDependencyIdentifier ( ) : ModuleDependencyIdentifier

{ <EOL> val component = selected <EOL> return when ( val componentId = component . id ) { <EOL> is ModuleComponentIdentifier -> ModuleDependencyIdentifier ( componentId . group , componentId . module ) <EOL> is ProjectComponentIdentifier -> { <EOL> if ( componentId in params . build ) { <EOL> params . projectData [ componentId . projectPath ] ? . moduleId ? . getOrThrow ( ) <EOL> ? : error ( "<STR_LIT>" ) <EOL> } else { <EOL> ModuleDependencyIdentifier ( component . moduleVersion ? . group ? : "<STR_LIT>" , component . moduleVersion ? . name ? : "<STR_LIT>" ) <EOL> } <EOL> } <EOL> else -> error ( "<STR_LIT>" ) <EOL> } <EOL> }

/**
 * Behaves as [ModuleIds.fromComponent]
 */


fun accepts ( value : Any ? , property : KProperty < * > , ) : Boolean

/**
 * Tells if this handler accepts the given property
 * Called for each variable in the cells executed by users,
 * except those names are starting from [TEMP_PROPERTY_PREFIX]
 * or those that have been already consumed by another handler
 *
 * @param value Property value
 * @param property Property compile-time information
 */


fun finalize ( host : KotlinKernelHost )

/**
 * Called one time per cell after all the variables have been processed,
 * and only if this handler accepted at least one variable
 *
 * @param host Host for running executions
 */


fun acceptsType ( type : KType ) : Boolean

/**
 * Returns true if this converter accepts [type], false otherwise
 */


public fun < T > face ( column : ColumnReference < T > , ) : NonPositionalMapping < T , FontFace >

{ <EOL> return addNonPositionalMapping < T , FontFace > ( FONT_FACE , column . name ( ) , null ) <EOL> }

/**
 * Maps the `face` aesthetic to a data column by [ColumnReference].
 *
 * @param column the data column to be mapped.
 * @return a [NonPositionalMapping] object representing the mapping.
 */


public fun < T > face ( column : KProperty < T > , ) : NonPositionalMapping < T , FontFace >

{ <EOL> return addNonPositionalMapping < T , FontFace > ( FONT_FACE , column . name , null ) <EOL> }

/**
 * Maps the `face` aesthetic to a data column by [KProperty].
 *
 * @param column the data column to be mapped.
 * @return a [NonPositionalMapping] object representing the mapping.
 */


public fun face ( column : String , ) : NonPositionalMapping < Any ? , FontFace >

{ <EOL> return addNonPositionalMapping < Any ? , FontFace > ( FONT_FACE , column , null ) <EOL> }

/**
 * Maps the `face` aesthetic to a data column by [String].
 *
 * @param column the data column to be mapped.
 * @return a [NonPositionalMapping] object representing the mapping.
 */


public fun < T > face ( values : Iterable < T > , name : String ? = null ) : NonPositionalMapping < T , FontFace >

{ <EOL> return addNonPositionalMapping < T , FontFace > ( FONT_FACE , values . toList ( ) , name , null ) <EOL> }

/**
 * Maps the `face` aesthetic to the iterable of values.
 *
 * @param values the iterable of values to be mapped.
 * @param name optional name for this aesthetic mapping.
 * @return a [NonPositionalMapping] object representing the mapping.
 */


public fun < T > face ( values : DataColumn < T > , ) : NonPositionalMapping < T , FontFace >

{ <EOL> return addNonPositionalMapping < T , FontFace > ( FONT_FACE , values , null ) <EOL> }

/**
 * Maps the `face` aesthetic to a data column.
 *
 * @param values the data column to be mapped.
 * @return a [NonPositionalMapping] object representing the mapping.
 */


{ <EOL> val ( train , test ) = mnist ( ) <EOL> lenet5Classic . use { <EOL> val timeStopping = TimeStopping ( seconds = <NUM_LIT> , verbose = true ) <EOL> it . compile ( optimizer = Adam ( clipGradient = ClipGradientByValue ( <NUM_LIT> ) ) , loss = Losses . SOFT_MAX_CROSS_ENTROPY_WITH_LOGITS , metric = Metrics . ACCURACY ) <EOL> it . logSummary ( ) <EOL> it . fit ( dataset = train , epochs = EPOCHS , batchSize = TRAINING_BATCH_SIZE , callback = timeStopping ) <EOL> val accuracy = it . evaluate ( dataset = test , batchSize = TEST_BATCH_SIZE ) . metrics [ Metrics . ACCURACY ] <EOL> println ( "<STR_LIT>" ) <EOL> } <EOL> }

/**
 * This example shows how to do image classification from scratch using [lenet5Classic], without leveraging pre-trained weights or a pre-made model.
 * We demonstrate the workflow on the Mnist classification dataset.
 *
 * It includes:
 * - dataset loading from S3
 * - callback definition
 * - model compilation with [TimeStopping] callback
 * - model summary
 * - model training
 * - model evaluation
 */


private inline fun < A : KtCallableDeclaration > forEachCallableProvider ( packageFqName : FqName , name : Name , getCallables : ( CallableId ) -> Collection < A > , provide : LLFirKotlinSymbolProvider . ( CallableId , Collection < A > ) -> Unit , )

{ <EOL> if ( ! symbolNamesProvider . mayHaveTopLevelCallable ( packageFqName , name ) ) return <EOL> val callableId = CallableId ( packageFqName , name ) <EOL> getCallables ( callableId ) <EOL> . groupBy { getModule ( it ) } <EOL> . forEach { ( ktModule , callables ) -> <EOL> val provider = providersByKtModule [ ktModule ] ? : return@forEach <EOL> provider . provide ( callableId , callables ) <EOL> } <EOL> }

/**
 * Calls [provide] on those providers which can contribute a callable of the given name.
 */


private fun KotlinDeclarationProvider . getTopLevelCallables ( callableId : CallableId ) : List < KtCallableDeclaration >

= <EOL> getTopLevelFunctions ( callableId ) + getTopLevelProperties ( callableId )

/**
 * Callables are provided very rarely (compared to functions/properties individually), so it's okay to hit indices twice here.
 */


= Identity

/**
 * Returns an [Identity] position adjustment.
 *
 * With `Identity`, no position adjustment will be done.
 *
 * @return [Identity] position adjustment object.
 */


= Stack

/**
 * Returns a [Stack] position adjustment.
 *
 * With `Stack`, overlapping elements will be stacked on top of each other.
 *
 * @return [Stack] position adjustment object.
 */


public fun dodge ( width : Double ? = null ) : Position

= Dodge ( width )

/**
 * Returns a [Dodge] position adjustment.
 *
 * With `Dodge`, overlapping elements will be dodged side-to-side.
 *
 * @param width the dodging width, different from the individual element's width.
 * @return [Dodge] position adjustment object.
 */


public fun jitter ( width : Double ? = null , height : Double ? = null ) : Position

= Jitter ( width , height )

/**
 * Returns a [Jitter] position adjustment.
 *
 * With `Jitter`, a small random offset will be applied to avoid overlap.
 *
 * @param width the amount of vertical jitter.
 * @param height the amount of horizontal jitter.
 * @return [Jitter] position adjustment object.
 */


public fun nudge ( x : Double ? = null , y : Double ? = null ) : Position

= Nudge ( x , y )

/**
 * Returns a [Nudge] position adjustment.
 *
 * With `Nudge`, elements will be moved a fixed distance vertically and/or horizontally.
 *
 * @param x the vertical distance to move.
 * @param y the horizontal distance to move.
 * @return [Nudge] position adjustment object.
 */


public fun jitterDodge ( dodgeWidth : Double ? = null , jitterWidth : Double ? = null , jitterHeight : Double ? = null ) : Position

= JitterDodge ( dodgeWidth , jitterWidth , jitterHeight )

/**
 * Returns a [JitterDodge] position adjustment.
 *
 * With `JitterDodge`, dodge and jitter adjustments will be combined.
 *
 * @param dodgeWidth the dodging width in the x-direction.
 * @param jitterWidth the jitter width in the x-direction.
 * @param jitterHeight the jitter height in the y-direction.
 * @return [JitterDodge] position adjustment object.
 */


@ kotlin . internal . InlineOnly <EOL> public actual inline fun < T > Array < out T > . elementAt ( index : Int ) : T

{ <EOL> return get ( index ) <EOL> }

/**
 * Returns an element at the given [index] or throws an [IndexOutOfBoundsException] if the [index] is out of bounds of this array.
 *
 * @sample samples.collections.Collections.Elements.elementAt
 */


@ kotlin . internal . InlineOnly <EOL> public actual inline fun ByteArray . elementAt ( index : Int ) : Byte

{ <EOL> return get ( index ) <EOL> }


@ kotlin . internal . InlineOnly <EOL> public actual inline fun ShortArray . elementAt ( index : Int ) : Short

{ <EOL> return get ( index ) <EOL> }


@ kotlin . internal . InlineOnly <EOL> public actual inline fun IntArray . elementAt ( index : Int ) : Int

{ <EOL> return get ( index ) <EOL> }


@ kotlin . internal . InlineOnly <EOL> public actual inline fun LongArray . elementAt ( index : Int ) : Long

{ <EOL> return get ( index ) <EOL> }


@ kotlin . internal . InlineOnly <EOL> public actual inline fun FloatArray . elementAt ( index : Int ) : Float

{ <EOL> return get ( index ) <EOL> }


@ kotlin . internal . InlineOnly <EOL> public actual inline fun DoubleArray . elementAt ( index : Int ) : Double

{ <EOL> return get ( index ) <EOL> }


@ kotlin . internal . InlineOnly <EOL> public actual inline fun BooleanArray . elementAt ( index : Int ) : Boolean

{ <EOL> return get ( index ) <EOL> }


@ kotlin . internal . InlineOnly <EOL> public actual inline fun CharArray . elementAt ( index : Int ) : Char

{ <EOL> return get ( index ) <EOL> }


public actual fun < T > Array < out T > . asList ( ) : List < T >

{ <EOL> return object : AbstractList < T > ( ) , RandomAccess { <EOL> override val size : Int get ( ) = this@asList . size <EOL> override fun isEmpty ( ) : Boolean = this@asList . isEmpty ( ) <EOL> override fun contains ( element : T ) : Boolean = this@asList . contains ( element ) <EOL> override fun get ( index : Int ) : T = this@asList [ index ] <EOL> override fun indexOf ( element : T ) : Int = this@asList . indexOf ( element ) <EOL> override fun lastIndexOf ( element : T ) : Int = this@asList . lastIndexOf ( element ) <EOL> } <EOL> }

/**
 * Returns a [List] that wraps the original array.
 */


public actual fun ByteArray . asList ( ) : List < Byte >

{ <EOL> return object : AbstractList < Byte > ( ) , RandomAccess { <EOL> override val size : Int get ( ) = this@asList . size <EOL> override fun isEmpty ( ) : Boolean = this@asList . isEmpty ( ) <EOL> override fun contains ( element : Byte ) : Boolean = this@asList . contains ( element ) <EOL> override fun get ( index : Int ) : Byte = this@asList [ index ] <EOL> override fun indexOf ( element : Byte ) : Int = this@asList . indexOf ( element ) <EOL> override fun lastIndexOf ( element : Byte ) : Int = this@asList . lastIndexOf ( element ) <EOL> } <EOL> }


public actual fun ShortArray . asList ( ) : List < Short >

{ <EOL> return object : AbstractList < Short > ( ) , RandomAccess { <EOL> override val size : Int get ( ) = this@asList . size <EOL> override fun isEmpty ( ) : Boolean = this@asList . isEmpty ( ) <EOL> override fun contains ( element : Short ) : Boolean = this@asList . contains ( element ) <EOL> override fun get ( index : Int ) : Short = this@asList [ index ] <EOL> override fun indexOf ( element : Short ) : Int = this@asList . indexOf ( element ) <EOL> override fun lastIndexOf ( element : Short ) : Int = this@asList . lastIndexOf ( element ) <EOL> } <EOL> }


public actual fun IntArray . asList ( ) : List < Int >

{ <EOL> return object : AbstractList < Int > ( ) , RandomAccess { <EOL> override val size : Int get ( ) = this@asList . size <EOL> override fun isEmpty ( ) : Boolean = this@asList . isEmpty ( ) <EOL> override fun contains ( element : Int ) : Boolean = this@asList . contains ( element ) <EOL> override fun get ( index : Int ) : Int = this@asList [ index ] <EOL> override fun indexOf ( element : Int ) : Int = this@asList . indexOf ( element ) <EOL> override fun lastIndexOf ( element : Int ) : Int = this@asList . lastIndexOf ( element ) <EOL> } <EOL> }


public actual fun LongArray . asList ( ) : List < Long >

{ <EOL> return object : AbstractList < Long > ( ) , RandomAccess { <EOL> override val size : Int get ( ) = this@asList . size <EOL> override fun isEmpty ( ) : Boolean = this@asList . isEmpty ( ) <EOL> override fun contains ( element : Long ) : Boolean = this@asList . contains ( element ) <EOL> override fun get ( index : Int ) : Long = this@asList [ index ] <EOL> override fun indexOf ( element : Long ) : Int = this@asList . indexOf ( element ) <EOL> override fun lastIndexOf ( element : Long ) : Int = this@asList . lastIndexOf ( element ) <EOL> } <EOL> }


public actual fun FloatArray . asList ( ) : List < Float >

{ <EOL> return object : AbstractList < Float > ( ) , RandomAccess { <EOL> override val size : Int get ( ) = this@asList . size <EOL> override fun isEmpty ( ) : Boolean = this@asList . isEmpty ( ) <EOL> override fun contains ( element : Float ) : Boolean = this@asList . any { it . toBits ( ) == element . toBits ( ) } <EOL> override fun get ( index : Int ) : Float = this@asList [ index ] <EOL> override fun indexOf ( element : Float ) : Int = this@asList . indexOfFirst { it . toBits ( ) == element . toBits ( ) } <EOL> override fun lastIndexOf ( element : Float ) : Int = this@asList . indexOfLast { it . toBits ( ) == element . toBits ( ) } <EOL> } <EOL> }


public actual fun DoubleArray . asList ( ) : List < Double >

{ <EOL> return object : AbstractList < Double > ( ) , RandomAccess { <EOL> override val size : Int get ( ) = this@asList . size <EOL> override fun isEmpty ( ) : Boolean = this@asList . isEmpty ( ) <EOL> override fun contains ( element : Double ) : Boolean = this@asList . any { it . toBits ( ) == element . toBits ( ) } <EOL> override fun get ( index : Int ) : Double = this@asList [ index ] <EOL> override fun indexOf ( element : Double ) : Int = this@asList . indexOfFirst { it . toBits ( ) == element . toBits ( ) } <EOL> override fun lastIndexOf ( element : Double ) : Int = this@asList . indexOfLast { it . toBits ( ) == element . toBits ( ) } <EOL> } <EOL> }


public actual fun BooleanArray . asList ( ) : List < Boolean >

{ <EOL> return object : AbstractList < Boolean > ( ) , RandomAccess { <EOL> override val size : Int get ( ) = this@asList . size <EOL> override fun isEmpty ( ) : Boolean = this@asList . isEmpty ( ) <EOL> override fun contains ( element : Boolean ) : Boolean = this@asList . contains ( element ) <EOL> override fun get ( index : Int ) : Boolean = this@asList [ index ] <EOL> override fun indexOf ( element : Boolean ) : Int = this@asList . indexOf ( element ) <EOL> override fun lastIndexOf ( element : Boolean ) : Int = this@asList . lastIndexOf ( element ) <EOL> } <EOL> }


public actual fun CharArray . asList ( ) : List < Char >

{ <EOL> return object : AbstractList < Char > ( ) , RandomAccess { <EOL> override val size : Int get ( ) = this@asList . size <EOL> override fun isEmpty ( ) : Boolean = this@asList . isEmpty ( ) <EOL> override fun contains ( element : Char ) : Boolean = this@asList . contains ( element ) <EOL> override fun get ( index : Int ) : Char = this@asList [ index ] <EOL> override fun indexOf ( element : Char ) : Int = this@asList . indexOf ( element ) <EOL> override fun lastIndexOf ( element : Char ) : Int = this@asList . lastIndexOf ( element ) <EOL> } <EOL> }


@ SinceKotlin ( "<STR_LIT:1.1>" ) <EOL> @ kotlin . internal . LowPriorityInOverloadResolution <EOL> public actual infix fun < T > Array < out T > . contentDeepEquals ( other : Array < out T > ) : Boolean

{ <EOL> return this . contentDeepEquals ( other ) <EOL> }

/**
 * Checks if the two specified arrays are *deeply* equal to one another.
 *
 * Two arrays are considered deeply equal if they have the same size, and elements at corresponding indices are deeply equal.
 * That is, if two corresponding elements are nested arrays, they are also compared deeply.
 * Elements of other types are compared for equality using the [equals][Any.equals] function.
 * For floating point numbers, this means `NaN` is equal to itself and `-0.0` is not equal to `0.0`.
 *
 * If any of the arrays contain themselves at any nesting level, the behavior is undefined.
 *
 * @param other the array to compare deeply with this array.
 * @return `true` if the two arrays are deeply equal, `false` otherwise.
 *
 * @sample samples.collections.Arrays.ContentOperations.contentDeepEquals
 */


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> public actual infix fun < T > Array < out T > ? . contentDeepEquals ( other : Array < out T > ? ) : Boolean

{ <EOL> return contentDeepEqualsImpl ( other ) <EOL> }

/**
 * Checks if the two specified arrays are *deeply* equal to one another.
 *
 * Two arrays are considered deeply equal if they have the same size, and elements at corresponding indices are deeply equal.
 * That is, if two corresponding elements are nested arrays, they are also compared deeply.
 * Elements of other types are compared for equality using the [equals][Any.equals] function.
 * For floating point numbers, this means `NaN` is equal to itself and `-0.0` is not equal to `0.0`.
 *
 * The arrays are also considered deeply equal if both are `null`.
 *
 * If any of the arrays contain themselves at any nesting level, the behavior is undefined.
 *
 * @param other the array to compare deeply with this array.
 * @return `true` if the two arrays are deeply equal, `false` otherwise.
 *
 * @sample samples.collections.Arrays.ContentOperations.contentDeepEquals
 */


@ SinceKotlin ( "<STR_LIT:1.1>" ) <EOL> @ kotlin . internal . LowPriorityInOverloadResolution <EOL> public actual fun < T > Array < out T > . contentDeepHashCode ( ) : Int

{ <EOL> return this . contentDeepHashCode ( ) <EOL> }

/**
 * Returns a hash code based on the contents of this array as if it is [List].
 * Nested arrays are treated as lists too.
 *
 * If any of arrays contains itself on any nesting level the behavior is undefined.
 */


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> public actual fun < T > Array < out T > ? . contentDeepHashCode ( ) : Int

{ <EOL> return contentDeepHashCodeImpl ( ) <EOL> }


@ SinceKotlin ( "<STR_LIT:1.1>" ) <EOL> @ kotlin . internal . LowPriorityInOverloadResolution <EOL> public actual fun < T > Array < out T > . contentDeepToString ( ) : String

{ <EOL> return this . contentDeepToString ( ) <EOL> }

/**
 * Returns a string representation of the contents of this array as if it is a [List].
 * Nested arrays are treated as lists too.
 *
 * If any of arrays contains itself on any nesting level that reference
 * is rendered as `"[...]"` to prevent recursion.
 *
 * @sample samples.collections.Arrays.ContentOperations.contentDeepToString
 */


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> public actual fun < T > Array < out T > ? . contentDeepToString ( ) : String

{ <EOL> return contentDeepToStringImpl ( ) <EOL> }


@ Deprecated ( "<STR_LIT>" ) <EOL> @ SinceKotlin ( "<STR_LIT:1.1>" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = "<STR_LIT:1.4>" ) <EOL> public infix fun < T > Array < out T > . contentEquals ( other : Array < out T > ) : Boolean

{ <EOL> return this . contentEquals ( other ) <EOL> }

/**
 * Checks if the two specified arrays are *structurally* equal to one another.
 *
 * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.
 * Elements are compared for equality using the [equals][Any.equals] function.
 * For floating point numbers, this means `NaN` is equal to itself and `-0.0` is not equal to `0.0`.
 *
 * If the arrays contain nested arrays, use [contentDeepEquals] to recursively compare their elements.
 *
 * @param other the array to compare with this array.
 * @return `true` if the two arrays are structurally equal, `false` otherwise.
 *
 * @sample samples.collections.Arrays.ContentOperations.arrayContentEquals
 */


@ Deprecated ( "<STR_LIT>" ) <EOL> @ SinceKotlin ( "<STR_LIT:1.1>" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = "<STR_LIT:1.4>" ) <EOL> public infix fun ByteArray . contentEquals ( other : ByteArray ) : Boolean

/**
 * Checks if the two specified arrays are *structurally* equal to one another.
 *
 * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.
 *
 * @param other the array to compare with this array.
 * @return `true` if the two arrays are structurally equal, `false` otherwise.
 *
 * @sample samples.collections.Arrays.ContentOperations.intArrayContentEquals
 */


@ Deprecated ( "<STR_LIT>" ) <EOL> @ SinceKotlin ( "<STR_LIT:1.1>" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = "<STR_LIT:1.4>" ) <EOL> public infix fun ShortArray . contentEquals ( other : ShortArray ) : Boolean


@ Deprecated ( "<STR_LIT>" ) <EOL> @ SinceKotlin ( "<STR_LIT:1.1>" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = "<STR_LIT:1.4>" ) <EOL> public infix fun IntArray . contentEquals ( other : IntArray ) : Boolean


@ Deprecated ( "<STR_LIT>" ) <EOL> @ SinceKotlin ( "<STR_LIT:1.1>" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = "<STR_LIT:1.4>" ) <EOL> public infix fun LongArray . contentEquals ( other : LongArray ) : Boolean


@ Deprecated ( "<STR_LIT>" ) <EOL> @ SinceKotlin ( "<STR_LIT:1.1>" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = "<STR_LIT:1.4>" ) <EOL> public infix fun FloatArray . contentEquals ( other : FloatArray ) : Boolean

/**
 * Checks if the two specified arrays are *structurally* equal to one another.
 *
 * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.
 * Elements are compared for equality using the [equals][Any.equals] function.
 * This means `NaN` is equal to itself and `-0.0` is not equal to `0.0`.
 *
 * @param other the array to compare with this array.
 * @return `true` if the two arrays are structurally equal, `false` otherwise.
 *
 * @sample samples.collections.Arrays.ContentOperations.doubleArrayContentEquals
 */


@ Deprecated ( "<STR_LIT>" ) <EOL> @ SinceKotlin ( "<STR_LIT:1.1>" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = "<STR_LIT:1.4>" ) <EOL> public infix fun DoubleArray . contentEquals ( other : DoubleArray ) : Boolean


@ Deprecated ( "<STR_LIT>" ) <EOL> @ SinceKotlin ( "<STR_LIT:1.1>" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = "<STR_LIT:1.4>" ) <EOL> public infix fun BooleanArray . contentEquals ( other : BooleanArray ) : Boolean

/**
 * Checks if the two specified arrays are *structurally* equal to one another.
 *
 * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.
 *
 * @param other the array to compare with this array.
 * @return `true` if the two arrays are structurally equal, `false` otherwise.
 *
 * @sample samples.collections.Arrays.ContentOperations.booleanArrayContentEquals
 */


@ Deprecated ( "<STR_LIT>" ) <EOL> @ SinceKotlin ( "<STR_LIT:1.1>" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = "<STR_LIT:1.4>" ) <EOL> public infix fun CharArray . contentEquals ( other : CharArray ) : Boolean

/**
 * Checks if the two specified arrays are *structurally* equal to one another.
 *
 * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.
 *
 * @param other the array to compare with this array.
 * @return `true` if the two arrays are structurally equal, `false` otherwise.
 *
 * @sample samples.collections.Arrays.ContentOperations.charArrayContentEquals
 */


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> public actual infix fun < T > Array < out T > ? . contentEquals ( other : Array < out T > ? ) : Boolean

{ <EOL> if ( this === other ) return true <EOL> if ( this === null || other === null ) return false <EOL> if ( size != other . size ) return false <EOL> for ( i in indices ) { <EOL> if ( this [ i ] != other [ i ] ) return false <EOL> } <EOL> return true <EOL> }

/**
 * Checks if the two specified arrays are *structurally* equal to one another.
 *
 * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.
 * Elements are compared for equality using the [equals][Any.equals] function.
 * For floating point numbers, this means `NaN` is equal to itself and `-0.0` is not equal to `0.0`.
 *
 * The arrays are also considered structurally equal if both are `null`.
 *
 * If the arrays contain nested arrays, use [contentDeepEquals] to recursively compare their elements.
 *
 * @param other the array to compare with this array.
 * @return `true` if the two arrays are structurally equal, `false` otherwise.
 *
 * @sample samples.collections.Arrays.ContentOperations.arrayContentEquals
 */


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> public actual infix fun ByteArray ? . contentEquals ( other : ByteArray ? ) : Boolean

/**
 * Checks if the two specified arrays are *structurally* equal to one another.
 *
 * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.
 *
 * The arrays are also considered structurally equal if both are `null`.
 *
 * @param other the array to compare with this array.
 * @return `true` if the two arrays are structurally equal, `false` otherwise.
 *
 * @sample samples.collections.Arrays.ContentOperations.intArrayContentEquals
 */


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> public actual infix fun ShortArray ? . contentEquals ( other : ShortArray ? ) : Boolean


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> public actual infix fun IntArray ? . contentEquals ( other : IntArray ? ) : Boolean


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> public actual infix fun LongArray ? . contentEquals ( other : LongArray ? ) : Boolean


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> public actual infix fun FloatArray ? . contentEquals ( other : FloatArray ? ) : Boolean

{ <EOL> if ( this === other ) return true <EOL> if ( this === null || other === null ) return false <EOL> if ( size != other . size ) return false <EOL> for ( i in indices ) { <EOL> if ( ! this [ i ] . equals ( other [ i ] ) ) return false <EOL> } <EOL> return true <EOL> }

/**
 * Checks if the two specified arrays are *structurally* equal to one another.
 *
 * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.
 * Elements are compared for equality using the [equals][Any.equals] function.
 * This means `NaN` is equal to itself and `-0.0` is not equal to `0.0`.
 *
 * The arrays are also considered structurally equal if both are `null`.
 *
 * @param other the array to compare with this array.
 * @return `true` if the two arrays are structurally equal, `false` otherwise.
 *
 * @sample samples.collections.Arrays.ContentOperations.doubleArrayContentEquals
 */


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> public actual infix fun DoubleArray ? . contentEquals ( other : DoubleArray ? ) : Boolean


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> public actual infix fun BooleanArray ? . contentEquals ( other : BooleanArray ? ) : Boolean

/**
 * Checks if the two specified arrays are *structurally* equal to one another.
 *
 * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.
 *
 * The arrays are also considered structurally equal if both are `null`.
 *
 * @param other the array to compare with this array.
 * @return `true` if the two arrays are structurally equal, `false` otherwise.
 *
 * @sample samples.collections.Arrays.ContentOperations.booleanArrayContentEquals
 */


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> public actual infix fun CharArray ? . contentEquals ( other : CharArray ? ) : Boolean

/**
 * Checks if the two specified arrays are *structurally* equal to one another.
 *
 * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.
 *
 * The arrays are also considered structurally equal if both are `null`.
 *
 * @param other the array to compare with this array.
 * @return `true` if the two arrays are structurally equal, `false` otherwise.
 *
 * @sample samples.collections.Arrays.ContentOperations.charArrayContentEquals
 */


@ Deprecated ( "<STR_LIT>" ) <EOL> @ SinceKotlin ( "<STR_LIT:1.1>" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = "<STR_LIT:1.4>" ) <EOL> public fun < T > Array < out T > . contentHashCode ( ) : Int

{ <EOL> return this . contentHashCode ( ) <EOL> }

/**
 * Returns a hash code based on the contents of this array as if it is [List].
 */


@ Deprecated ( "<STR_LIT>" ) <EOL> @ SinceKotlin ( "<STR_LIT:1.1>" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = "<STR_LIT:1.4>" ) <EOL> public fun ByteArray . contentHashCode ( ) : Int


@ Deprecated ( "<STR_LIT>" ) <EOL> @ SinceKotlin ( "<STR_LIT:1.1>" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = "<STR_LIT:1.4>" ) <EOL> public fun ShortArray . contentHashCode ( ) : Int


@ Deprecated ( "<STR_LIT>" ) <EOL> @ SinceKotlin ( "<STR_LIT:1.1>" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = "<STR_LIT:1.4>" ) <EOL> public fun IntArray . contentHashCode ( ) : Int


@ Deprecated ( "<STR_LIT>" ) <EOL> @ SinceKotlin ( "<STR_LIT:1.1>" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = "<STR_LIT:1.4>" ) <EOL> public fun LongArray . contentHashCode ( ) : Int


@ Deprecated ( "<STR_LIT>" ) <EOL> @ SinceKotlin ( "<STR_LIT:1.1>" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = "<STR_LIT:1.4>" ) <EOL> public fun FloatArray . contentHashCode ( ) : Int


@ Deprecated ( "<STR_LIT>" ) <EOL> @ SinceKotlin ( "<STR_LIT:1.1>" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = "<STR_LIT:1.4>" ) <EOL> public fun DoubleArray . contentHashCode ( ) : Int


@ Deprecated ( "<STR_LIT>" ) <EOL> @ SinceKotlin ( "<STR_LIT:1.1>" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = "<STR_LIT:1.4>" ) <EOL> public fun BooleanArray . contentHashCode ( ) : Int


@ Deprecated ( "<STR_LIT>" ) <EOL> @ SinceKotlin ( "<STR_LIT:1.1>" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = "<STR_LIT:1.4>" ) <EOL> public fun CharArray . contentHashCode ( ) : Int


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> public actual fun < T > Array < out T > ? . contentHashCode ( ) : Int

{ <EOL> if ( this === null ) return <NUM_LIT:0> <EOL> var result = <NUM_LIT:1> <EOL> for ( element in this ) <EOL> result = <NUM_LIT:31> * result + element . hashCode ( ) <EOL> return result <EOL> }


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> public actual fun ByteArray ? . contentHashCode ( ) : Int


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> public actual fun ShortArray ? . contentHashCode ( ) : Int


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> public actual fun IntArray ? . contentHashCode ( ) : Int


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> public actual fun LongArray ? . contentHashCode ( ) : Int


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> public actual fun FloatArray ? . contentHashCode ( ) : Int


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> public actual fun DoubleArray ? . contentHashCode ( ) : Int


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> public actual fun BooleanArray ? . contentHashCode ( ) : Int


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> public actual fun CharArray ? . contentHashCode ( ) : Int


@ Deprecated ( "<STR_LIT>" ) <EOL> @ SinceKotlin ( "<STR_LIT:1.1>" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = "<STR_LIT:1.4>" ) <EOL> public fun < T > Array < out T > . contentToString ( ) : String

{ <EOL> return this . contentToString ( ) <EOL> }

/**
 * Returns a string representation of the contents of the specified array as if it is [List].
 *
 * @sample samples.collections.Arrays.ContentOperations.contentToString
 */


@ Deprecated ( "<STR_LIT>" ) <EOL> @ SinceKotlin ( "<STR_LIT:1.1>" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = "<STR_LIT:1.4>" ) <EOL> public fun ByteArray . contentToString ( ) : String


@ Deprecated ( "<STR_LIT>" ) <EOL> @ SinceKotlin ( "<STR_LIT:1.1>" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = "<STR_LIT:1.4>" ) <EOL> public fun ShortArray . contentToString ( ) : String


@ Deprecated ( "<STR_LIT>" ) <EOL> @ SinceKotlin ( "<STR_LIT:1.1>" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = "<STR_LIT:1.4>" ) <EOL> public fun IntArray . contentToString ( ) : String


@ Deprecated ( "<STR_LIT>" ) <EOL> @ SinceKotlin ( "<STR_LIT:1.1>" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = "<STR_LIT:1.4>" ) <EOL> public fun LongArray . contentToString ( ) : String


@ Deprecated ( "<STR_LIT>" ) <EOL> @ SinceKotlin ( "<STR_LIT:1.1>" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = "<STR_LIT:1.4>" ) <EOL> public fun FloatArray . contentToString ( ) : String


@ Deprecated ( "<STR_LIT>" ) <EOL> @ SinceKotlin ( "<STR_LIT:1.1>" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = "<STR_LIT:1.4>" ) <EOL> public fun DoubleArray . contentToString ( ) : String


@ Deprecated ( "<STR_LIT>" ) <EOL> @ SinceKotlin ( "<STR_LIT:1.1>" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = "<STR_LIT:1.4>" ) <EOL> public fun BooleanArray . contentToString ( ) : String


@ Deprecated ( "<STR_LIT>" ) <EOL> @ SinceKotlin ( "<STR_LIT:1.1>" ) <EOL> @ DeprecatedSinceKotlin ( hiddenSince = "<STR_LIT:1.4>" ) <EOL> public fun CharArray . contentToString ( ) : String


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> public actual fun < T > Array < out T > ? . contentToString ( ) : String

{ <EOL> return this ? . joinToString ( "<STR_LIT:U+002CU+0020>" , "<STR_LIT:[>" , "<STR_LIT:]>" ) ? : "<STR_LIT:null>" <EOL> }


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> public actual fun ByteArray ? . contentToString ( ) : String


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> public actual fun ShortArray ? . contentToString ( ) : String


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> public actual fun IntArray ? . contentToString ( ) : String


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> public actual fun LongArray ? . contentToString ( ) : String


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> public actual fun FloatArray ? . contentToString ( ) : String


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> public actual fun DoubleArray ? . contentToString ( ) : String


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> public actual fun BooleanArray ? . contentToString ( ) : String


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


@ SinceKotlin ( "<STR_LIT:1.3>" ) <EOL> @ Suppress ( "<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>" ) <EOL> public actual fun < T > Array < out T > . copyInto ( destination : Array < T > , destinationOffset : Int = <NUM_LIT:0> , startIndex : Int = <NUM_LIT:0> , endIndex : Int = size ) : Array < T >

{ <EOL> AbstractList . checkRangeIndexes ( startIndex , endIndex , this . size ) <EOL> val rangeSize = endIndex - startIndex <EOL> AbstractList . checkRangeIndexes ( destinationOffset , destinationOffset + rangeSize , destination . size ) <EOL> kotlin . wasm . internal . copyWasmArray ( this . storage , destination . storage , startIndex , destinationOffset , rangeSize ) <EOL> return destination <EOL> }

/**
 * Copies this array or its subrange into the [destination] array and returns that array.
 *
 * It's allowed to pass the same array in the [destination] and even specify the subrange so that it overlaps with the destination range.
 *
 * @param destination the array to copy to.
 * @param destinationOffset the position in the [destination] array to copy to, 0 by default.
 * @param startIndex the beginning (inclusive) of the subrange to copy, 0 by default.
 * @param endIndex the end (exclusive) of the subrange to copy, size of this array by default.
 *
 * @throws IndexOutOfBoundsException or [IllegalArgumentException] when [startIndex] or [endIndex] is out of range of this array indices or when `startIndex > endIndex`.
 * @throws IndexOutOfBoundsException when the subrange doesn't fit into the [destination] array starting at the specified [destinationOffset],
 * or when that index is out of the [destination] array indices range.
 *
 * @return the [destination] array.
 */


@ SinceKotlin ( "<STR_LIT:1.3>" ) <EOL> @ Suppress ( "<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>" ) <EOL> public actual fun ByteArray . copyInto ( destination : ByteArray , destinationOffset : Int = <NUM_LIT:0> , startIndex : Int = <NUM_LIT:0> , endIndex : Int = size ) : ByteArray


@ SinceKotlin ( "<STR_LIT:1.3>" ) <EOL> @ Suppress ( "<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>" ) <EOL> public actual fun ShortArray . copyInto ( destination : ShortArray , destinationOffset : Int = <NUM_LIT:0> , startIndex : Int = <NUM_LIT:0> , endIndex : Int = size ) : ShortArray


@ SinceKotlin ( "<STR_LIT:1.3>" ) <EOL> @ Suppress ( "<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>" ) <EOL> public actual fun IntArray . copyInto ( destination : IntArray , destinationOffset : Int = <NUM_LIT:0> , startIndex : Int = <NUM_LIT:0> , endIndex : Int = size ) : IntArray


@ SinceKotlin ( "<STR_LIT:1.3>" ) <EOL> @ Suppress ( "<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>" ) <EOL> public actual fun LongArray . copyInto ( destination : LongArray , destinationOffset : Int = <NUM_LIT:0> , startIndex : Int = <NUM_LIT:0> , endIndex : Int = size ) : LongArray


@ SinceKotlin ( "<STR_LIT:1.3>" ) <EOL> @ Suppress ( "<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>" ) <EOL> public actual fun FloatArray . copyInto ( destination : FloatArray , destinationOffset : Int = <NUM_LIT:0> , startIndex : Int = <NUM_LIT:0> , endIndex : Int = size ) : FloatArray


@ SinceKotlin ( "<STR_LIT:1.3>" ) <EOL> @ Suppress ( "<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>" ) <EOL> public actual fun DoubleArray . copyInto ( destination : DoubleArray , destinationOffset : Int = <NUM_LIT:0> , startIndex : Int = <NUM_LIT:0> , endIndex : Int = size ) : DoubleArray


@ SinceKotlin ( "<STR_LIT:1.3>" ) <EOL> @ Suppress ( "<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>" ) <EOL> public actual fun BooleanArray . copyInto ( destination : BooleanArray , destinationOffset : Int = <NUM_LIT:0> , startIndex : Int = <NUM_LIT:0> , endIndex : Int = size ) : BooleanArray


@ SinceKotlin ( "<STR_LIT:1.3>" ) <EOL> @ Suppress ( "<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>" ) <EOL> public actual fun CharArray . copyInto ( destination : CharArray , destinationOffset : Int = <NUM_LIT:0> , startIndex : Int = <NUM_LIT:0> , endIndex : Int = size ) : CharArray


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

{ <EOL> return this . copyOfUninitializedElements ( size ) <EOL> }

/**
 * Returns new array which is a copy of the original array.
 *
 * @sample samples.collections.Arrays.CopyOfOperations.copyOf
 */


public actual fun ByteArray . copyOf ( ) : ByteArray


public actual fun ShortArray . copyOf ( ) : ShortArray


public actual fun IntArray . copyOf ( ) : IntArray


public actual fun LongArray . copyOf ( ) : LongArray


public actual fun FloatArray . copyOf ( ) : FloatArray


public actual fun DoubleArray . copyOf ( ) : DoubleArray


public actual fun BooleanArray . copyOf ( ) : BooleanArray


public actual fun CharArray . copyOf ( ) : CharArray


public actual fun ByteArray . copyOf ( newSize : Int ) : ByteArray

{ <EOL> return this . copyOfUninitializedElements ( newSize ) <EOL> }

/**
 * Returns new array which is a copy of the original array, resized to the given [newSize].
 * The copy is either truncated or padded at the end with zero values if necessary.
 *
 * - If [newSize] is less than the size of the original array, the copy array is truncated to the [newSize].
 * - If [newSize] is greater than the size of the original array, the extra elements in the copy array are filled with zero values.
 *
 * @sample samples.collections.Arrays.CopyOfOperations.resizedPrimitiveCopyOf
 */


public actual fun ShortArray . copyOf ( newSize : Int ) : ShortArray


public actual fun IntArray . copyOf ( newSize : Int ) : IntArray


public actual fun LongArray . copyOf ( newSize : Int ) : LongArray


public actual fun FloatArray . copyOf ( newSize : Int ) : FloatArray


public actual fun DoubleArray . copyOf ( newSize : Int ) : DoubleArray


public actual fun BooleanArray . copyOf ( newSize : Int ) : BooleanArray

/**
 * Returns new array which is a copy of the original array, resized to the given [newSize].
 * The copy is either truncated or padded at the end with `false` values if necessary.
 *
 * - If [newSize] is less than the size of the original array, the copy array is truncated to the [newSize].
 * - If [newSize] is greater than the size of the original array, the extra elements in the copy array are filled with `false` values.
 *
 * @sample samples.collections.Arrays.CopyOfOperations.resizedPrimitiveCopyOf
 */


public actual fun CharArray . copyOf ( newSize : Int ) : CharArray

/**
 * Returns new array which is a copy of the original array, resized to the given [newSize].
 * The copy is either truncated or padded at the end with null char (`\u0000`) values if necessary.
 *
 * - If [newSize] is less than the size of the original array, the copy array is truncated to the [newSize].
 * - If [newSize] is greater than the size of the original array, the extra elements in the copy array are filled with null char (`\u0000`) values.
 *
 * @sample samples.collections.Arrays.CopyOfOperations.resizedPrimitiveCopyOf
 */


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

{ <EOL> return this . copyOfNulls ( newSize ) <EOL> }

/**
 * Returns new array which is a copy of the original array, resized to the given [newSize].
 * The copy is either truncated or padded at the end with `null` values if necessary.
 *
 * - If [newSize] is less than the size of the original array, the copy array is truncated to the [newSize].
 * - If [newSize] is greater than the size of the original array, the extra elements in the copy array are filled with `null` values.
 *
 * @sample samples.collections.Arrays.CopyOfOperations.resizingCopyOf
 */


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

{ <EOL> checkCopyOfRangeArguments ( fromIndex , toIndex , size ) <EOL> return copyOfUninitializedElements ( fromIndex , toIndex ) <EOL> }

/**
 * Returns a new array which is a copy of the specified range of the original array.
 *
 * @param fromIndex the start of the range (inclusive) to copy.
 * @param toIndex the end of the range (exclusive) to copy.
 *
 * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.
 * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].
 */


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


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


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


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


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


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


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


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


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

{ <EOL> val newSize = toIndex - fromIndex <EOL> if ( newSize < <NUM_LIT:0> ) { <EOL> throw IllegalArgumentException ( "<STR_LIT>" ) <EOL> } <EOL> val result = arrayOfUninitializedElements < T > ( newSize ) <EOL> this . copyInto ( result , <NUM_LIT:0> , fromIndex , toIndex . coerceAtMost ( size ) ) <EOL> return result <EOL> }

/**
 * Returns new array which is a copy of the original array's range between [fromIndex] (inclusive)
 * and [toIndex] (exclusive) with new elements filled with **lateinit** _uninitialized_ values.
 * Attempts to read _uninitialized_ values from this array work in implementation-dependent manner,
 * either throwing exception or returning some kind of implementation-specific default value.
 */


internal fun ByteArray . copyOfUninitializedElements ( fromIndex : Int , toIndex : Int ) : ByteArray

{ <EOL> val newSize = toIndex - fromIndex <EOL> if ( newSize < <NUM_LIT:0> ) { <EOL> throw IllegalArgumentException ( "<STR_LIT>" ) <EOL> } <EOL> val result = ByteArray ( newSize ) <EOL> this . copyInto ( result , <NUM_LIT:0> , fromIndex , toIndex . coerceAtMost ( size ) ) <EOL> return result <EOL> }


internal fun ShortArray . copyOfUninitializedElements ( fromIndex : Int , toIndex : Int ) : ShortArray

{ <EOL> val newSize = toIndex - fromIndex <EOL> if ( newSize < <NUM_LIT:0> ) { <EOL> throw IllegalArgumentException ( "<STR_LIT>" ) <EOL> } <EOL> val result = ShortArray ( newSize ) <EOL> this . copyInto ( result , <NUM_LIT:0> , fromIndex , toIndex . coerceAtMost ( size ) ) <EOL> return result <EOL> }


internal fun IntArray . copyOfUninitializedElements ( fromIndex : Int , toIndex : Int ) : IntArray

{ <EOL> val newSize = toIndex - fromIndex <EOL> if ( newSize < <NUM_LIT:0> ) { <EOL> throw IllegalArgumentException ( "<STR_LIT>" ) <EOL> } <EOL> val result = IntArray ( newSize ) <EOL> this . copyInto ( result , <NUM_LIT:0> , fromIndex , toIndex . coerceAtMost ( size ) ) <EOL> return result <EOL> }


internal fun LongArray . copyOfUninitializedElements ( fromIndex : Int , toIndex : Int ) : LongArray

{ <EOL> val newSize = toIndex - fromIndex <EOL> if ( newSize < <NUM_LIT:0> ) { <EOL> throw IllegalArgumentException ( "<STR_LIT>" ) <EOL> } <EOL> val result = LongArray ( newSize ) <EOL> this . copyInto ( result , <NUM_LIT:0> , fromIndex , toIndex . coerceAtMost ( size ) ) <EOL> return result <EOL> }


internal fun FloatArray . copyOfUninitializedElements ( fromIndex : Int , toIndex : Int ) : FloatArray

{ <EOL> val newSize = toIndex - fromIndex <EOL> if ( newSize < <NUM_LIT:0> ) { <EOL> throw IllegalArgumentException ( "<STR_LIT>" ) <EOL> } <EOL> val result = FloatArray ( newSize ) <EOL> this . copyInto ( result , <NUM_LIT:0> , fromIndex , toIndex . coerceAtMost ( size ) ) <EOL> return result <EOL> }


internal fun DoubleArray . copyOfUninitializedElements ( fromIndex : Int , toIndex : Int ) : DoubleArray

{ <EOL> val newSize = toIndex - fromIndex <EOL> if ( newSize < <NUM_LIT:0> ) { <EOL> throw IllegalArgumentException ( "<STR_LIT>" ) <EOL> } <EOL> val result = DoubleArray ( newSize ) <EOL> this . copyInto ( result , <NUM_LIT:0> , fromIndex , toIndex . coerceAtMost ( size ) ) <EOL> return result <EOL> }


internal fun BooleanArray . copyOfUninitializedElements ( fromIndex : Int , toIndex : Int ) : BooleanArray

{ <EOL> val newSize = toIndex - fromIndex <EOL> if ( newSize < <NUM_LIT:0> ) { <EOL> throw IllegalArgumentException ( "<STR_LIT>" ) <EOL> } <EOL> val result = BooleanArray ( newSize ) <EOL> this . copyInto ( result , <NUM_LIT:0> , fromIndex , toIndex . coerceAtMost ( size ) ) <EOL> return result <EOL> }


internal fun CharArray . copyOfUninitializedElements ( fromIndex : Int , toIndex : Int ) : CharArray

{ <EOL> val newSize = toIndex - fromIndex <EOL> if ( newSize < <NUM_LIT:0> ) { <EOL> throw IllegalArgumentException ( "<STR_LIT>" ) <EOL> } <EOL> val result = CharArray ( newSize ) <EOL> this . copyInto ( result , <NUM_LIT:0> , fromIndex , toIndex . coerceAtMost ( size ) ) <EOL> return result <EOL> }


internal fun < T > Array < T > . copyOfUninitializedElements ( newSize : Int ) : Array < T >

{ <EOL> return copyOfUninitializedElements ( <NUM_LIT:0> , newSize ) <EOL> }

/**
 * Returns new array which is a copy of the original array with new elements filled with **lateinit** _uninitialized_ values.
 * Attempts to read _uninitialized_ values from this array work in implementation-dependent manner,
 * either throwing exception or returning some kind of implementation-specific default value.
 */


internal fun ByteArray . copyOfUninitializedElements ( newSize : Int ) : ByteArray


internal fun ShortArray . copyOfUninitializedElements ( newSize : Int ) : ShortArray


internal fun IntArray . copyOfUninitializedElements ( newSize : Int ) : IntArray


internal fun LongArray . copyOfUninitializedElements ( newSize : Int ) : LongArray


internal fun FloatArray . copyOfUninitializedElements ( newSize : Int ) : FloatArray


internal fun DoubleArray . copyOfUninitializedElements ( newSize : Int ) : DoubleArray


internal fun BooleanArray . copyOfUninitializedElements ( newSize : Int ) : BooleanArray


internal fun CharArray . copyOfUninitializedElements ( newSize : Int ) : CharArray


@ SinceKotlin ( "<STR_LIT:1.3>" ) <EOL> @ Suppress ( "<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>" ) <EOL> public actual fun < T > Array < T > . fill ( element : T , fromIndex : Int = <NUM_LIT:0> , toIndex : Int = size ) : Unit

{ <EOL> AbstractList . checkRangeIndexes ( fromIndex , toIndex , size ) <EOL> for ( index in fromIndex until toIndex ) { <EOL> this [ index ] = element <EOL> } <EOL> }

/**
 * Fills this array or its subrange with the specified [element] value.
 *
 * @param fromIndex the start of the range (inclusive) to fill, 0 by default.
 * @param toIndex the end of the range (exclusive) to fill, size of this array by default.
 *
 * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.
 * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].
 */


@ SinceKotlin ( "<STR_LIT:1.3>" ) <EOL> @ Suppress ( "<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>" ) <EOL> public actual fun ByteArray . fill ( element : Byte , fromIndex : Int = <NUM_LIT:0> , toIndex : Int = size ) : Unit


@ SinceKotlin ( "<STR_LIT:1.3>" ) <EOL> @ Suppress ( "<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>" ) <EOL> public actual fun ShortArray . fill ( element : Short , fromIndex : Int = <NUM_LIT:0> , toIndex : Int = size ) : Unit


@ SinceKotlin ( "<STR_LIT:1.3>" ) <EOL> @ Suppress ( "<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>" ) <EOL> public actual fun IntArray . fill ( element : Int , fromIndex : Int = <NUM_LIT:0> , toIndex : Int = size ) : Unit


@ SinceKotlin ( "<STR_LIT:1.3>" ) <EOL> @ Suppress ( "<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>" ) <EOL> public actual fun LongArray . fill ( element : Long , fromIndex : Int = <NUM_LIT:0> , toIndex : Int = size ) : Unit


@ SinceKotlin ( "<STR_LIT:1.3>" ) <EOL> @ Suppress ( "<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>" ) <EOL> public actual fun FloatArray . fill ( element : Float , fromIndex : Int = <NUM_LIT:0> , toIndex : Int = size ) : Unit


@ SinceKotlin ( "<STR_LIT:1.3>" ) <EOL> @ Suppress ( "<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>" ) <EOL> public actual fun DoubleArray . fill ( element : Double , fromIndex : Int = <NUM_LIT:0> , toIndex : Int = size ) : Unit


@ SinceKotlin ( "<STR_LIT:1.3>" ) <EOL> @ Suppress ( "<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>" ) <EOL> public actual fun BooleanArray . fill ( element : Boolean , fromIndex : Int = <NUM_LIT:0> , toIndex : Int = size ) : Unit


@ SinceKotlin ( "<STR_LIT:1.3>" ) <EOL> @ Suppress ( "<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>" ) <EOL> public actual fun CharArray . fill ( element : Char , fromIndex : Int = <NUM_LIT:0> , toIndex : Int = size ) : Unit


public actual operator fun < T > Array < T > . plus ( element : T ) : Array < T >

{ <EOL> val index = size <EOL> val result = copyOfUninitializedElements ( index + <NUM_LIT:1> ) <EOL> result [ index ] = element <EOL> return result <EOL> }

/**
 * Returns an array containing all elements of the original array and then the given [element].
 */


public actual operator fun ByteArray . plus ( element : Byte ) : ByteArray


public actual operator fun ShortArray . plus ( element : Short ) : ShortArray


public actual operator fun IntArray . plus ( element : Int ) : IntArray


public actual operator fun LongArray . plus ( element : Long ) : LongArray


public actual operator fun FloatArray . plus ( element : Float ) : FloatArray


public actual operator fun DoubleArray . plus ( element : Double ) : DoubleArray


public actual operator fun BooleanArray . plus ( element : Boolean ) : BooleanArray


public actual operator fun CharArray . plus ( element : Char ) : CharArray


public actual operator fun < T > Array < T > . plus ( elements : Collection < T > ) : Array < T >

{ <EOL> var index = size <EOL> val result = copyOfUninitializedElements ( index + elements . size ) <EOL> for ( element in elements ) result [ index ++ ] = element <EOL> return result <EOL> }

/**
 * Returns an array containing all elements of the original array and then all elements of the given [elements] collection.
 */


public actual operator fun ByteArray . plus ( elements : Collection < Byte > ) : ByteArray


public actual operator fun ShortArray . plus ( elements : Collection < Short > ) : ShortArray


public actual operator fun IntArray . plus ( elements : Collection < Int > ) : IntArray


public actual operator fun LongArray . plus ( elements : Collection < Long > ) : LongArray


public actual operator fun FloatArray . plus ( elements : Collection < Float > ) : FloatArray


public actual operator fun DoubleArray . plus ( elements : Collection < Double > ) : DoubleArray


public actual operator fun BooleanArray . plus ( elements : Collection < Boolean > ) : BooleanArray


public actual operator fun CharArray . plus ( elements : Collection < Char > ) : CharArray


public actual operator fun < T > Array < T > . plus ( elements : Array < out T > ) : Array < T >

{ <EOL> val thisSize = size <EOL> val arraySize = elements . size <EOL> val result = copyOfUninitializedElements ( thisSize + arraySize ) <EOL> elements . copyInto ( result , thisSize ) <EOL> return result <EOL> }

/**
 * Returns an array containing all elements of the original array and then all elements of the given [elements] array.
 */


public actual operator fun ByteArray . plus ( elements : ByteArray ) : ByteArray


public actual operator fun ShortArray . plus ( elements : ShortArray ) : ShortArray


public actual operator fun IntArray . plus ( elements : IntArray ) : IntArray


public actual operator fun LongArray . plus ( elements : LongArray ) : LongArray


public actual operator fun FloatArray . plus ( elements : FloatArray ) : FloatArray


public actual operator fun DoubleArray . plus ( elements : DoubleArray ) : DoubleArray


public actual operator fun BooleanArray . plus ( elements : BooleanArray ) : BooleanArray


public actual operator fun CharArray . plus ( elements : CharArray ) : CharArray


@ kotlin . internal . InlineOnly <EOL> public actual inline fun < T > Array < T > . plusElement ( element : T ) : Array < T >

{ <EOL> return plus ( element ) <EOL> }


public actual fun IntArray . sort ( ) : Unit

{ <EOL> if ( size > <NUM_LIT:1> ) sortArray ( this , <NUM_LIT:0> , size ) <EOL> }

/**
 * Sorts the array in-place.
 *
 * @sample samples.collections.Arrays.Sorting.sortArray
 */


public actual fun LongArray . sort ( ) : Unit


public actual fun ByteArray . sort ( ) : Unit


public actual fun ShortArray . sort ( ) : Unit


public actual fun DoubleArray . sort ( ) : Unit


public actual fun FloatArray . sort ( ) : Unit


public actual fun CharArray . sort ( ) : Unit


public actual fun < T : Comparable < T > > Array < out T > . sort ( ) : Unit

/**
 * Sorts the array in-place according to the natural order of its elements.
 *
 * The sort is _stable_. It means that equal elements preserve their order relative to each other after sorting.
 *
 * @sample samples.collections.Arrays.Sorting.sortArrayOfComparable
 */


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> @ Suppress ( "<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>" ) <EOL> public actual fun < T : Comparable < T > > Array < out T > . sort ( fromIndex : Int = <NUM_LIT:0> , toIndex : Int = size ) : Unit

{ <EOL> AbstractList . checkRangeIndexes ( fromIndex , toIndex , size ) <EOL> sortArray ( this , fromIndex , toIndex ) <EOL> }

/**
 * Sorts a range in the array in-place.
 *
 * The sort is _stable_. It means that equal elements preserve their order relative to each other after sorting.
 *
 * @param fromIndex the start of the range (inclusive) to sort, 0 by default.
 * @param toIndex the end of the range (exclusive) to sort, size of this array by default.
 *
 * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.
 * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].
 *
 * @sample samples.collections.Arrays.Sorting.sortRangeOfArrayOfComparable
 */


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> @ Suppress ( "<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>" ) <EOL> public actual fun ByteArray . sort ( fromIndex : Int = <NUM_LIT:0> , toIndex : Int = size ) : Unit

/**
 * Sorts a range in the array in-place.
 *
 * @param fromIndex the start of the range (inclusive) to sort, 0 by default.
 * @param toIndex the end of the range (exclusive) to sort, size of this array by default.
 *
 * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.
 * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].
 *
 * @sample samples.collections.Arrays.Sorting.sortRangeOfArray
 */


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> @ Suppress ( "<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>" ) <EOL> public actual fun ShortArray . sort ( fromIndex : Int = <NUM_LIT:0> , toIndex : Int = size ) : Unit


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> @ Suppress ( "<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>" ) <EOL> public actual fun IntArray . sort ( fromIndex : Int = <NUM_LIT:0> , toIndex : Int = size ) : Unit


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> @ Suppress ( "<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>" ) <EOL> public actual fun LongArray . sort ( fromIndex : Int = <NUM_LIT:0> , toIndex : Int = size ) : Unit


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> @ Suppress ( "<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>" ) <EOL> public actual fun FloatArray . sort ( fromIndex : Int = <NUM_LIT:0> , toIndex : Int = size ) : Unit


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> @ Suppress ( "<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>" ) <EOL> public actual fun DoubleArray . sort ( fromIndex : Int = <NUM_LIT:0> , toIndex : Int = size ) : Unit


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> @ Suppress ( "<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>" ) <EOL> public actual fun CharArray . sort ( fromIndex : Int = <NUM_LIT:0> , toIndex : Int = size ) : Unit


public actual fun < T > Array < out T > . sortWith ( comparator : Comparator < in T > ) : Unit

{ <EOL> if ( size > <NUM_LIT:1> ) sortArrayWith ( this , <NUM_LIT:0> , size , comparator ) <EOL> }

/**
 * Sorts the array in-place according to the order specified by the given [comparator].
 *
 * The sort is _stable_. It means that equal elements preserve their order relative to each other after sorting.
 */


@ Suppress ( "<STR_LIT:ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS>" ) <EOL> public actual fun < T > Array < out T > . sortWith ( comparator : Comparator < in T > , fromIndex : Int = <NUM_LIT:0> , toIndex : Int = size ) : Unit

{ <EOL> AbstractList . checkRangeIndexes ( fromIndex , toIndex , size ) <EOL> sortArrayWith ( this , fromIndex , toIndex , comparator ) <EOL> }

/**
 * Sorts a range in the array in-place with the given [comparator].
 *
 * The sort is _stable_. It means that equal elements preserve their order relative to each other after sorting.
 *
 * @param fromIndex the start of the range (inclusive) to sort, 0 by default.
 * @param toIndex the end of the range (exclusive) to sort, size of this array by default.
 *
 * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.
 * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].
 */


public actual fun ByteArray . toTypedArray ( ) : Array < Byte >

{ <EOL> return Array ( size ) { index -> this [ index ] } <EOL> }

/**
 * Returns a *typed* object array containing all of the elements of this primitive array.
 */


public actual fun ShortArray . toTypedArray ( ) : Array < Short >


public actual fun IntArray . toTypedArray ( ) : Array < Int >


public actual fun LongArray . toTypedArray ( ) : Array < Long >


public actual fun FloatArray . toTypedArray ( ) : Array < Float >


public actual fun DoubleArray . toTypedArray ( ) : Array < Double >


public actual fun BooleanArray . toTypedArray ( ) : Array < Boolean >


public actual fun CharArray . toTypedArray ( ) : Array < Char >


fun Gradle . registerMinimalVariantImplementationFactoriesForTests ( )

{ <EOL> VariantImplementationFactoriesConfigurator . get ( gradle ) . putIfAbsent ( ConfigurationTimePropertiesAccessor . ConfigurationTimePropertiesAccessorVariantFactory :: class , DefaultConfigurationTimePropertiesAccessorVariantFactory ( ) ) <EOL> VariantImplementationFactoriesConfigurator . get ( gradle ) . putIfAbsent ( IdeaSyncDetector . IdeaSyncDetectorVariantFactory :: class , DefaultIdeaSyncDetectorVariantFactory ( ) ) <EOL> }

/**
 * Configures some default factories that are usually automatically registered in
 * [org.jetbrains.kotlin.gradle.plugin.DefaultKotlinBasePlugin.apply]
 *
 * This function can be used in some minimal tests that do not apply the full KGP plugin but still touch
 * some parts of its code
 */


private fun configureDokkaPublicationsDefaults ( dokkatooExtension : DokkatooExtension , )

{ <EOL> dokkatooExtension . dokkatooPublications . all { <EOL> enabled . convention ( true ) <EOL> cacheRoot . convention ( dokkatooExtension . dokkatooCacheDirectory ) <EOL> delayTemplateSubstitution . convention ( false ) <EOL> failOnWarning . convention ( false ) <EOL> finalizeCoroutines . convention ( false ) <EOL> moduleName . convention ( dokkatooExtension . moduleName ) <EOL> moduleVersion . convention ( dokkatooExtension . moduleVersion ) <EOL> offlineMode . convention ( false ) <EOL> outputDir . convention ( dokkatooExtension . dokkatooPublicationDirectory ) <EOL> suppressInheritedMembers . convention ( false ) <EOL> suppressObviousFunctions . convention ( true ) <EOL> } <EOL> }

/** Set defaults in all [DokkatooExtension.dokkatooPublications]s */


private fun NamedDomainObjectContainer < DokkaSourceSetSpec > . configureDefaults ( sourceSetScopeConvention : Property < String > , )

{ <EOL> configureEach dss @ { <EOL> analysisPlatform . convention ( KotlinPlatform . DEFAULT ) <EOL> displayName . convention ( analysisPlatform . map { platform -> <EOL> when { <EOL> name . endsWith ( "<STR_LIT>" ) -> name . substringBeforeLast ( "<STR_LIT>" ) <EOL> else -> platform . displayName <EOL> } <EOL> } ) <EOL> documentedVisibilities . convention ( setOf ( VisibilityModifier . PUBLIC ) ) <EOL> jdkVersion . convention ( <NUM_LIT:8> ) <EOL> enableKotlinStdLibDocumentationLink . convention ( true ) <EOL> enableJdkDocumentationLink . convention ( true ) <EOL> enableAndroidDocumentationLink . convention ( analysisPlatform . map { it == KotlinPlatform . AndroidJVM } ) <EOL> reportUndocumented . convention ( false ) <EOL> skipDeprecated . convention ( false ) <EOL> skipEmptyPackages . convention ( true ) <EOL> sourceSetScope . convention ( sourceSetScopeConvention ) <EOL> suppress . convention ( false ) <EOL> suppressGeneratedFiles . convention ( true ) <EOL> sourceLinks . configureEach { <EOL> localDirectory . convention ( layout . projectDirectory ) <EOL> remoteLineSuffix . convention ( "<STR_LIT>" ) <EOL> } <EOL> perPackageOptions . configureEach { <EOL> matchingRegex . convention ( "<STR_LIT>" ) <EOL> suppress . convention ( false ) <EOL> skipDeprecated . convention ( false ) <EOL> reportUndocumented . convention ( false ) <EOL> } <EOL> externalDocumentationLinks { <EOL> configureEach { <EOL> enabled . convention ( true ) <EOL> packageListUrl . convention ( url . map { it . appendPath ( "<STR_LIT>" ) } ) <EOL> } <EOL> maybeCreate ( "<STR_LIT>" ) { <EOL> enabled . convention ( this @ dss . enableJdkDocumentationLink ) <EOL> url ( this @ dss . jdkVersion . map { jdkVersion -> <EOL> when { <EOL> jdkVersion < <NUM_LIT:11> -> "<STR_LIT>" <EOL> else -> "<STR_LIT>" <EOL> } <EOL> } ) <EOL> packageListUrl ( this @ dss . jdkVersion . map { jdkVersion -> <EOL> when { <EOL> jdkVersion < <NUM_LIT:11> -> "<STR_LIT>" <EOL> else -> "<STR_LIT>" <EOL> } <EOL> } ) <EOL> } <EOL> maybeCreate ( "<STR_LIT>" ) { <EOL> enabled . convention ( this @ dss . enableKotlinStdLibDocumentationLink ) <EOL> url ( "<STR_LIT>" ) <EOL> } <EOL> maybeCreate ( "<STR_LIT>" ) { <EOL> enabled . convention ( this @ dss . enableAndroidDocumentationLink ) <EOL> url ( "<STR_LIT>" ) <EOL> } <EOL> maybeCreate ( "<STR_LIT>" ) { <EOL> enabled . convention ( this @ dss . enableAndroidDocumentationLink ) <EOL> url ( "<STR_LIT>" ) <EOL> packageListUrl ( "<STR_LIT>" ) <EOL> } <EOL> } <EOL> } <EOL> }

/** Set conventions for all [DokkaSourceSetSpec] properties */


protected fun String . appendFormat ( ) : String

= <EOL> when ( val name = formatName ) { <EOL> null -> this <EOL> else -> this + name . uppercaseFirstChar ( ) <EOL> }

/** Appends [formatName] to the end of the string, camelcase style, if [formatName] is not null */


@ kotlin . internal . InlineOnly <EOL> public actual inline fun < T > Array < out T > . elementAt ( index : Int ) : T

{ <EOL> return get ( index ) <EOL> }

/**
 * Returns an element at the given [index] or throws an [IndexOutOfBoundsException] if the [index] is out of bounds of this array.
 *
 * @sample samples.collections.Collections.Elements.elementAt
 */


@ kotlin . internal . InlineOnly <EOL> public actual inline fun ByteArray . elementAt ( index : Int ) : Byte

{ <EOL> return get ( index ) <EOL> }


@ kotlin . internal . InlineOnly <EOL> public actual inline fun ShortArray . elementAt ( index : Int ) : Short

{ <EOL> return get ( index ) <EOL> }


@ kotlin . internal . InlineOnly <EOL> public actual inline fun IntArray . elementAt ( index : Int ) : Int

{ <EOL> return get ( index ) <EOL> }


@ kotlin . internal . InlineOnly <EOL> public actual inline fun LongArray . elementAt ( index : Int ) : Long

{ <EOL> return get ( index ) <EOL> }


@ kotlin . internal . InlineOnly <EOL> public actual inline fun FloatArray . elementAt ( index : Int ) : Float

{ <EOL> return get ( index ) <EOL> }


@ kotlin . internal . InlineOnly <EOL> public actual inline fun DoubleArray . elementAt ( index : Int ) : Double

{ <EOL> return get ( index ) <EOL> }


@ kotlin . internal . InlineOnly <EOL> public actual inline fun BooleanArray . elementAt ( index : Int ) : Boolean

{ <EOL> return get ( index ) <EOL> }


@ kotlin . internal . InlineOnly <EOL> public actual inline fun CharArray . elementAt ( index : Int ) : Char

{ <EOL> return get ( index ) <EOL> }


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

{ <EOL> return filterIsInstanceTo ( ArrayList < R > ( ) , klass ) <EOL> }

/**
 * Returns a list containing all elements that are instances of specified class.
 *
 * @sample samples.collections.Collections.Filtering.filterIsInstanceJVM
 */


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

{ <EOL> @ Suppress ( "<STR_LIT:UNCHECKED_CAST>" ) <EOL> for ( element in this ) if ( klass . isInstance ( element ) ) destination . add ( element as R ) <EOL> return destination <EOL> }

/**
 * Appends all elements that are instances of specified class to the given [destination].
 *
 * @sample samples.collections.Collections.Filtering.filterIsInstanceToJVM
 */


public actual fun < T > Array < out T > . asList ( ) : List < T >

{ <EOL> return ArraysUtilJVM . asList ( this ) <EOL> }

/**
 * Returns a [List] that wraps the original array.
 */


public actual fun ByteArray . asList ( ) : List < Byte >

{ <EOL> return object : AbstractList < Byte > ( ) , RandomAccess { <EOL> override val size : Int get ( ) = this@asList . size <EOL> override fun isEmpty ( ) : Boolean = this@asList . isEmpty ( ) <EOL> override fun contains ( element : Byte ) : Boolean = this@asList . contains ( element ) <EOL> override fun get ( index : Int ) : Byte = this@asList [ index ] <EOL> override fun indexOf ( element : Byte ) : Int = this@asList . indexOf ( element ) <EOL> override fun lastIndexOf ( element : Byte ) : Int = this@asList . lastIndexOf ( element ) <EOL> } <EOL> }


public actual fun ShortArray . asList ( ) : List < Short >

{ <EOL> return object : AbstractList < Short > ( ) , RandomAccess { <EOL> override val size : Int get ( ) = this@asList . size <EOL> override fun isEmpty ( ) : Boolean = this@asList . isEmpty ( ) <EOL> override fun contains ( element : Short ) : Boolean = this@asList . contains ( element ) <EOL> override fun get ( index : Int ) : Short = this@asList [ index ] <EOL> override fun indexOf ( element : Short ) : Int = this@asList . indexOf ( element ) <EOL> override fun lastIndexOf ( element : Short ) : Int = this@asList . lastIndexOf ( element ) <EOL> } <EOL> }


public actual fun IntArray . asList ( ) : List < Int >

{ <EOL> return object : AbstractList < Int > ( ) , RandomAccess { <EOL> override val size : Int get ( ) = this@asList . size <EOL> override fun isEmpty ( ) : Boolean = this@asList . isEmpty ( ) <EOL> override fun contains ( element : Int ) : Boolean = this@asList . contains ( element ) <EOL> override fun get ( index : Int ) : Int = this@asList [ index ] <EOL> override fun indexOf ( element : Int ) : Int = this@asList . indexOf ( element ) <EOL> override fun lastIndexOf ( element : Int ) : Int = this@asList . lastIndexOf ( element ) <EOL> } <EOL> }


public actual fun LongArray . asList ( ) : List < Long >

{ <EOL> return object : AbstractList < Long > ( ) , RandomAccess { <EOL> override val size : Int get ( ) = this@asList . size <EOL> override fun isEmpty ( ) : Boolean = this@asList . isEmpty ( ) <EOL> override fun contains ( element : Long ) : Boolean = this@asList . contains ( element ) <EOL> override fun get ( index : Int ) : Long = this@asList [ index ] <EOL> override fun indexOf ( element : Long ) : Int = this@asList . indexOf ( element ) <EOL> override fun lastIndexOf ( element : Long ) : Int = this@asList . lastIndexOf ( element ) <EOL> } <EOL> }


public actual fun FloatArray . asList ( ) : List < Float >

{ <EOL> return object : AbstractList < Float > ( ) , RandomAccess { <EOL> override val size : Int get ( ) = this@asList . size <EOL> override fun isEmpty ( ) : Boolean = this@asList . isEmpty ( ) <EOL> override fun contains ( element : Float ) : Boolean = this@asList . any { it . toBits ( ) == element . toBits ( ) } <EOL> override fun get ( index : Int ) : Float = this@asList [ index ] <EOL> override fun indexOf ( element : Float ) : Int = this@asList . indexOfFirst { it . toBits ( ) == element . toBits ( ) } <EOL> override fun lastIndexOf ( element : Float ) : Int = this@asList . indexOfLast { it . toBits ( ) == element . toBits ( ) } <EOL> } <EOL> }


public actual fun DoubleArray . asList ( ) : List < Double >

{ <EOL> return object : AbstractList < Double > ( ) , RandomAccess { <EOL> override val size : Int get ( ) = this@asList . size <EOL> override fun isEmpty ( ) : Boolean = this@asList . isEmpty ( ) <EOL> override fun contains ( element : Double ) : Boolean = this@asList . any { it . toBits ( ) == element . toBits ( ) } <EOL> override fun get ( index : Int ) : Double = this@asList [ index ] <EOL> override fun indexOf ( element : Double ) : Int = this@asList . indexOfFirst { it . toBits ( ) == element . toBits ( ) } <EOL> override fun lastIndexOf ( element : Double ) : Int = this@asList . indexOfLast { it . toBits ( ) == element . toBits ( ) } <EOL> } <EOL> }


public actual fun BooleanArray . asList ( ) : List < Boolean >

{ <EOL> return object : AbstractList < Boolean > ( ) , RandomAccess { <EOL> override val size : Int get ( ) = this@asList . size <EOL> override fun isEmpty ( ) : Boolean = this@asList . isEmpty ( ) <EOL> override fun contains ( element : Boolean ) : Boolean = this@asList . contains ( element ) <EOL> override fun get ( index : Int ) : Boolean = this@asList [ index ] <EOL> override fun indexOf ( element : Boolean ) : Int = this@asList . indexOf ( element ) <EOL> override fun lastIndexOf ( element : Boolean ) : Int = this@asList . lastIndexOf ( element ) <EOL> } <EOL> }


public actual fun CharArray . asList ( ) : List < Char >

{ <EOL> return object : AbstractList < Char > ( ) , RandomAccess { <EOL> override val size : Int get ( ) = this@asList . size <EOL> override fun isEmpty ( ) : Boolean = this@asList . isEmpty ( ) <EOL> override fun contains ( element : Char ) : Boolean = this@asList . contains ( element ) <EOL> override fun get ( index : Int ) : Char = this@asList [ index ] <EOL> override fun indexOf ( element : Char ) : Int = this@asList . indexOf ( element ) <EOL> override fun lastIndexOf ( element : Char ) : Int = this@asList . lastIndexOf ( element ) <EOL> } <EOL> }


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

{ <EOL> return java . util . Arrays . binarySearch ( this , fromIndex , toIndex , element , comparator ) <EOL> }

/**
 * Searches the array or the range of the array for the provided [element] using the binary search algorithm.
 * The array is expected to be sorted according to the specified [comparator], otherwise the result is undefined.
 *
 * If the array contains multiple elements equal to the specified [element], there is no guarantee which one will be found.
 *
 * @param element the element to search for.
 * @param comparator the comparator according to which this array is sorted.
 * @param fromIndex the start of the range (inclusive) to search in, 0 by default.
 * @param toIndex the end of the range (exclusive) to search in, size of this array by default.
 *
 * @return the index of the element, if it is contained in the array within the specified range;
 * otherwise, the inverted insertion point `(-insertion point - 1)`.
 * The insertion point is defined as the index at which the element should be inserted,
 * so that the array (or the specified subrange of array) still remains sorted according to the specified [comparator].
 *
 * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.
 * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].
 */


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

{ <EOL> return java . util . Arrays . binarySearch ( this , fromIndex , toIndex , element ) <EOL> }

/**
 * Searches the array or the range of the array for the provided [element] using the binary search algorithm.
 * The array is expected to be sorted, otherwise the result is undefined.
 *
 * If the array contains multiple elements equal to the specified [element], there is no guarantee which one will be found.
 *
 * @param element the to search for.
 * @param fromIndex the start of the range (inclusive) to search in, 0 by default.
 * @param toIndex the end of the range (exclusive) to search in, size of this array by default.
 *
 * @return the index of the element, if it is contained in the array within the specified range;
 * otherwise, the inverted insertion point `(-insertion point - 1)`.
 * The insertion point is defined as the index at which the element should be inserted,
 * so that the array (or the specified subrange of array) still remains sorted.
 *
 * @throws IndexOutOfBoundsException if [fromIndex] is less than zero or [toIndex] is greater than the size of this array.
 * @throws IllegalArgumentException if [fromIndex] is greater than [toIndex].
 */


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


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


public fun IntArray . binarySearch ( element : Int , fromIndex : Int = <NUM_LIT:0> , toIndex : Int = size ) : Int


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


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


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


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


@ SinceKotlin ( "<STR_LIT:1.1>" ) <EOL> @ kotlin . internal . LowPriorityInOverloadResolution <EOL> @ JvmName ( "<STR_LIT>" ) <EOL> @ kotlin . internal . InlineOnly <EOL> public actual inline infix fun < T > Array < out T > . contentDeepEquals ( other : Array < out T > ) : Boolean

{ <EOL> return this . contentDeepEquals ( other ) <EOL> }

/**
 * Checks if the two specified arrays are *deeply* equal to one another.
 *
 * Two arrays are considered deeply equal if they have the same size, and elements at corresponding indices are deeply equal.
 * That is, if two corresponding elements are nested arrays, they are also compared deeply.
 * Elements of other types are compared for equality using the [equals][Any.equals] function.
 * For floating point numbers, this means `NaN` is equal to itself and `-0.0` is not equal to `0.0`.
 *
 * If any of the arrays contain themselves at any nesting level, the behavior is undefined.
 *
 * @param other the array to compare deeply with this array.
 * @return `true` if the two arrays are deeply equal, `false` otherwise.
 *
 * @sample samples.collections.Arrays.ContentOperations.contentDeepEquals
 */


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> @ JvmName ( "<STR_LIT>" ) <EOL> @ kotlin . internal . InlineOnly <EOL> public actual inline infix fun < T > Array < out T > ? . contentDeepEquals ( other : Array < out T > ? ) : Boolean

{ <EOL> if ( kotlin . internal . apiVersionIsAtLeast ( <NUM_LIT:1> , <NUM_LIT:3> , <NUM_LIT:0> ) ) <EOL> return contentDeepEqualsImpl ( other ) <EOL> else <EOL> return java . util . Arrays . deepEquals ( this , other ) <EOL> }

/**
 * Checks if the two specified arrays are *deeply* equal to one another.
 *
 * Two arrays are considered deeply equal if they have the same size, and elements at corresponding indices are deeply equal.
 * That is, if two corresponding elements are nested arrays, they are also compared deeply.
 * Elements of other types are compared for equality using the [equals][Any.equals] function.
 * For floating point numbers, this means `NaN` is equal to itself and `-0.0` is not equal to `0.0`.
 *
 * The arrays are also considered deeply equal if both are `null`.
 *
 * If any of the arrays contain themselves at any nesting level, the behavior is undefined.
 *
 * @param other the array to compare deeply with this array.
 * @return `true` if the two arrays are deeply equal, `false` otherwise.
 *
 * @sample samples.collections.Arrays.ContentOperations.contentDeepEquals
 */


@ SinceKotlin ( "<STR_LIT:1.1>" ) <EOL> @ kotlin . internal . LowPriorityInOverloadResolution <EOL> @ JvmName ( "<STR_LIT>" ) <EOL> @ kotlin . internal . InlineOnly <EOL> public actual inline fun < T > Array < out T > . contentDeepHashCode ( ) : Int

{ <EOL> return this . contentDeepHashCode ( ) <EOL> }

/**
 * Returns a hash code based on the contents of this array as if it is [List].
 * Nested arrays are treated as lists too.
 *
 * If any of arrays contains itself on any nesting level the behavior is undefined.
 */


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> @ JvmName ( "<STR_LIT>" ) <EOL> @ kotlin . internal . InlineOnly <EOL> public actual inline fun < T > Array < out T > ? . contentDeepHashCode ( ) : Int

{ <EOL> if ( kotlin . internal . apiVersionIsAtLeast ( <NUM_LIT:1> , <NUM_LIT:3> , <NUM_LIT:0> ) ) <EOL> return contentDeepHashCodeImpl ( ) <EOL> else <EOL> return java . util . Arrays . deepHashCode ( this ) <EOL> }


@ SinceKotlin ( "<STR_LIT:1.1>" ) <EOL> @ kotlin . internal . LowPriorityInOverloadResolution <EOL> @ JvmName ( "<STR_LIT>" ) <EOL> @ kotlin . internal . InlineOnly <EOL> public actual inline fun < T > Array < out T > . contentDeepToString ( ) : String

{ <EOL> return this . contentDeepToString ( ) <EOL> }

/**
 * Returns a string representation of the contents of this array as if it is a [List].
 * Nested arrays are treated as lists too.
 *
 * If any of arrays contains itself on any nesting level that reference
 * is rendered as `"[...]"` to prevent recursion.
 *
 * @sample samples.collections.Arrays.ContentOperations.contentDeepToString
 */


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> @ JvmName ( "<STR_LIT>" ) <EOL> @ kotlin . internal . InlineOnly <EOL> public actual inline fun < T > Array < out T > ? . contentDeepToString ( ) : String

{ <EOL> if ( kotlin . internal . apiVersionIsAtLeast ( <NUM_LIT:1> , <NUM_LIT:3> , <NUM_LIT:0> ) ) <EOL> return contentDeepToStringImpl ( ) <EOL> else <EOL> return java . util . Arrays . deepToString ( this ) <EOL> }


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> @ kotlin . internal . InlineOnly <EOL> public actual inline infix fun < T > Array < out T > ? . contentEquals ( other : Array < out T > ? ) : Boolean

{ <EOL> return java . util . Arrays . equals ( this , other ) <EOL> }

/**
 * Checks if the two specified arrays are *structurally* equal to one another.
 *
 * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.
 * Elements are compared for equality using the [equals][Any.equals] function.
 * For floating point numbers, this means `NaN` is equal to itself and `-0.0` is not equal to `0.0`.
 *
 * The arrays are also considered structurally equal if both are `null`.
 *
 * If the arrays contain nested arrays, use [contentDeepEquals] to recursively compare their elements.
 *
 * @param other the array to compare with this array.
 * @return `true` if the two arrays are structurally equal, `false` otherwise.
 *
 * @sample samples.collections.Arrays.ContentOperations.arrayContentEquals
 */


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> @ kotlin . internal . InlineOnly <EOL> public actual inline infix fun ByteArray ? . contentEquals ( other : ByteArray ? ) : Boolean

/**
 * Checks if the two specified arrays are *structurally* equal to one another.
 *
 * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.
 *
 * The arrays are also considered structurally equal if both are `null`.
 *
 * @param other the array to compare with this array.
 * @return `true` if the two arrays are structurally equal, `false` otherwise.
 *
 * @sample samples.collections.Arrays.ContentOperations.intArrayContentEquals
 */


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> @ kotlin . internal . InlineOnly <EOL> public actual inline infix fun ShortArray ? . contentEquals ( other : ShortArray ? ) : Boolean


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> @ kotlin . internal . InlineOnly <EOL> public actual inline infix fun IntArray ? . contentEquals ( other : IntArray ? ) : Boolean


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> @ kotlin . internal . InlineOnly <EOL> public actual inline infix fun LongArray ? . contentEquals ( other : LongArray ? ) : Boolean


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> @ kotlin . internal . InlineOnly <EOL> public actual inline infix fun FloatArray ? . contentEquals ( other : FloatArray ? ) : Boolean

/**
 * Checks if the two specified arrays are *structurally* equal to one another.
 *
 * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.
 * Elements are compared for equality using the [equals][Any.equals] function.
 * This means `NaN` is equal to itself and `-0.0` is not equal to `0.0`.
 *
 * The arrays are also considered structurally equal if both are `null`.
 *
 * @param other the array to compare with this array.
 * @return `true` if the two arrays are structurally equal, `false` otherwise.
 *
 * @sample samples.collections.Arrays.ContentOperations.doubleArrayContentEquals
 */


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> @ kotlin . internal . InlineOnly <EOL> public actual inline infix fun DoubleArray ? . contentEquals ( other : DoubleArray ? ) : Boolean


@ SinceKotlin ( "<STR_LIT:1.4>" ) <EOL> @ kotlin . internal . InlineOnly <EOL> public actual inline infix fun BooleanArray ? . contentEquals ( other : BooleanArray ? ) : Boolean

/**
 * Checks if the two specified arrays are *structurally* equal to one another.
 *
 * Two arrays are considered structurally equal if they have the same size, and elements at corresponding indices are equal.
 *
 * The arrays are also considered structurally equal if both are `null`.
 *
 * @param other the array to compare with this array.
 * @return `true` if the two arrays are structurally equal, `false` otherwise.
 *
 * @sample samples.collections.Arrays.ContentOperations.booleanArrayContentEquals
 */