fun getVisibleSourceSets ( visibleFromSourceSet : KotlinSourceSetName , resolvedRootMppDependency : ResolvedDependencyResult , dependencyProjectStructureMetadata : KotlinProjectStructureMetadata , resolvedToOtherProject : Boolean , ) : SourceSetVisibilityResult

{ <EOL> val resolvedRootMppDependencyId = resolvedRootMppDependency . selected . id <EOL> val platformCompilationsByResolvedVariantName = mutableMapOf < String , PlatformCompilationData > ( ) <EOL> val visiblePlatformVariantNames : List < Set < String > > = platformCompilations <EOL> . filter { visibleFromSourceSet in it . allSourceSets } <EOL> . mapNotNull { platformCompilationData -> <EOL> val resolvedPlatformDependencies = platformCompilationData <EOL> . resolvedDependenciesConfiguration <EOL> . allResolvedDependencies <EOL> . filter { it . selected . id isEqualsIgnoringVersion resolvedRootMppDependencyId } <EOL> . ifEmpty { return@mapNotNull null } <EOL> resolvedPlatformDependencies . map { resolvedPlatformDependency -> <EOL> val resolvedVariant = kotlinVariantNameFromPublishedVariantName ( resolvedPlatformDependency . resolvedVariant . displayName ) <EOL> if ( resolvedVariant !in platformCompilationsByResolvedVariantName ) { <EOL> platformCompilationsByResolvedVariantName [ resolvedVariant ] = platformCompilationData <EOL> } <EOL> resolvedVariant <EOL> } . toSet ( ) <EOL> } <EOL> if ( visiblePlatformVariantNames . isEmpty ( ) ) { <EOL> return SourceSetVisibilityResult ( emptySet ( ) , emptyMap ( ) ) <EOL> } <EOL> val visibleSourceSetNames = visiblePlatformVariantNames <EOL> . mapNotNull { platformVariants -> <EOL> platformVariants <EOL> . map { dependencyProjectStructureMetadata . sourceSetNamesByVariantName [ it ] . orEmpty ( ) } <EOL> . fold ( emptySet < String > ( ) ) { acc , item -> acc union item } <EOL> . ifEmpty { null } <EOL> } <EOL> . ifEmpty { listOf ( emptySet ( ) ) } <EOL> . reduce { acc , item -> acc intersect item } <EOL> val hostSpecificArtifactBySourceSet : Map < String , File > = <EOL> if ( resolvedToOtherProject ) { <EOL> emptyMap ( ) <EOL> } else { <EOL> val hostSpecificSourceSets = visibleSourceSetNames . intersect ( dependencyProjectStructureMetadata . hostSpecificSourceSets ) <EOL> val someVariantByHostSpecificSourceSet = <EOL> hostSpecificSourceSets . associate { sourceSetName -> <EOL> sourceSetName to dependencyProjectStructureMetadata . sourceSetNamesByVariantName <EOL> . filterKeys { it in platformCompilationsByResolvedVariantName } <EOL> . filterValues { sourceSetName in it } <EOL> . keys . first ( ) <EOL> } <EOL> someVariantByHostSpecificSourceSet . entries . mapNotNull { ( sourceSetName , variantName ) -> <EOL> val resolvedHostSpecificMetadataConfiguration = platformCompilationsByResolvedVariantName <EOL> . getValue ( variantName ) <EOL> . hostSpecificMetadataConfiguration <EOL> ? : return@mapNotNull null <EOL> val dependency = resolvedHostSpecificMetadataConfiguration <EOL> . allResolvedDependencies <EOL> . find { it . selected . id == resolvedRootMppDependencyId } <EOL> ? : return@mapNotNull null <EOL> val metadataArtifact = resolvedHostSpecificMetadataConfiguration <EOL> . dependencyArtifactsOrNull ( dependency ) <EOL> ? . singleOrNull ( ) <EOL> ? : return@mapNotNull null <EOL> val metadataArtifactFile = metadataArtifact . file <EOL> if ( ! metadataArtifactFile . exists ( ) ) return@mapNotNull null <EOL> sourceSetName to metadataArtifact . file <EOL> } . toMap ( ) <EOL> } <EOL> return SourceSetVisibilityResult ( visibleSourceSetNames , hostSpecificArtifactBySourceSet ) <EOL> }

/**
 * Determine which source sets of the [resolvedRootMppDependency] are visible in the [visibleFromSourceSet] source set.
 *
 * This requires resolving dependencies of the compilations which [visibleFromSourceSet] takes part in, in order to find which variants the
 * [resolvedRootMppDependency] got resolved to for those compilations.
 *
 * Once the variants are known, they are checked against the [dependencyProjectStructureMetadata], and the
 * source sets of the dependency are determined that are compiled for all those variants and thus should be visible here.
 *
 * If the [resolvedRootMppDependency] is a project dependency, its project should be passed as [resolvedToOtherProject], as
 * the Gradle API for dependency variants behaves differently for project dependencies and published ones.
 */


private infix fun ComponentIdentifier . isEqualsIgnoringVersion ( that : ComponentIdentifier ) : Boolean

{ <EOL> if ( this is ProjectComponentIdentifier && that is ProjectComponentIdentifier ) return this == that <EOL> if ( this is ModuleComponentIdentifier && that is ModuleComponentIdentifier ) return this . moduleIdentifier == that . moduleIdentifier <EOL> return false <EOL> }

/**
 * Returns true when two components identifiers are from the same maven module (group + name)
 * Gradle projects can't be resolved into multiple versions since there is only one version of a project in gradle build
 */


private fun needSuspendConversion ( type : IrSimpleType , function : FirFunction ) : Boolean

{ <EOL> return type . isSuspendFunction ( ) && ! function . isSuspend <EOL> }

/**
 * For example,
 * fun referenceConsumer(f: suspend () -> Unit) = ...
 * fun nonSuspendFunction(...) = ...
 * fun useSite(...) = { ... referenceConsumer(::nonSuspendFunction) ... }
 *
 * At the use site, instead of referenced, we can put the suspend lambda as an adapter.
 */


private fun needCoercionToUnit ( type : IrSimpleType , function : FirFunction ) : Boolean

{ <EOL> val expectedReturnType = type . arguments . last ( ) . typeOrNull <EOL> val actualReturnType = function . returnTypeRef . coneType <EOL> return expectedReturnType ? . isUnit ( ) == true && <EOL> ! actualReturnType . isUnit && actualReturnType . toSymbol ( c . session ) !is FirTypeParameterSymbol <EOL> }

/**
 * For example,
 * fun referenceConsumer(f: () -> Unit) = f()
 * fun referenced(...): Any { ... }
 * fun useSite(...) = { ... referenceConsumer(::referenced) ... }
 *
 * At the use site, instead of referenced, we can put the adapter: { ... -> referenced(...) }
 */


private fun hasVarargOrDefaultArguments ( callableReferenceAccess : FirCallableReferenceAccess ) : Boolean

{ <EOL> val calleeReference = callableReferenceAccess . calleeReference as? FirResolvedCallableReference ? : return false <EOL> return calleeReference . mappedArguments . any { ( _ , value ) -> <EOL> value is ResolvedCallArgument . VarargArgument || value is ResolvedCallArgument . DefaultArgument <EOL> } <EOL> }

/**
 * For example,
 * fun referenceConsumer(f: (Char, Char) -> String): String = ... // e.g., f(char1, char2)
 * fun referenced(vararg xs: Char) = ...
 * fun useSite(...) = { ... referenceConsumer(::referenced) ... }
 *
 * At the use site, instead of referenced, we can put the adapter: { a, b -> referenced(a, b) }
 */


internal fun IrExpression . applySuspendConversionIfNeeded ( argument : FirExpression , parameterType : ConeKotlinType ) : IrExpression

{ <EOL> if ( this is IrBlock && origin == IrStatementOrigin . ADAPTED_FUNCTION_REFERENCE ) { <EOL> return this <EOL> } <EOL> if ( ! parameterType . isSuspendOrKSuspendFunctionType ( session ) ) { <EOL> return this <EOL> } <EOL> val expectedFunctionalType = parameterType . customFunctionTypeToSimpleFunctionType ( session ) <EOL> if ( this is IrVararg ) { <EOL> return applyConversionOnVararg ( argument ) { firVarargArgument -> <EOL> applySuspendConversionIfNeeded ( firVarargArgument , parameterType ) <EOL> } <EOL> } <EOL> val invokeSymbol = findInvokeSymbol ( expectedFunctionalType , argument ) ? : return this <EOL> val suspendConvertedType = parameterType . toIrType ( c ) as IrSimpleType <EOL> return argument . convertWithOffsets { startOffset , endOffset -> <EOL> val irAdapterFunction = createAdapterFunctionForArgument ( startOffset , endOffset , suspendConvertedType , type , invokeSymbol ) <EOL> val irAdapterRef = IrFunctionReferenceImpl ( startOffset , endOffset , suspendConvertedType , irAdapterFunction . symbol , irAdapterFunction . typeParameters . size , irAdapterFunction . valueParameters . size , null , IrStatementOrigin . SUSPEND_CONVERSION ) <EOL> IrBlockImpl ( startOffset , endOffset , suspendConvertedType , IrStatementOrigin . SUSPEND_CONVERSION ) . apply { <EOL> statements . add ( irAdapterFunction ) <EOL> statements . add ( irAdapterRef . apply { extensionReceiver = this@applySuspendConversionIfNeeded } ) <EOL> } <EOL> } <EOL> }

/**
 * For example,
 * fun consumer(f: suspend () -> Unit) = ...
 * fun nonSuspendFunction = { ... }
 * fun useSite(...) = { ... consumer(nonSuspendFunction) ... }
 *
 * At the use site, instead of the argument, we can put the suspend lambda as an adapter.
 *
 * Instead of functions, a subtype of functional type can be used too:
 * class Foo {
 * override fun invoke() = ...
 * }
 * fun useSite(...) = { ... consumer(Foo()) ... }
 */


inline fun < reified T : Number > amin ( a : KtNDArray < T > ) : T

= <EOL> callFunc ( nameMethod = arrayOf ( "<STR_LIT>" ) , args = arrayOf ( a ) , kClass = T :: class )

/**
 * Return the minimum of an array or minimum along an axis.
 */


inline fun < reified T : Number > amax ( a : KtNDArray < T > ) : T

/**
 * Return the maximum of an array or maximum along an axis.
 */


fun < T : Number > nanmin ( a : KtNDArray < T > ) : Double

= <EOL> callFunc ( nameMethod = arrayOf ( "<STR_LIT>" ) , args = arrayOf ( a ) , kClass = Double :: class )

/**
 * Return minimum of an array or minimum along an axis, ignoring any NaNs.
 */


fun < T : Number > nanmax ( a : KtNDArray < T > ) : Double

/**
 * Return the maximum of an array or maximum along an axis, ignoring any NaNs.
 */


fun < T : Number > ptp ( a : KtNDArray < T > , axis : Int ) : KtNDArray < T >

= <EOL> callFunc ( nameMethod = arrayOf ( "<STR_LIT>" ) , args = arrayOf ( a , axis ) )

/**
 * Range of values (maximum - minimum) along an axis.
 */


fun < T : Number > percentile ( a : KtNDArray < T > , q : Double ) : Double

= <EOL> callFunc ( nameMethod = arrayOf ( "<STR_LIT>" ) , args = arrayOf ( a , q ) , kClass = Double :: class )

/**
 * Compute the q-th percentile of the data along the specified axis.
 */


fun < T : Number > nanPercentile ( a : KtNDArray < T > , q : Double ) : Double


fun < T : Number > nanPercentile ( a : KtNDArray < T > , q : Double , axis : Int ) : KtNDArray < Double >

= <EOL> callFunc ( nameMethod = arrayOf ( "<STR_LIT>" ) , args = arrayOf ( a , q , axis ) )

/**
 * Compute the qth percentile of the data along the specified axis, while ignoring nan values.
 */


fun < T : Number > quantile ( a : KtNDArray < T > , q : Double ) : Double

/**
 * Compute the q-th quantile of the data along the specified axis.
 */


fun < T : Number > nanQuantile ( a : KtNDArray < T > , q : Double ) : Double

/**
 * Compute the qth quantile of the data along the specified axis, while ignoring nan values.
 */


public fun < T > intercept ( column : ColumnReference < T > , ) : PositionalMapping < T >

{ <EOL> return addPositionalMapping < T > ( INTERCEPT , column . name ( ) , null ) <EOL> }

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


public fun < T > intercept ( column : KProperty < T > , ) : PositionalMapping < T >

{ <EOL> return addPositionalMapping < T > ( INTERCEPT , column . name , null ) <EOL> }

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


public fun intercept ( column : String , ) : PositionalMapping < Any ? >

{ <EOL> return addPositionalMapping < Any ? > ( INTERCEPT , column , null ) <EOL> }

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


public fun < T > intercept ( values : Iterable < T > , ) : PositionalMapping < T >

{ <EOL> return addPositionalMapping < T > ( INTERCEPT , values . toList ( ) , null , null ) <EOL> }

/**
 * Maps the `intercept` aesthetic to iterable of values.
 *
 * @param values The iterable of values to be mapped.
 * @return A [PositionalMapping] object representing the mapping.
 */


public fun < T > intercept ( values : DataColumn < T > , ) : PositionalMapping < T >

{ <EOL> return addPositionalMapping < T > ( INTERCEPT , values , null ) <EOL> }

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


public abstract fun substitute ( substitutor : KtSubstitutor ) : KtCallableSignature < S >

/**
 * Applies a [substitutor] to the given signature and return a new signature with substituted types.
 *
 * @see KtSubstitutor.substitute
 */


public abstract override fun close ( )

/**
 * Closes this coroutine dispatcher and shuts down its executor.
 *
 * It may throw an exception if this dispatcher is global and cannot be closed.
 */


@ JvmName ( "<STR_LIT>" ) <EOL> public fun ExecutorService . asCoroutineDispatcher ( ) : ExecutorCoroutineDispatcher

= <EOL> ExecutorCoroutineDispatcherImpl ( this )

/**
 * Converts an instance of [ExecutorService] to an implementation of [ExecutorCoroutineDispatcher].
 *
 * ## Interaction with [delay] and time-based coroutines.
 *
 * If the given [ExecutorService] is an instance of [ScheduledExecutorService], then all time-related
 * coroutine operations such as [delay], [withTimeout] and time-based [Flow] operators will be scheduled
 * on this executor using [schedule][ScheduledExecutorService.schedule] method. If the corresponding
 * coroutine is cancelled, [ScheduledFuture.cancel] will be invoked on the corresponding future.
 *
 * If the given [ExecutorService] is an instance of [ScheduledThreadPoolExecutor], then prior to any scheduling,
 * remove on cancel policy will be set via [ScheduledThreadPoolExecutor.setRemoveOnCancelPolicy] in order
 * to reduce the memory pressure of cancelled coroutines.
 *
 * If the executor service is neither of this types, the separate internal thread will be used to
 * _track_ the delay and time-related executions, but the coroutine itself will still be executed
 * on top of the given executor.
 *
 * ## Rejected execution
 * If the underlying executor throws [RejectedExecutionException] on
 * attempt to submit a continuation task (it happens when [closing][ExecutorCoroutineDispatcher.close] the
 * resulting dispatcher, on underlying executor [shutdown][ExecutorService.shutdown], or when it uses limited queues),
 * then the [Job] of the affected task is [cancelled][Job.cancel] and the task is submitted to the
 * [Dispatchers.IO], so that the affected coroutine can cleanup its resources and promptly complete.
 */


@ JvmName ( "<STR_LIT>" ) <EOL> public fun Executor . asCoroutineDispatcher ( ) : CoroutineDispatcher

= <EOL> ( this as? DispatcherExecutor ) ? . dispatcher ? : ExecutorCoroutineDispatcherImpl ( this )

/**
 * Converts an instance of [Executor] to an implementation of [CoroutineDispatcher].
 *
 * ## Interaction with [delay] and time-based coroutines.
 *
 * If the given [Executor] is an instance of [ScheduledExecutorService], then all time-related
 * coroutine operations such as [delay], [withTimeout] and time-based [Flow] operators will be scheduled
 * on this executor using [schedule][ScheduledExecutorService.schedule] method. If the corresponding
 * coroutine is cancelled, [ScheduledFuture.cancel] will be invoked on the corresponding future.
 *
 * If the given [Executor] is an instance of [ScheduledThreadPoolExecutor], then prior to any scheduling,
 * remove on cancel policy will be set via [ScheduledThreadPoolExecutor.setRemoveOnCancelPolicy] in order
 * to reduce the memory pressure of cancelled coroutines.
 *
 * If the executor is neither of this types, the separate internal thread will be used to
 * _track_ the delay and time-related executions, but the coroutine itself will still be executed
 * on top of the given executor.
 *
 * ## Rejected execution
 *
 * If the underlying executor throws [RejectedExecutionException] on
 * attempt to submit a continuation task (it happens when [closing][ExecutorCoroutineDispatcher.close] the
 * resulting dispatcher, on underlying executor [shutdown][ExecutorService.shutdown], or when it uses limited queues),
 * then the [Job] of the affected task is [cancelled][Job.cancel] and the task is submitted to the
 * [Dispatchers.IO], so that the affected coroutine can cleanup its resources and promptly complete.
 */


public fun CoroutineDispatcher . asExecutor ( ) : Executor

= <EOL> ( this as? ExecutorCoroutineDispatcher ) ? . executor ? : DispatcherExecutor ( this )

/**
 * Converts an instance of [CoroutineDispatcher] to an implementation of [Executor].
 *
 * It returns the original executor when used on the result of [Executor.asCoroutineDispatcher] extensions.
 */


@ JvmName ( "<STR_LIT>" ) <EOL> internal fun resetStateReusable ( ) : Boolean

{ <EOL> assert { resumeMode == MODE_CANCELLABLE_REUSABLE } <EOL> assert { parentHandle !== NonDisposableHandle } <EOL> val state = _state . value <EOL> assert { state !is NotCompleted } <EOL> if ( state is CompletedContinuation && state . idempotentResume != null ) { <EOL> detachChild ( ) <EOL> return false <EOL> } <EOL> _decisionAndIndex . value = decisionAndIndex ( UNDECIDED , NO_INDEX ) <EOL> _state . value = Active <EOL> return true <EOL> }

/**
 * Resets cancellability state in order to [suspendCancellableCoroutineReusable] to work.
 * Invariant: used only by [suspendCancellableCoroutineReusable] in [REUSABLE_CLAIMED] state.
 */


open fun getContinuationCancellationCause ( parent : Job ) : Throwable

= <EOL> parent . getCancellationException ( )

/**
 * It is used when parent is cancelled to get the cancellation cause for this continuation.
 */


internal fun releaseClaimedReusableContinuation ( )

{ <EOL> val cancellationCause = ( delegate as? DispatchedContinuation < * > ) ? . tryReleaseClaimedContinuation ( this ) ? : return <EOL> detachChild ( ) <EOL> cancel ( cancellationCause ) <EOL> }

/**
 * Tries to release reusable continuation. It can fail is there was an asynchronous cancellation,
 * in which case it detaches from the parent and cancels this continuation.
 */


override fun invokeOnCancellation ( segment : Segment < * > , index : Int )

{ <EOL> _decisionAndIndex . update { <EOL> check ( it . index == NO_INDEX ) { <EOL> "<STR_LIT>" <EOL> } <EOL> decisionAndIndex ( it . decision , index ) <EOL> } <EOL> invokeOnCancellationImpl ( segment ) <EOL> }

/**
 * An optimized version for the code below that does not allocate
 * a cancellation handler object and efficiently stores the specified
 * [segment] and [index] in this [CancellableContinuationImpl].
 *
 * The only difference is that `segment.onCancellation(..)` is never
 * called if this continuation is already completed;
 *
 * ```
 * invokeOnCancellation { cause ->
 * segment.onCancellation(index, cause)
 * }
 * ```
 */


private fun tryResumeImpl ( proposedUpdate : Any ? , idempotent : Any ? , onCancellation : ( ( cause : Throwable ) -> Unit ) ? <EOL> ) : Symbol ?

{ <EOL> _state . loop { state -> <EOL> when ( state ) { <EOL> is NotCompleted -> { <EOL> val update = resumedState ( state , proposedUpdate , resumeMode , onCancellation , idempotent ) <EOL> if ( ! _state . compareAndSet ( state , update ) ) return@loop <EOL> detachChildIfNonResuable ( ) <EOL> return RESUME_TOKEN <EOL> } <EOL> is CompletedContinuation -> { <EOL> return if ( idempotent != null && state . idempotentResume === idempotent ) { <EOL> assert { state . result == proposedUpdate } <EOL> RESUME_TOKEN <EOL> } else { <EOL> null <EOL> } <EOL> } <EOL> else -> return null <EOL> } <EOL> } <EOL> }

/**
 * Similar to [tryResume], but does not actually completes resume (needs [completeResume] call).
 * Returns [RESUME_TOKEN] when resumed, `null` when it was already resumed or cancelled.
 */


{ <EOL> val handle = parentHandle ? : return <EOL> handle . dispose ( ) <EOL> _parentHandle . value = NonDisposableHandle <EOL> }


fun invoke ( cause : Throwable ? )

/**
 * Signals cancellation.
 *
 * This function:
 * - Does not throw any exceptions.
 * Violating this rule in an implementation leads to [handleUncaughtCoroutineException] being called with a
 * [CompletionHandlerException] wrapping the thrown exception.
 * - Is fast, non-blocking, and thread-safe.
 * - Can be invoked concurrently with the surrounding code.
 * - Can be invoked from any context.
 *
 * The meaning of `cause` that is passed to the handler is:
 * - It is `null` if the continuation was cancelled directly via [CancellableContinuation.cancel] without a `cause`.
 * - It is an instance of [CancellationException] if the continuation was _normally_ cancelled from the outside.
 * **It should not be treated as an error**. In particular, it should not be reported to error logs.
 * - Otherwise, the continuation had cancelled with an _error_.
 */


override fun invoke ( cause : Throwable ? )

{ handler ( cause ) }


internal fun List < SerialDescriptor > ? . compactArray ( ) : Array < SerialDescriptor >

= <EOL> takeUnless { it . isNullOrEmpty ( ) } ? . toTypedArray ( ) ? : EMPTY_DESCRIPTOR_ARRAY

/**
 * Same as [toTypedArray], but uses special empty array constant, if [this]
 * is null or empty.
 */


internal expect fun < T : Any > KClass < T > . constructSerializerForGivenTypeArgs ( vararg args : KSerializer < Any ? > ) : KSerializer < T > ?

/**
 * Constructs KSerializer<D<T0, T1, ...>> by given KSerializer<T0>, KSerializer<T1>, ...
 * via reflection (on JVM) or compiler+plugin intrinsic `SerializerFactory` (on Native)
 */


internal expect fun isReferenceArray ( rootClass : KClass < Any > ) : Boolean

/**
 * Checks whether given KType and its corresponding KClass represent a reference array
 */


internal expect fun < T > Array < T > . getChecked ( index : Int ) : T

/**
 * Array.get that checks indices on JS
 */


internal expect fun BooleanArray . getChecked ( index : Int ) : Boolean


internal expect fun < T > createCache ( factory : ( KClass < * > ) -> KSerializer < T > ? ) : SerializerCache < T >

/**
 * Create serializers cache for non-parametrized and non-contextual serializers.
 * The activity and type of cache is determined for a specific platform and a specific environment.
 */


internal expect fun < T > createParametrizedCache ( factory : ( KClass < Any > , List < KType > ) -> KSerializer < T > ? ) : ParametrizedSerializerCache < T >

/**
 * Create serializers cache for parametrized and non-contextual serializers. Parameters also non-contextual.
 * The activity and type of cache is determined for a specific platform and a specific environment.
 */


fun get ( key : KClass < Any > ) : KSerializer < T > ?

/**
 * Returns cached serializer or `null` if serializer not found.
 */


fun get ( key : KClass < Any > , types : List < KType > = emptyList ( ) ) : Result < KSerializer < T > ? >

/**
 * Returns successful result with cached serializer or `null` if root serializer not found.
 * If no serializer was found for the parameters, then result contains an exception.
 */


fun getClassId ( ) : ClassId ?

/**
 * Return [ClassId], if the class is not local (E.e, if a class can be accessed by that [ClassId] from another context)
 *
 * For classes that itself local (are declared inside a function or other local scope), returns `null`.
 * For nested classes in local classes returns `null`.
 * For KtEnumEntry returns null as enum entry is not a class semantically. And so, for nested classes in enum entry, returns `null`.
 * Otherwise, returns non-null [ClassId].
 *
 * For returned ClassId, the [ClassId.isLocal] is always `false`.
 */


{ <EOL> System . setProperty ( "<STR_LIT>" , computeHomeDirectory ( ) ) <EOL> System . setProperty ( "<STR_LIT>" , "<STR_LIT:true>" ) <EOL> }

/**
 * For proper initialization of idea services those two properties should
 * be set in environment of test. You can setup them manually via build
 * system of run configurations or just `initIdeaConfiguration` before
 * running tests using abilities of core test framework you use
 */


internal fun Scale . wrap ( aes : Aesthetic , domainType : KType , scaleParameters : ScaleParameters ? , isGroupKey : Boolean , ) : org . jetbrains . letsPlot . intern . Scale

{ <EOL> return when ( this ) { <EOL> is PositionalScale < * > -> { <EOL> val naValue = if ( this is ContinuousScale < * > ) { <EOL> wrapValue ( nullValue ) <EOL> } else { <EOL> null <EOL> } <EOL> val axis = scaleParameters as? Axis < * > ? <EOL> val name = axis ? . name <EOL> val breaks = axis ? . breaks <EOL> val labels = axis ? . labels <EOL> val format = axis ? . format <EOL> val expand = axis ? . expand <EOL> val position = axis ? . position ? . let { <EOL> when ( it ) { <EOL> AxisPosition . DEFAULT -> null <EOL> AxisPosition . OPPOSITE -> when ( aes ) { <EOL> X -> "<STR_LIT>" <EOL> Y -> "<STR_LIT>" <EOL> else -> null <EOL> } <EOL> AxisPosition . BOTH -> "<STR_LIT>" <EOL> } <EOL> } <EOL> when ( this ) { <EOL> is PositionalCategoricalScale < * > -> { <EOL> when ( aes ) { <EOL> X -> scaleXDiscrete ( limits = categories ? . wrap ( ) , name = name , breaks = breaks ? . wrap ( ) , labels = labels , format = format , expand = expand , position = position ) <EOL> Y -> scaleYDiscrete ( limits = categories ? . wrap ( ) , name = name , breaks = breaks ? . wrap ( ) , labels = labels , format = format , expand = expand , position = position ) <EOL> else -> TODO ( "<STR_LIT:error>" ) <EOL> } <EOL> } <EOL> is PositionalContinuousScale < * > -> { <EOL> when ( aes ) { <EOL> X -> if ( domainType in dateTimeTypes ) { <EOL> scaleXDateTime ( limits = ( min to max ) . wrap ( ) , name = name , breaks = breaks ? . filterNotNull ( ) , labels = labels , format = format , expand = expand , position = position ) <EOL> } else if ( domainType in timeTypes ) { <EOL> scaleXTime ( limits = ( min to max ) . wrap ( ) , name = name , breaks = breaks ? . filterNotNull ( ) , labels = labels , expand = expand , position = position ) <EOL> } else { <EOL> scaleXContinuous ( limits = ( min to max ) . wrap ( ) , name = name , breaks = breaks ? . map { it as Number } , labels = labels , trans = ( transform as? Transformation ) ? . name , format = format , expand = expand , naValue = naValue as? Number , position = position ) <EOL> } <EOL> Y -> if ( domainType in dateTimeTypes ) { <EOL> scaleYDateTime ( limits = ( min to max ) . wrap ( ) , name = name , breaks = breaks ? . wrap ( ) , labels = labels , format = format , expand = expand , naValue = naValue , position = position ) <EOL> } else if ( domainType in timeTypes ) { <EOL> scaleYTime ( limits = ( min to max ) . wrap ( ) , name = name , breaks = breaks ? . filterNotNull ( ) , labels = labels , expand = expand , position = position ) <EOL> } else { <EOL> scaleYContinuous ( limits = ( min to max ) . wrap ( ) , name = name , breaks = breaks ? . map { it as Number } , labels = labels , trans = ( transform as? Transformation ) ? . name , format = format , expand = expand , naValue = naValue as? Number , position = position ) <EOL> } <EOL> else -> TODO ( ) <EOL> } <EOL> } <EOL> is PositionalDefaultScale < * > -> if ( domainType . isCategoricalType ( ) || isGroupKey ) { <EOL> PositionalCategoricalScale < String > ( null ) . wrap ( aes , domainType , scaleParameters , isGroupKey ) <EOL> } else { <EOL> PositionalContinuousScale < Double > ( null , null , null , null ) . wrap ( aes , domainType , scaleParameters , isGroupKey ) <EOL> } <EOL> } <EOL> } <EOL> is NonPositionalScale < * , * > -> { <EOL> val naValue = if ( this is ContinuousScale < * > ) { <EOL> wrapValue ( nullValue ) <EOL> } else { <EOL> ( this as? NonPositionalCategoricalScale < * , * > ) ? . domainCategories ? . indexOf ( null ) ? . let { <EOL> if ( it == - <NUM_LIT:1> ) { <EOL> null <EOL> } else rangeValues ? . get ( it ) ? . let { <EOL> wrapValue ( it ) <EOL> } <EOL> } <EOL> } <EOL> val legend = scaleParameters as? Legend < * , * > ? <EOL> val name = legend ? . name <EOL> val breaks = legend ? . breaks <EOL> val labels = legend ? . labels <EOL> val format = legend ? . format <EOL> val legendType = legend ? . type ? . let { <EOL> when ( it ) { <EOL> is LegendType . None -> "<STR_LIT>" <EOL> is LegendType . ColorBar -> guideColorbar ( barHeight = it . barHeight , barWidth = it . barWidth , nbin = it . nBin ) <EOL> is LegendType . DiscreteLegend -> guideLegend ( nrow = it . nRow , ncol = it . nCol , byRow = it . byRow ) <EOL> } <EOL> } <EOL> when ( this ) { <EOL> is NonPositionalDefaultScale < * , * > -> if ( this is NonPositionalDefaultCategoricalScale < * , * > || domainType . isCategoricalType ( ) || aes in discreteAes || isGroupKey ) { <EOL> NonPositionalCategoricalScale < String , String > ( null , null ) . wrap ( aes , domainType , scaleParameters , isGroupKey ) <EOL> } else { <EOL> NonPositionalContinuousScale < Double , Double > ( null , null , null , null , null , null ) . wrap ( aes , domainType , scaleParameters , isGroupKey ) <EOL> } <EOL> is NonPositionalCategoricalScale < * , * > -> { <EOL> when ( aes ) { <EOL> SIZE -> if ( rangeValues != null ) { <EOL> scaleSizeManual ( values = rangeValues ! ! . map { it as Number } , limits = domainCategories ? . wrap ( ) , name = name , breaks = breaks ? . wrap ( ) , labels = labels , guide = legendType , format = format , naValue = naValue as? Number ) <EOL> } else { <EOL> org . jetbrains . letsPlot . intern . Scale ( Aes . SIZE , limits = domainCategories ? . wrap ( ) , name = name , breaks = breaks ? . wrap ( ) , labels = labels , guide = legendType , format = format , ) <EOL> } <EOL> COLOR -> { <EOL> if ( rangeValues == null ) { <EOL> scaleColorDiscrete ( limits = domainCategories ? . wrap ( ) , name = name , breaks = breaks ? . wrap ( ) , labels = labels , guide = legendType , format = format , naValue = naValue ) <EOL> } else { <EOL> scaleColorManual ( limits = domainCategories ? . wrap ( ) , values = rangeValues ! ! . map { ( it as Color ) . wrap ( ) } , name = name , breaks = breaks ? . wrap ( ) , labels = labels , guide = legendType , format = format , naValue = naValue ) <EOL> } <EOL> } <EOL> FILL -> { <EOL> if ( rangeValues == null ) { <EOL> scaleFillDiscrete ( limits = domainCategories ? . wrap ( ) , name = name , breaks = breaks ? . wrap ( ) , labels = labels , guide = legendType , format = format , naValue = naValue ) <EOL> } else { <EOL> scaleFillManual ( limits = domainCategories ? . wrap ( ) , values = rangeValues ! ! . map { ( it as Color ) . wrap ( ) } , name = name , breaks = breaks ? . wrap ( ) , labels = labels , guide = legendType , format = format , naValue = naValue ) <EOL> } <EOL> } <EOL> ALPHA -> if ( rangeValues != null ) { <EOL> scaleAlphaManual ( limits = domainCategories ? . wrap ( ) , values = rangeValues ! ! . map { it as Double } , name = name , breaks = breaks ? . wrap ( ) , labels = labels , guide = legendType , format = format , naValue = naValue as? Number ) <EOL> } else { <EOL> org . jetbrains . letsPlot . intern . Scale ( Aes . ALPHA , limits = domainCategories ? . wrap ( ) , name = name , breaks = breaks ? . wrap ( ) , labels = labels , guide = legendType , format = format , naValue = naValue ) <EOL> } <EOL> LINE_TYPE -> if ( rangeValues != null ) { <EOL> scaleLinetypeManual ( limits = domainCategories ? . wrap ( ) , values = rangeValues ! ! . map { ( it as LineType ) . codeNumber } , name = name , breaks = breaks ? . wrap ( ) , labels = labels , guide = legendType , format = format , naValue = naValue ) <EOL> } else { <EOL> org . jetbrains . letsPlot . intern . Scale ( Aes . LINETYPE , limits = domainCategories ? . wrap ( ) , name = name , breaks = breaks ? . wrap ( ) , labels = labels , guide = legendType , format = format , naValue = naValue ) <EOL> } <EOL> SHAPE -> if ( rangeValues == null ) { <EOL> scaleShape ( limits = domainCategories ? . wrap ( ) , name = name , breaks = breaks ? . wrap ( ) , labels = labels , guide = legendType , format = format , naValue = naValue ) <EOL> } else { <EOL> scaleShapeManual ( limits = domainCategories ? . wrap ( ) , values = rangeValues ! ! . map { ( it as Symbol ) . shape } , name = name , breaks = breaks ? . wrap ( ) , labels = labels , guide = legendType , format = format , naValue = naValue ) <EOL> } <EOL> else -> TODO ( ) <EOL> } <EOL> } <EOL> is NonPositionalContinuousScale < * , * > -> { <EOL> when ( aes ) { <EOL> SIZE -> scaleSize ( limits = ( domainMin to domainMax ) . wrap ( ) , range = ( rangeMin to rangeMax ) . computeRange ( ) , name = name , breaks = breaks ? . map { it as Number } , labels = labels , guide = legendType , trans = ( transform as Transformation ? ) ? . name , format = format , naValue = naValue as? Number ) <EOL> STROKE -> scaleStroke ( range = ( rangeMin to rangeMax ) . computeRange ( ) , name = name , breaks = breaks ? . map { it as? Number } , labels = labels , limits = ( domainMin to domainMax ) . wrap ( ) , naValue = naValue as? Number , format = format , guide = legendType , trans = ( transform as? Transformation ) ? . name ) <EOL> COLOR -> { <EOL> val lowColor = ( rangeMin as? Color ) ? . wrap ( ) <EOL> val highColor = ( rangeMax as? Color ) ? . wrap ( ) <EOL> val limits = ( domainMin to domainMax ) . wrap ( ) <EOL> org . jetbrains . letsPlot . intern . Scale ( aesthetic = Aes . COLOR , name = name , breaks = breaks ? . map { it . toString ( ) } , labels = labels , limits = limits , naValue = naValue , format = format , guide = legendType , trans = ( transform as Transformation ? ) ? . name , otherOptions = Options ( mapOf ( Option . Scale . LOW to lowColor , Option . Scale . HIGH to highColor , Option . Scale . SCALE_MAPPER_KIND to Option . Scale . MapperKind . COLOR_GRADIENT ) ) ) <EOL> } <EOL> FILL -> { <EOL> val lowColor = ( rangeMin as? Color ) ? . wrap ( ) <EOL> val highColor = ( rangeMax as? Color ) ? . wrap ( ) <EOL> val limits = ( domainMin to domainMax ) . wrap ( ) <EOL> org . jetbrains . letsPlot . intern . Scale ( aesthetic = Aes . FILL , name = name , breaks = breaks ? . map { it . toString ( ) } , labels = labels , limits = limits , naValue = naValue , format = format , guide = legendType , trans = ( transform as Transformation ? ) ? . name , otherOptions = Options ( mapOf ( Option . Scale . LOW to lowColor , Option . Scale . HIGH to highColor , Option . Scale . SCALE_MAPPER_KIND to Option . Scale . MapperKind . COLOR_GRADIENT ) ) ) <EOL> } <EOL> ALPHA -> scaleAlpha ( limits = ( domainMin to domainMax ) . wrap ( ) , range = ( rangeMin to rangeMax ) . wrap ( ) as Pair < Number , Number > ? , name = name , breaks = breaks ? . map { it as Number } , labels = labels , guide = legendType , trans = ( transform as Transformation ? ) ? . name , format = format , naValue = naValue as? Number ) <EOL> else -> TODO ( ) <EOL> } <EOL> } <EOL> is CustomScale -> when ( this ) { <EOL> is ScaleColorGrey < * > -> when ( aes ) { <EOL> COLOR -> scaleColorGrey ( paletteRange ? . first , paletteRange ? . second , name = name , breaks = breaks ? . map { it as Number } , labels = labels , guide = legendType , limits = domainLimits . wrap ( ) , trans = transform ? . name , format = format , naValue = naValue ) <EOL> FILL -> scaleFillGrey ( paletteRange ? . first , paletteRange ? . second , name = name , breaks = breaks ? . map { it as Number } , labels = labels , guide = legendType , limits = domainLimits . wrap ( ) , trans = transform ? . name , format = format , naValue = naValue ) <EOL> else -> TODO ( ) <EOL> } <EOL> is ScaleColorHue < * > -> when ( aes ) { <EOL> COLOR -> scaleColorHue ( huesRange , chroma , luminance , hueStart , direction ? . value , name = name , breaks = breaks ? . map { it as Number } , labels = labels , guide = legendType , limits = domainLimits . wrap ( ) , trans = transform ? . name , format = format , naValue = naValue ) <EOL> FILL -> scaleFillHue ( huesRange , chroma , luminance , hueStart , direction ? . value , name = name , breaks = breaks ? . map { it as Number } , labels = labels , guide = legendType , limits = domainLimits . wrap ( ) , trans = transform ? . name , format = format , naValue = naValue ) <EOL> else -> TODO ( ) <EOL> } <EOL> is ScaleColorBrewer < * > -> when ( aes ) { <EOL> COLOR -> scaleColorBrewer ( type = null , palette = palette ? . name , name = name , breaks = breaks ? . map { it as Number } , labels = labels , guide = legendType , limits = limits , trans = transform ? . name , format = format , naValue = naValue ) <EOL> FILL -> scaleFillBrewer ( type = null , palette = palette ? . name , name = name , breaks = breaks ? . map { it as Number } , labels = labels , guide = legendType , limits = limits , trans = transform ? . name , format = format , naValue = naValue ) <EOL> else -> TODO ( ) <EOL> } <EOL> is ScaleColorViridis < * > -> { <EOL> val option = colormap . name . lowercase ( ) <EOL> val begin = hueRange . start <EOL> val end = hueRange . endInclusive <EOL> val direction = direction . value <EOL> val trans = ( this as? ScaleContinuousColorViridis < * > ) ? . transform ? . name <EOL> when ( aes ) { <EOL> COLOR -> scaleColorViridis ( option = option , alpha = null , begin = begin , end = end , direction = direction , name = name , breaks = breaks ? . map { it as Number } , labels = labels , guide = legendType , limits = limits , trans = trans , format = format , naValue = naValue ) <EOL> FILL -> scaleFillViridis ( option = option , alpha = null , begin = begin , end = end , direction = direction , name = name , breaks = breaks ? . map { it as Number } , labels = labels , guide = legendType , limits = limits , trans = trans , format = format , naValue = naValue ) <EOL> else -> TODO ( ) <EOL> } <EOL> } <EOL> is ScaleContinuousColorGradient2 < * > -> when ( aes ) { <EOL> COLOR -> scaleColorGradient2 ( low . wrap ( ) , mid . wrap ( ) , high . wrap ( ) , midpoint , name = name , breaks = breaks ? . map { it as Number } , labels = labels , guide = legendType , limits = domainLimits . wrap ( ) , trans = transform ? . name , format = format , naValue = naValue ) <EOL> FILL -> scaleFillGradient2 ( low . wrap ( ) , mid . wrap ( ) , high . wrap ( ) , midpoint , name = name , breaks = breaks ? . map { it as Number } , labels = labels , guide = legendType , limits = domainLimits . wrap ( ) , trans = transform ? . name , format = format , naValue = naValue ) <EOL> else -> TODO ( ) <EOL> } <EOL> is ScaleContinuousColorGradientN < * > -> when ( aes ) { <EOL> COLOR -> scaleColorGradientN ( rangeColors . map { it . wrap ( ) } , name = name , breaks = breaks ? . map { it as Number } , labels = labels , guide = legendType , limits = domainLimits . wrap ( ) , trans = transform ? . name , format = format , naValue = naValue ) <EOL> FILL -> scaleFillGradientN ( rangeColors . map { it . wrap ( ) } , name = name , breaks = breaks ? . map { it as Number } , labels = labels , guide = legendType , limits = domainLimits . wrap ( ) , trans = transform ? . name , format = format , naValue = naValue ) <EOL> else -> TODO ( ) <EOL> } <EOL> else -> TODO ( ) <EOL> } <EOL> else -> TODO ( ) <EOL> } <EOL> } <EOL> else -> TODO ( "<STR_LIT:error>" ) <EOL> } <EOL> }


@ ExperimentalCoroutinesApi <EOL> @ DelicateCoroutinesApi <EOL> public fun newSingleThreadContext ( name : String ) : CloseableCoroutineDispatcher

= <EOL> newFixedThreadPoolContext ( <NUM_LIT:1> , name )

/**
 * Creates a coroutine execution context using a single thread with built-in [yield] support.
 * **NOTE: The resulting [CloseableCoroutineDispatcher] owns native resources (its thread).
 * Resources are reclaimed by [CloseableCoroutineDispatcher.close].**
 *
 * If the resulting dispatcher is [closed][CloseableCoroutineDispatcher.close] and
 * attempt to submit a task is made, then:
 * - On the JVM, the [Job] of the affected task is [cancelled][Job.cancel] and the task is submitted to the
 * [Dispatchers.IO], so that the affected coroutine can clean up its resources and promptly complete.
 * - On Native, the attempt to submit a task throws an exception.
 *
 * This is a **delicate** API. The result of this method is a closeable resource with the
 * associated native resources (threads or native workers). It should not be allocated in place,
 * should be closed at the end of its lifecycle, and has non-trivial memory and CPU footprint.
 * If you do not need a separate thread pool, but only have to limit effective parallelism of the dispatcher,
 * it is recommended to use [CoroutineDispatcher.limitedParallelism] instead.
 *
 * If you need a completely separate thread pool with scheduling policy that is based on the standard
 * JDK executors, use the following expression:
 * `Executors.newSingleThreadExecutor().asCoroutineDispatcher()`.
 * See `Executor.asCoroutineDispatcher` for details.
 *
 * @param name the base name of the created thread.
 */


@ ExperimentalCoroutinesApi <EOL> public expect fun newFixedThreadPoolContext ( nThreads : Int , name : String ) : CloseableCoroutineDispatcher

/**
 * Creates a coroutine execution context with the fixed-size thread-pool and built-in [yield] support.
 * **NOTE: The resulting [CoroutineDispatcher] owns native resources (its threads).
 * Resources are reclaimed by [CloseableCoroutineDispatcher.close].**
 *
 * If the resulting dispatcher is [closed][CloseableCoroutineDispatcher.close] and
 * attempt to submit a continuation task is made,
 * - On the JVM, the [Job] of the affected task is [cancelled][Job.cancel] and the task is submitted to the
 * [Dispatchers.IO], so that the affected coroutine can clean up its resources and promptly complete.
 * - On Native, the attempt to submit a task throws an exception.
 *
 * This is a **delicate** API. The result of this method is a closeable resource with the
 * associated native resources (threads or native workers). It should not be allocated in place,
 * should be closed at the end of its lifecycle, and has non-trivial memory and CPU footprint.
 * If you do not need a separate thread pool, but only have to limit effective parallelism of the dispatcher,
 * it is recommended to use [CoroutineDispatcher.limitedParallelism] instead.
 *
 * If you need a completely separate thread pool with scheduling policy that is based on the standard
 * JDK executors, use the following expression:
 * `Executors.newFixedThreadPool().asCoroutineDispatcher()`.
 * See `Executor.asCoroutineDispatcher` for details.
 *
 * @param nThreads the number of threads.
 * @param name the base name of the created threads.
 */


public operator fun get ( index : Int ) : ULong

= storage [ index ] . toULong ( )

/**
 * Returns the array element at the given [index]. This method can be called using the index operator.
 *
 * If the [index] is out of bounds of this array, throws an [IndexOutOfBoundsException] except in Kotlin/JS
 * where the behavior is unspecified.
 */


public operator fun set ( index : Int , value : ULong )

{ <EOL> storage [ index ] = value . toLong ( ) <EOL> }

/**
 * Sets the element at the given [index] to the given [value]. This method can be called using the index operator.
 *
 * If the [index] is out of bounds of this array, throws an [IndexOutOfBoundsException] except in Kotlin/JS
 * where the behavior is unspecified.
 */


public override operator fun iterator ( ) : kotlin . collections . Iterator < ULong >

= Iterator ( storage )

/** Creates an iterator over the elements of the array. */


@ SinceKotlin ( "<STR_LIT:1.3>" ) <EOL> @ ExperimentalUnsignedTypes <EOL> @ kotlin . internal . InlineOnly <EOL> public inline fun ULongArray ( size : Int , init : ( Int ) -> ULong ) : ULongArray

{ <EOL> return ULongArray ( LongArray ( size ) { index -> init ( index ) . toLong ( ) } ) <EOL> }

/**
 * Creates a new array of the specified [size], where each element is calculated by calling the specified
 * [init] function.
 *
 * The function [init] is called for each array element sequentially starting from the first one.
 * It should return the value for an array element given its index.
 */


public fun < T : Any > contextual ( kClass : KClass < T > , serializer : KSerializer < T > ) : Unit

= <EOL> contextual ( kClass ) { serializer }

/**
 * Accept a serializer, associated with [kClass] for contextual serialization.
 */


public fun < T : Any > contextual ( kClass : KClass < T > , provider : ( typeArgumentsSerializers : List < KSerializer < * > > ) -> KSerializer < * > )

/**
 * Accept a provider, associated with generic [kClass] for contextual serialization.
 */


public fun < Base : Any , Sub : Base > polymorphic ( baseClass : KClass < Base > , actualClass : KClass < Sub > , actualSerializer : KSerializer < Sub > )

/**
 * Accept a serializer, associated with [actualClass] for polymorphic serialization.
 */


public fun < Base : Any > polymorphicDefaultSerializer ( baseClass : KClass < Base > , defaultSerializerProvider : ( value : Base ) -> SerializationStrategy < Base > ? <EOL> )

/**
 * Accept a default serializer provider, associated with the [baseClass] for polymorphic serialization.
 * [defaultSerializerProvider] is invoked when no polymorphic serializers for `value` in the scope of [baseClass] were found.
 *
 * Default serializers provider affects only serialization process. Deserializers are accepted in the
 * [SerializersModuleCollector.polymorphicDefaultDeserializer] method.
 *
 * [defaultSerializerProvider] can be stateful and lookup a serializer for the missing type dynamically.
 */


public fun < Base : Any > polymorphicDefaultDeserializer ( baseClass : KClass < Base > , defaultDeserializerProvider : ( className : String ? ) -> DeserializationStrategy < Base > ? <EOL> )

/**
 * Accept a default deserializer provider, associated with the [baseClass] for polymorphic deserialization.
 * [defaultDeserializerProvider] is invoked when no polymorphic serializers associated with the `className`
 * in the scope of [baseClass] were found. `className` could be `null` for formats that support nullable class discriminators
 * (currently only `Json` with `useArrayPolymorphism` set to `false`).
 *
 * Default deserializers provider affects only deserialization process. Serializers are accepted in the
 * [SerializersModuleCollector.polymorphicDefaultSerializer] method.
 *
 * [defaultDeserializerProvider] can be stateful and lookup a serializer for the missing type dynamically.
 */


@ Deprecated ( "<STR_LIT>" , ReplaceWith ( "<STR_LIT>" ) , DeprecationLevel . WARNING ) <EOL> public fun < Base : Any > polymorphicDefault ( baseClass : KClass < Base > , defaultDeserializerProvider : ( className : String ? ) -> DeserializationStrategy < Base > ? <EOL> )

{ <EOL> polymorphicDefaultDeserializer ( baseClass , defaultDeserializerProvider ) <EOL> }

/**
 * Accept a default deserializer provider, associated with the [baseClass] for polymorphic deserialization.
 *
 * This function affect only deserialization process. To avoid confusion, it was deprecated and replaced with [polymorphicDefaultDeserializer].
 * To affect serialization process, use [SerializersModuleCollector.polymorphicDefaultSerializer].
 *
 * [defaultDeserializerProvider] is invoked when no polymorphic serializers associated with the `className`
 * in the scope of [baseClass] were found. `className` could be `null` for formats that support nullable class discriminators
 * (currently only `Json` with `useArrayPolymorphism` set to `false`).
 *
 * [defaultDeserializerProvider] can be stateful and lookup a serializer for the missing type dynamically.
 *
 * @see SerializersModuleCollector.polymorphicDefaultDeserializer
 * @see SerializersModuleCollector.polymorphicDefaultSerializer
 */


{ <EOL> if ( this is TrainableLayer ) isTrainable = false <EOL> }

/**
 * Freezes layer weights, so they won't be changed during training.
 */


{ <EOL> require ( this is TrainableLayer ) { <EOL> "<STR_LIT>" <EOL> } <EOL> isTrainable = true <EOL> }

/**
 * Unfreezes layer weights, allowing to change them during training.
 */


fun < T > systemProperty ( convert : ( String ) -> T ) : ReadOnlyProperty < Any ? , T >

= <EOL> ReadOnlyProperty { _ , property -> <EOL> val value = requireNotNull ( System . getProperty ( property . name ) ) { <EOL> "<STR_LIT>" <EOL> } <EOL> convert ( value ) <EOL> }

/**
 * Delegated accessor for a system property.
 *
 * @see System.getProperty
 */


private inline fun enqueueResolveForExplicitReceiver ( originalCallInfo : CallInfo , crossinline invokeAction : suspend ( FirTowerResolveTask , CallInfo ) -> Unit )

{ <EOL> val invokeReceiverVariableInfo = originalCallInfo . replaceWithVariableAccess ( ) <EOL> val towerDataElementsForName = TowerDataElementsForName ( invokeReceiverVariableInfo . name , components . towerDataContext ) <EOL> enqueueInvokeReceiverTask ( originalCallInfo , invokeReceiverVariableInfo , towerDataElementsForName = towerDataElementsForName , invokeBuiltinExtensionMode = false ) { <EOL> invokeAction ( it , invokeReceiverVariableInfo ) <EOL> } <EOL> val invokeReceiverVariableWithNoReceiverInfo = invokeReceiverVariableInfo . replaceExplicitReceiver ( null ) <EOL> enqueueInvokeReceiverTask ( originalCallInfo , invokeReceiverVariableWithNoReceiverInfo , towerDataElementsForName = towerDataElementsForName , invokeBuiltinExtensionMode = true ) { <EOL> it . runResolverForNoReceiver ( invokeReceiverVariableWithNoReceiverInfo , skipSynthetics = true ) <EOL> } <EOL> }

/**
 * It's whether Qualifier.f() or expressionReceiver.f(), later we name it as "x.f()"
 *
 * @param originalCallInfo describes whole "x.f()"
 * @param invokeAction runs the process of looking for the receiver "x.f" depending on the kind of "x" (qualifier or expression)
 */


private inline fun enqueueInvokeReceiverTask ( info : CallInfo , invokeReceiverInfo : CallInfo , towerDataElementsForName : TowerDataElementsForName = TowerDataElementsForName ( invokeReceiverInfo . name , components . towerDataContext ) , invokeBuiltinExtensionMode : Boolean , crossinline runResolutionForInvokeReceiverVariable : suspend ( FirTowerResolveTask ) -> Unit )

{ <EOL> val collector = CandidateCollector ( components , components . resolutionStageRunner ) <EOL> val invokeReceiverProcessor = InvokeReceiverResolveTask ( components , manager , towerDataElementsForName , collector , CandidateFactory ( context , invokeReceiverInfo ) , onSuccessfulLevel = { towerGroup -> <EOL> enqueueResolverTasksForInvokeReceiverCandidates ( invokeBuiltinExtensionMode , info , receiverGroup = towerGroup , collector ) <EOL> collector . newDataSet ( ) <EOL> } ) <EOL> manager . enqueueResolverTask { <EOL> runResolutionForInvokeReceiverVariable ( invokeReceiverProcessor ) <EOL> } <EOL> }

/**
 * Let we have a call if a form of "x.f()" or "f()"
 *
 * This method enqueues a task (based on runResolutionForInvokeReceiverVariable) that for each successful property enqueues another task
 * that tries to resolve "f()" call itself
 *
 * @param info describes whole "x.f()" or "f()"
 * @param invokeReceiverInfo describes "x.f" or "f" variable (in case of no-receiver call or in case of resolving invokeExtension with "x")
 * @param invokeBuiltinExtensionMode is true only when the original call has a form "x.f()" and invokeReceiverInfo is "f"
 * @param runResolutionForInvokeReceiverVariable runs the process of looking for the receiver ("x.f" or "f") on the given FirTowerResolveTask
 */


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

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


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

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

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


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

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


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

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


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

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

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


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

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

/**
 * Sidebar for tangentially related content
 */


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

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


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

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


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

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


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

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

/**
 * Text directionality isolation
 */


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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

/**
 * Disclosure control for hiding details
 */


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

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


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

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


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

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

/**
 * Generic language/style container
 */


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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

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


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

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

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


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

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


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

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


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

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


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

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


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

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

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


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

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


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

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


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

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


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

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


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

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

/**
 * Section with navigational links
 */


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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

/**
 * Parenthesis for ruby annotation text
 */


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

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


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

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


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

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


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

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


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

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


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

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


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

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

/**
 * Generic document or application section
 */


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


@ TypeRefinement <EOL> override fun refineType ( type : KotlinTypeMarker ) : KotlinType

{ <EOL> require ( type is KotlinType ) <EOL> if ( type . constructor . declarationDescriptor ? . module == moduleDescriptor ) return type <EOL> return when { <EOL> type . needsRefinementHackForKtij24195 ( ) -> doRefineType ( ( type as AbbreviatedType ) . abbreviation ) <EOL> type . needsRefinement ( ) -> doRefineType ( type ) <EOL> else -> type <EOL> } <EOL> }

/**
 * IMPORTANT: that function has not obvious contract: it refines only supertypes,
 * and don't refines type arguments, so return type is "partly refined".
 *
 * It's fine for subtyping, because we refine type arguments inside type checker when it needs to
 * It's fine for scopes, because we refine type of every expression:
 *
 * // common module
 * expect interface A
 * class Inv<T>(val value: T)
 * fun getA(): Inv<A> = ...
 *
 * // platform module
 *
 * actual interface A {
 * val x: Int
 * }
 *
 * fun foo() {
 * getA().value.x
 * }
 *
 * Let's call type of `actual interface A` A'
 *
 * expression `getA()` has not refined type Inv<A> and same refined type
 * expression `getA().value` has not refined type A that refines into type A', so there is a
 * field `x` in it's member scope
 */


private fun KotlinType . needsRefinementHackForKtij24195 ( ) : Boolean

{ <EOL> if ( this !is AbbreviatedType ) return false <EOL> if ( abbreviation . constructor . declarationDescriptor !is TypeAliasDescriptor ) return false <EOL> val expansionDescriptorClassId = expandedType . constructor . declarationDescriptor . classId ? : return false <EOL> return moduleDescriptor . findClassifierAcrossModuleDependencies ( expansionDescriptorClassId ) == null <EOL> }

/**
 * This is a hack for https://youtrack.jetbrains.com/issue/KTIJ-24195
 *
 * The rough idea is that if:
 * - we see a typealias pointing to a classifier
 * - ideally, we'd consider only `actual typealias`es, but we don't write `actual`-flag in metadata :(
 * - and that classifier isn't visible from our module
 * - then we should re-refine the abbreviation
 *
 * Read KTIJ-24195 comments for detailed explanation and reasoning why this hack is sufficient.
 *
 * Performance note: this hack amounts to running an additional `findClassAcrossModuleDependencies` on all `typealias`
 * abbreviations. In most cases, the resolution of abbreviation should've happened before, so this call will just hit the cache.
 * It is possible to construct a case where this call will actually have to do some non-trivial work, but:
 * a) it's quite hard to write such case even knowing how our caches work, so the probability of a real-life user' code hitting that
 * case is minuscule
 * b) even if we somehow manage to hit that case in real code, this is just one more `getContributedClassifier` per used
 * `typealias`, as all subsequent calls will be cached.
 */


fun createStandaloneInstanceFor ( moduleDescriptor : ModuleDescriptor ) : KotlinTypeRefinerImpl

= <EOL> KotlinTypeRefinerImpl ( moduleDescriptor , LockBasedStorageManager . NO_LOCKS , isStandalone = true )

/**
 * Create a new *thread unsafe* type refiner instance for the specified module.
 * Note, that module's type refiner capability won't be changed.
 */


@ Test <EOL> fun failWithModulesNotInAnyScope ( )

{ <EOL> val json = Json { serializersModule = BaseAndDerivedModule } <EOL> checkNotRegisteredMessage ( assertFailsWith < SerializationException > { <EOL> json . encodeToString ( MyPolyData . serializer ( ) , MyPolyData ( mapOf ( "<STR_LIT:a>" to PolyDerived ( "<STR_LIT:foo>" ) ) ) ) <EOL> } ) <EOL> }

/**
 * This test should fail because PolyDerived registered in the scope of PolyBase, not kotlin.Any
 */


@ Test <EOL> fun failWithModulesNotInParticularScope ( )

{ <EOL> val json = Json { serializersModule = baseAndDerivedModuleAtAny } <EOL> checkNotRegisteredMessage ( assertFailsWith < SerializationException > { <EOL> json . encodeToString ( MyPolyDataWithPolyBase . serializer ( ) , MyPolyDataWithPolyBase ( mapOf ( "<STR_LIT:a>" to PolyDerived ( "<STR_LIT:foo>" ) ) , PolyDerived ( "<STR_LIT:foo>" ) ) ) <EOL> } ) <EOL> }

/**
 * This test should fail because PolyDerived registered in the scope of kotlin.Any, not PolyBase
 */


public fun load ( pathToModel : String ) : SavedModel

{ <EOL> return SavedModel ( SavedModelBundle . load ( pathToModel , "<STR_LIT>" ) ) <EOL> }

/**
 * Loads model from SavedModelBundle format.
 */


{ <EOL> val modelHub = ONNXModelHub ( cacheDirectory = File ( "<STR_LIT>" ) ) <EOL> val modelType = ONNXModels . PoseDetection . MoveNetMultiPoseLighting <EOL> val model = modelHub . loadModel ( modelType , CPU ( ) ) <EOL> val inputData = prepareInputData ( modelType ) <EOL> val cpuInferenceTime = cpuInference ( model , inputData ) <EOL> println ( "<STR_LIT>" ) <EOL> val cudaInferenceTime = cudaInference ( model , inputData ) <EOL> println ( "<STR_LIT>" ) <EOL> model . close ( ) <EOL> }

/**
 * This example compares the inference speed of different execution providers:
 * - [inferUsing] scope function is used for CUDA inference. That's why the underlying session should be closed manually.
 */


@ Deprecated ( message = "<STR_LIT>" , replaceWith = ReplaceWith ( "<STR_LIT>" , "<STR_LIT>" ) , level = DeprecationLevel . WARNING ) <EOL> internal fun Project . setupNativeCompiler ( konanTarget : KonanTarget )

{ <EOL> val isKonanHomeOverridden = kotlinPropertiesProvider . nativeHome != null <EOL> if ( ! isKonanHomeOverridden ) { <EOL> val downloader = NativeCompilerDownloader ( this ) <EOL> if ( kotlinPropertiesProvider . nativeReinstall ) { <EOL> logger . info ( "<STR_LIT>" ) <EOL> downloader . compilerDirectory . deleteRecursively ( ) <EOL> } <EOL> downloader . downloadIfNeeded ( ) <EOL> logger . info ( "<STR_LIT>" ) <EOL> } else { <EOL> logger . info ( "<STR_LIT>" ) <EOL> } <EOL> val distributionType = NativeDistributionTypeProvider ( project ) . getDistributionType ( ) <EOL> if ( distributionType . mustGeneratePlatformLibs ) { <EOL> PlatformLibrariesGenerator ( project , konanTarget ) . generatePlatformLibsIfNeeded ( ) <EOL> } <EOL> }

/**
 * Sets up the Kotlin/Native compiler for the given project.
 *
 * @param konanTarget The target platform for the Kotlin/Native compiler.
 */


public inline fun < R > analyze ( useSiteKtElement : KtElement , action : KtAnalysisSession . ( ) -> R ) : R

= <EOL> KtAnalysisSessionProvider . getInstance ( useSiteKtElement . project ) <EOL> . analyse ( useSiteKtElement , action )

/**
 * Executes the given [action] in a [KtAnalysisSession] context.
 *
 * The project will be analyzed from the perspective of [useSiteKtElement]'s module, also called the use-site module.
 *
 * @see KtAnalysisSession
 */


public inline fun < R > analyze ( useSiteKtModule : KtModule , crossinline action : KtAnalysisSession . ( ) -> R ) : R

{ <EOL> val sessionProvider = KtAnalysisSessionProvider . getInstance ( useSiteKtModule . project ) <EOL> return sessionProvider . analyze ( useSiteKtModule , action ) <EOL> }

/**
 * Executes the given [action] in a [KtAnalysisSession] context.
 *
 * The project will be analyzed from the perspective of the given [useSiteKtModule].
 *
 * @see KtAnalysisSession
 * @see KtLifetimeTokenFactory
 */


@ OptIn ( KtModuleStructureInternals :: class ) <EOL> public inline fun < R > analyzeCopy ( useSiteKtElement : KtElement , resolutionMode : DanglingFileResolutionMode , crossinline action : KtAnalysisSession . ( ) -> R , ) : R

{ <EOL> val containingFile = useSiteKtElement . containingKtFile <EOL> return withDanglingFileResolutionMode ( containingFile , resolutionMode ) { <EOL> analyze ( containingFile , action ) <EOL> } <EOL> }

/**
 * Executes the given [action] in a [KtAnalysisSession] context.
 * Depending on the passed [resolutionMode], declarations inside a file copy will be treated in a specific way.
 *
 * Note that the [useSiteKtElement] must be inside a dangling file copy.
 * Specifically, [PsiFile.getOriginalFile] must point to the copy source.
 *
 * The project will be analyzed from the perspective of [useSiteKtElement]'s module, also called the use-site module.
 */


@ Suppress ( "<STR_LIT:UNCHECKED_CAST>" ) <EOL> public fun < C > ColumnSet < C > . last ( condition : ColumnFilter < C > = { true } ) : TransformableSingleColumn < C >

= <EOL> ( allColumnsInternal ( ) as TransformableColumnSet < C > ) <EOL> . transform { listOf ( it . last ( condition ) ) } <EOL> . singleOrNullWithTransformerImpl ( )

/**
 * @include [CommonLastDocs]
 * @set [CommonLastDocs.Examples]
 * `df.`[select][DataFrame.select]` { `[colsOf][SingleColumn.colsOf]`<`[String][String]`>().`[last][ColumnSet.last]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
 *
 * `df.`[select][DataFrame.select]` { `[colsOf][SingleColumn.colsOf]`<`[Int][Int]`>().`[last][ColumnSet.last]`() }`
 */


public fun ColumnsSelectionDsl < * > . last ( condition : ColumnFilter < * > = { true } ) : TransformableSingleColumn < * >

= <EOL> asSingleColumn ( ) . lastCol ( condition )

/**
 * @include [CommonLastDocs]
 * @set [CommonLastDocs.Examples]
 *
 * `df.`[select][DataFrame.select]` { `[last][ColumnsSelectionDsl.last]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
 */


public fun SingleColumn < DataRow < * > > . lastCol ( condition : ColumnFilter < * > = { true } ) : TransformableSingleColumn < * >

= <EOL> this . ensureIsColumnGroup ( ) . asColumnSet ( ) . last ( condition )

/**
 * @include [CommonLastDocs]
 * @set [CommonLastDocs.Examples]
 *
 * `df.`[select][DataFrame.select]` { myColumnGroup.`[lastCol][SingleColumn.lastCol]`() }`
 */


public fun String . lastCol ( condition : ColumnFilter < * > = { true } ) : TransformableSingleColumn < * >

= <EOL> columnGroup ( this ) . lastCol ( condition )

/**
 * @include [CommonLastDocs]
 * @set [CommonLastDocs.Examples]
 * `df.`[select][DataFrame.select]` { "myColumnGroup".`[lastCol][String.lastCol]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
 */


public fun KProperty < * > . lastCol ( condition : ColumnFilter < * > = { true } ) : TransformableSingleColumn < * >

/**
 * @include [CommonLastDocs]
 * @set [CommonLastDocs.Examples]
 * `df.`[select][DataFrame.select]` { Type::myColumnGroup.`[lastCol][SingleColumn.lastCol]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
 *
 * `df.`[select][DataFrame.select]` { DataSchemaType::myColumnGroup.`[lastCol][KProperty.lastCol]`() }`
 */


public fun ColumnPath . lastCol ( condition : ColumnFilter < * > = { true } ) : TransformableSingleColumn < * >

/**
 * @include [CommonLastDocs]
 * @set [CommonLastDocs.Examples]
 * `df.`[select][DataFrame.select]` { "pathTo"["myColumnGroup"].`[lastCol][ColumnPath.lastCol]` { it.`[name][ColumnReference.name]`().`[startsWith][String.startsWith]`("year") } }`
 */


fun ChangesCollector . getChangedSymbols ( reporter : ICReporter ) : DirtyData

{ <EOL> return changes ( ) . getChangedAndImpactedSymbols ( caches = emptyList ( ) , reporter ) <EOL> }

/**
 * Returns changed symbols from the changes collected by this [ChangesCollector].
 *
 * If impacted symbols are also needed, use [getChangedAndImpactedSymbols].
 */


fun ChangesCollector . getChangedAndImpactedSymbols ( caches : Iterable < IncrementalCacheCommon > , reporter : ICReporter ) : DirtyData

{ <EOL> return changes ( ) . getChangedAndImpactedSymbols ( caches , reporter ) <EOL> }

/**
 * Returns changed and impacted symbols from the changes collected by this [ChangesCollector].
 *
 * For example, if `Subclass` extends `Superclass` and `Superclass` has changed, `Subclass` will be impacted.
 */