val smartCastInfo = expression.getSmartCastInfo()
                buildString {
                    appendLine("expression: ${expression.text}")
                    appendLine("isStable: ${smartCastInfo?.isStable}")
                    appendLine("smartCastType: ${smartCastInfo?.smartCastType?.render(position = Variance.INVARIANT)}")

                    val receiverSmartCasts = expression.getImplicitReceiverSmartCast()

import org.jetbrains.kotlin.analysis.project.structure.KtModule
import org.jetbrains.kotlin.analysis.project.structure.ProjectStructureProvider
import org.jetbrains.kotlin.analysis.project.structure.isStable
import org.jetbrains.kotlin.analysis.api.platform.lifetime.KotlinReadActionConfinementLifetimeToken
import org.jetbrains.kotlin.psi.KtElement
import java.util.concurrent.ConcurrentMap
import kotlin.reflect.KClass

/**

public class KaSmartCastInfo(
    private val backingSmartCastType: KaType,
    private val backingIsStable: Boolean,
    override val token: KaLifetimeToken
) : KaLifetimeOwner {
    public val isStable: Boolean get() = withValidityAssertion { backingIsStable }
    public val smartCastType: KaType get() = withValidityAssertion { backingSmartCastType }

    override fun equals(other: Any?): Boolean {

        val type = expression.smartcastType.coneTypeSafe<ConeKotlinType>()?.asKtType() ?: return null
        return KaSmartCastInfo(type, expression.isStable, token)
    }

    private val KtExpression.isImplicitSmartCastInfoTarget: Boolean
        get() = this is KtNameReferenceExpression || this is KtOperationReferenceExpression

    attributes.emplace_back(builder.getNamedAttr(
        "dimension", BuildVhloIntV1Attr(op->dimension, builder)));
    attributes.emplace_back(builder.getNamedAttr(
        "is_stable",
        mlir::vhlo::BooleanV1Attr::get(builder.getContext(), op->is_stable)));
    return;
  }
  if (const auto* op = op_union.AsStablehloScatterOptions()) {
    attributes.emplace_back(builder.getNamedAttr(
        "update_window_dims",

//CHECK-NEXT: return %0 : tensor<1x1x64xf32>
//CHECK-NEXT:}

func.func @sort(%arg0: tensor<448xf32>, %arg1: tensor<448xi32>) -> tensor<448xf32> {
  %0, %1 = "vhlo.sort_v1"(%arg0, %arg1) <{dimension = #vhlo.integer_v1<0 : i64>, is_stable = #vhlo.bool_v1<true>}> ({
    ^bb0(%arg23: tensor<f32>, %arg24: tensor<f32>, %arg25: tensor<i32>, %arg26: tensor<i32>):

            !resolvedType.isNullableType()
        }

        when (val fir = expression.getOrBuildFir(analysisSession.firResolveSession)) {
            is FirSmartCastExpression -> if (fir.isStable) {
                if (fir.smartcastTypeWithoutNullableNothing != null) {
                    return DefiniteNullability.DEFINITELY_NULL
                } else if (fir.isNotNullable()) {

  body_subgraph_index : int;
}

table StablehloWhileOptions{
  cond_subgraph_index : int;
  body_subgraph_index : int;
}

table StablehloSortOptions{
  dimension : long;
  is_stable : bool;
  comparator_subgraph_index : int;
}

table StablehloConcatenateOptions {
  dimension : long;
}

table StablehloBroadcastInDimOptions{
  broadcast_dimensions : [long];
}

        return when {
            this is FirSmartCastExpression -> {
                val result = originalExpression.toKtReceiverValue()
                if (result != null && isStable) {
                    KaSmartCastedReceiverValue(result, smartcastType.coneType.asKtType())
                } else {
                    result
                }
            }

  // CHECK: [[RNG:%.*]] = "mhlo.rng"([[LOWER]], [[UPPER]], [[SHAPE]]) <{rng_distribution = #mhlo.rng_distribution<UNIFORM>}>
  // CHECK: [[SORT:%.*]]:2 = "mhlo.sort"([[RNG]], [[INPUT]]) <{dimension = -1 : i64, is_stable = {{.*}}}> ({
  // CHECK: ^{{.*}}([[ARG1:%.*]]: tensor<i32>, [[ARG2:%.*]]: tensor<i32>, {{.*}}: tensor<f32>, {{.*}}: tensor<f32>):
  // CHECK:   mhlo.compare LT, [[ARG1]], [[ARG2]], TOTALORDER