type.isUInt -> KaConstantValue.KaUnsignedIntConstantValue((value as Number).toInt().toUInt(), expression)
            type.isLong -> KaConstantValue.KaLongConstantValue((value as Number).toLong(), expression)
            type.isULong -> KaConstantValue.KaUnsignedLongConstantValue((value as Number).toLong().toULong(), expression)
            type.isString -> KaConstantValue.KaStringConstantValue(value.toString(), expression)

                isInt || isLong || isShort || isByte -> "0"
                isFloat -> "0.0f"
                isDouble -> "0.0"
                isChar -> "'\\u0000'"
                isBoolean -> "false"
                isUnit -> "Unit"
                isString -> "\"\""
                isUInt -> "0.toUInt()"
                isULong -> "0.toULong()"
                isUShort -> "0.toUShort()"

                return "System.getProperty(\"$name\", \"$defaultValue\")?.toLong()"
            }
        }
    }

    static SystemPropertyRead longGetLongWithLongDefault(String name, long defaultValue) {
        return new SystemPropertyRead() {
            @Override
            String getJavaExpression() {
                return "Long.getLong(\"$name\", Long.valueOf($defaultValue))"
            }

            @Override

                val long = value as Long
                if (Int.MIN_VALUE < long && long < Int.MAX_VALUE) KaConstantValue.KaIntConstantValue(long.toInt(), psi)
                else KaConstantValue.KaLongConstantValue(long, psi)
            }

            ConstantValueKind.UnsignedIntegerLiteral -> {
                val long = value as ULong

        // on Java 8
        writeLong(value.seconds)
        writeSmallInt(value.nano)
    }

    override suspend fun ReadContext.decode(): Duration =
        Duration.ofSeconds(readLong(), readSmallInt().toLong())

    else -> -1
  }

internal infix fun Byte.and(mask: Int): Int = toInt() and mask

internal infix fun Short.and(mask: Int): Int = toInt() and mask

internal infix fun Int.and(mask: Long): Long = toLong() and mask

@Throws(IOException::class)
internal fun BufferedSink.writeMedium(medium: Int) {
  writeByte(medium.ushr(16) and 0xff)
  writeByte(medium.ushr(8) and 0xff)
  writeByte(medium and 0xff)
}

        }

        override fun getOutputStream(requestor: Any?, newModificationStamp: Long, newTimeStamp: Long): OutputStream {
            error("Not yet implemented")
        }

        override fun contentsToByteArray(): ByteArray = ktFile.text.toByteArray()

        override fun getLength(): Long = ktFile.textLength.toLong()

        private val timeStamp = LocalDateTime.now().toEpochSecond(ZoneOffset.UTC)

    override fun skip(n: Long): Long = inputStream.skip(n)

    override fun registerValidation(obj: ObjectInputValidation?, prio: Int) = Unit

    override fun close() = Unit

    override fun available(): Int = inputStream.available()

    override fun skipBytes(len: Int): Int = inputStream.skip(len.toLong()).toInt()

    return tpu_status.getValue();
  }
  auto device_type = op->getAttrOfType<StringAttr>(TF::kCompileDeviceTypeAttr);
  if (!device_type || device_type.getValue() != TF::kTpuDevice) {
    // Op does not belong to a TPU cluster.
    return std::nullopt;
  }
  // Op belongs to a TPU cluster.
  if (auto replication_info =
          op->getAttrOfType<StringAttr>(TF::kReplicationInfoAttr)) {

	Transport TransportConfig

	Codec runtime.Codec
	// EncodeVersioner is the same groupVersioner used to build the
	// storage encoder. Given a list of kinds the input object might belong
	// to, the EncodeVersioner outputs the gvk the object will be
	// converted to before persisted in etcd.
	EncodeVersioner runtime.GroupVersioner
	// Transformer allows the value to be transformed prior to persisting into etcd.