isBoolean -> "false"
                isUnit -> "Unit"
                isString -> "\"\""
                isUInt -> "0.toUInt()"
                isULong -> "0.toULong()"
                isUShort -> "0.toUShort()"
                isUByte -> "0.toUByte()"
                else -> null
            }
        }
}

public typealias KtTypeInfoProviderMixIn = KaTypeInfoProviderMixIn

            type.isShort -> KaConstantValue.KaShortConstantValue((value as Number).toShort(), expression)
            type.isUShort -> KaConstantValue.KaUnsignedShortConstantValue((value as Number).toShort().toUShort(), expression)
            type.isInt -> KaConstantValue.KaIntConstantValue((value as Number).toInt(), expression)

            ConstantValueKind.Long -> (value as Number).toLong()
            ConstantValueKind.Short -> (value as Number).toShort()
            ConstantValueKind.UnsignedByte -> (value as Number).toLong().toUByte()
            ConstantValueKind.UnsignedShort -> (value as Number).toLong().toUShort()
            ConstantValueKind.UnsignedInt -> (value as Number).toLong().toUInt()

        is UByte -> KaConstantValue.KaUnsignedByteConstantValue(value, expression)
        is Short -> KaConstantValue.KaShortConstantValue(value, expression)
        is UShort -> KaConstantValue.KaUnsignedShortConstantValue(value, expression)
        is Int -> KaConstantValue.KaIntConstantValue(value, expression)
        is UInt -> KaConstantValue.KaUnsignedIntConstantValue(value, expression)

        writeInt(`val`)
    }

    override fun writeBoolean(`val`: Boolean) = record {
        writeBoolean(`val`)
    }

    override fun writeShort(`val`: Int) = record {
        this.writeShort(`val`.toShort())
    }

    override fun writeLong(`val`: Long) = record {
        writeLong(`val`)
    }

    override fun writeFloat(`val`: Float) = record {
        this.writeFloat(`val`)
    }

    ) : KaConstantValue(ConstantValueKind.Short) {
        override fun renderAsKotlinConstant(): String = value.toString()
    }

    public class KaUnsignedShortConstantValue(
        override val value: UShort,
        override val sourcePsi: KtElement?
    ) : KaConstantValue(ConstantValueKind.UnsignedShort) {
        override fun renderAsKotlinConstant(): String = "${value}u"
    }

    public class KaIntConstantValue(

        is ULongValue -> KaConstantValue.KaUnsignedLongConstantValue(value.toULong(), sourcePsi = null)
        is UShortValue -> KaConstantValue.KaUnsignedShortConstantValue(value.toUShort(), sourcePsi = null)
        else -> error("Unexpected constant value $value")
    }
}

internal tailrec fun KotlinBuiltIns.areSameArrayTypeIgnoringProjections(left: KotlinType, right: KotlinType): Boolean {

            is Visibility -> printer.append(value::class.java.simpleName)
            // Unsigned integers
            is UByte -> printer.append(value.toString())
            is UShort -> printer.append(value.toString())
            is UInt -> printer.append(value.toString())
            is ULong -> printer.append(value.toString())
            // Java values

// could be added to the list in the future.
enum DimensionType : byte {
  DENSE = 0,
  SPARSE_CSR = 1,
}

table Int32Vector {
  values:[int];
}

table Uint16Vector {
  values:[ushort] (force_align: 4);
}

table Uint8Vector {
  values:[ubyte] (force_align: 4);
}

// Variable-typed buffer to store the index metadata for a sparse dimension.

var dwarfToName = map[string]string{
	"long int":               "long",
	"long unsigned int":      "ulong",
	"unsigned int":           "uint",
	"short unsigned int":     "ushort",
	"unsigned short":         "ushort", // Used by Clang; issue 13129.
	"short int":              "short",
	"long long int":          "longlong",
	"long long unsigned int": "ulonglong",
	"signed char":            "schar",