return "$first to $second"
    }

    override fun convertType(type: KType): KType {
        val first = type.arguments.getOrNull(0)?.type ?: return type
        val second = type.arguments.getOrNull(1)?.type ?: return type
        return Pair::class.createType(
            arguments = listOf(
                KTypeProjection(
                    variance = KVariance.INVARIANT,

 */
class MediaType internal constructor(
  internal val mediaType: String,
  /**
   * Returns the high-level media type, such as "text", "image", "audio", "video", or "application".
   */
  @get:JvmName("type") val type: String,
  /**
   * Returns a specific media subtype, such as "plain" or "png", "mpeg", "mp4" or "xml".
   */
  @get:JvmName("subtype") val subtype: String,

                }
            }
            types.forEach(::visit)
        }

        return PreIndex().apply {
            allTypesToVisit.forEach { type ->
                addType(type)
                val properties = propertyExtractor.extractProperties(type)
                properties.forEach {
                    it.claimedFunctions.forEach { claimFunction(type, it) }
                    addProperty(

   * ```
   */
  fun frameLog(
    inbound: Boolean,
    streamId: Int,
    length: Int,
    type: Int,
    flags: Int,
  ): String {
    val formattedType = formattedType(type)
    val formattedFlags = formatFlags(type, flags)
    val direction = if (inbound) "<<" else ">>"
    return format(
      "%s 0x%08x %5d %-13s %s",
      direction,
      streamId,
      length,

  auto encoding = mlir::dyn_cast_or_null<mlir::mhlo::TypeExtensionsAttr>(
      type.getEncoding());
  return (encoding && !encoding.getBounds().empty());
}

bool HasStaticShapeOrBounded(Value val) {
  auto type = val.getType();
  if (mlir::isa<UnrankedTensorType>(type)) {
    return false;
  }
  if (mlir::isa<RankedTensorType>(type)) {
    auto ranked_tensor = mlir::dyn_cast<RankedTensorType>(type);

    fun bind(type: Class<*>, codec: Codec<*>) {
        require(bindings.all { it.encodingForType(type) == null }) {
            "There's already an encoding for type '$type'"
        }
        val codecForAny = codec.uncheckedCast<Codec<Any>>()
        val encodingProducer = producerForSubtypesOf(type, codecForAny)
        bind(encodingProducer, codecForAny)
    }

           the TF attribute, and the other for the type and value of the
           attribute value. Attribute value is a string with the format of
           "type$val", where type can be "bool", "string", "tfdtype", "tfshape",
           "tftensor".
           The value serialization format can be found in attr_util.h.

      %out_c, %out_tensor = "tfd.delegate_kernel"(

  var index = 0
  val result = mutableListOf<Mapping>()

  while (index < mappings.size) {
    val mapping = mappings[index]
    val type = canonicalizeType(mapping.type)
    val mappedTo = mapping.mappedTo

    var unionWith: Mapping = mapping
    index++

    while (index < mappings.size) {
      val next = mappings[index]

    }


private
fun KType.hasCompatibleTypeArguments(api: KType) =
    arguments.size == api.arguments.size && arguments.indices.all { idx ->
        val expectedType = arguments[idx].type
        val actualType = api.arguments[idx].type
        expectedType?.let { e ->
            actualType?.let { a -> e.isTypeArgumentCompatibleWith(a) }
        } ?: false
    }


private

func (s S) val() int   { return 1 }
func (s *S1) val() int { return 2 }
func (i I) val() int   { return 3 }
func (i *I1) val() int { return 4 }
func (t T) val() int   { return 7 }
func (t *T1) val() int { return 8 }

type Val interface {
	val() int
}

func val(v Val) int { return v.val() }

func main() {
	var s S
	var ps *S1
	var i I
	var pi *I1
	var pt *T1
	var t T
	var v Val

	if s.val() != 1 {