* If some of them are not, it logs a problem.
 *
 * The lambda is encoded straightforwardly as a bean, and, upon decoding, the bean is expected to be the [SerializedLambda].
 * Beside the compliance checks, the values are encoded or decoded as beans without any special handling.
 *
 * @see [org.gradle.internal.serialize.beans.services.unsupportedFieldDeclaredTypes]
 */

    val id = readSmallInt()
    val previousValue = identities.getInstance(id)
    return when {
        previousValue != null -> previousValue.uncheckedCast()
        else -> {
            decode(id).also {
                require(identities.getInstance(id) === it) {
                    "`decode(id)` should register the decoded instance"
                }

		usage()
	}
	if len(ar.files) > 0 {
		log.Fatalf("file %q not in archive", ar.files[0])
	}
}

// The unusual ancestry means the arguments are not Go-standard.
// These variables hold the decoded operation specified by the first argument.
// op holds the operation we are doing (prtx).
// verbose tells whether the 'v' option was specified.
var (
	op      rune
	verbose bool
)

    SingletonCodec(value)


fun <T> codec(
    encode: suspend WriteContext.(T) -> Unit,
    decode: suspend ReadContext.() -> T?
): Codec<T> = object : Codec<T> {
    override suspend fun WriteContext.encode(value: T) = encode(value)
    override suspend fun ReadContext.decode(): T? = decode()
}


inline fun <reified T> IsolateContext.ownerService() =
    ownerService(T::class.java)

    codec: Codec<Any?>,

    private
    val decoder: Decoder,

    private
    val beanStateReaderLookup: BeanStateReaderLookup,

    override val logger: Logger,

    problemsListener: ProblemsListener,

    private
    val classDecoder: ClassDecoder

) : AbstractIsolateContext<ReadIsolate>(codec, problemsListener), ReadContext, Decoder by decoder, AutoCloseable {

import org.gradle.internal.serialize.graph.writeCollection


/**
 * Decodes HashSet instances as LinkedHashSet to preserve original iteration order.
 */
object HashSetCodec : Codec<HashSet<Any?>> {

    override suspend fun WriteContext.encode(value: HashSet<Any?>) {
        writeCollectionCheckingForCircularElements(value)
    }

    override suspend fun ReadContext.decode(): HashSet<Any?> =

            val project = value.owningProject ?: throw UnsupportedOperationException("TransformStep must have an owning project to be encoded.")
            writeString(project.path)
            write(value.transform)
        }
    }

    override suspend fun ReadContext.decode(): TransformStep {
        return decodePreservingSharedIdentity {
            val path = readString()

}

func (m methodref) isExported() bool {
	for _, r := range m.m.name {
		return unicode.IsUpper(r)
	}
	panic("methodref has no signature")
}

// decodeMethodSig decodes an array of method signature information.
// Each element of the array is size bytes. The first 4 bytes is a
// nameOff for the method name, and the next 4 bytes is a typeOff for
// the function type.
//

 *  <p>Codecs may be implemented:
 *  <ul>
 *  <li>as a custom class that implements both encoding and decoding protocols in the same class
 *  <li>based on the combination of arbitrary encoder and decoder functions, as done via {@link org.gradle.internal.serialize.graph.CombinatorsKt#codec(kotlin.jvm.functions.Function3, kotlin.jvm.functions.Function2) codec(...)}

                HashCode classLoaderHash = hashCodeSerializer.read(decoder);
                String functionalInterfaceClass = decoder.readString();
                String implClass = decoder.readString();
                String implMethodName = decoder.readString();
                String implMethodSignature = decoder.readString();