// For parity with JSON, strings can be decoded into time.Time if they are RFC 3339
		// timestamps.
		ByteStringToTime: cbor.ByteStringToTimeAllowed,
	}.DecMode()
	if err != nil {
		panic(err)
	}
	return decode
}()

// DecodeLax is derived from Decode, but does not complain about unknown fields in the input.
var DecodeLax cbor.DecMode = func() cbor.DecMode {
	opts := Decode.DecOptions()

 * Beside the compliance checks, the values are encoded or decoded as beans without any special handling.
 *
 * @see [org.gradle.internal.serialize.beans.services.unsupportedFieldDeclaredTypes]
 */
object SerializedLambdaParametersCheckingCodec : Codec<SerializedLambda> {
    override suspend fun ReadContext.decode(): SerializedLambda {
        return decodeBean() as SerializedLambda
    }

 *  <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(...)}

        KryoBackedDecoder decoder = new KryoBackedDecoder(new EncodedStream.EncodedInput(System.in));
        try {
            gradleHomeDir = new File(decoder.readString());
            daemonBaseDir = new File(decoder.readString());
            idleTimeoutMs = decoder.readSmallInt();
            periodicCheckIntervalMs = decoder.readSmallInt();
            singleUse = decoder.readBoolean();

        context.runWriteOperation {
            write(value)
        }
    }

    private
    fun read(decoder: Decoder): BuildTreeModelSideEffect {
        val (context, codecs) = cacheIO.readerContextFor(decoder)
        context.push(IsolateOwners.OwnerHost(host), codecs.userTypesCodec())
        return context.runReadOperation {
            readNonNull()
        }
    }

        context.runWriteOperation {
            write(value)
        }
    }

    override fun read(decoder: Decoder): IntermediateModel {
        val (context, codecs) = cacheIO.readerContextFor(decoder)
        context.push(IsolateOwners.OwnerHost(host), codecs.userTypesCodec())
        return context.runReadOperation {
            readNonNull()
        }
    }

        writeFile(it.first)
        writeFile(it.second)
    }
}


internal
fun Decoder.readClassPath(): ClassPath {
    val isTransformed = readBoolean()
    return if (isTransformed) {
        readTransformedClassPath()
    } else {
        readDefaultClassPath()
    }
}


internal
fun Decoder.readDefaultClassPath(): ClassPath {
    val size = readSmallInt()

    )

    private
    fun readContextFor(
        decoder: Decoder,
        codecs: Codecs
    ) = readContextFor(decoder, codecs.userTypesCodec())

    private
    fun readContextFor(
        decoder: Decoder,
        codec: Codec<Any?>
    ) = DefaultReadContext(
        codec,
        decoder,
        beanStateReaderLookup,
        logger,
        problems,

                ValueSupplier.ExecutionTimeValue.ofNullable(value).withSideEffect(sideEffect)
            }

            4.toByte() -> ValueSupplier.ExecutionTimeValue.changingValue<Any>(providerWithChangingValueCodec.run { decode() }!!.uncheckedCast())
            else -> throw IllegalStateException("Unexpected provider value")
        }
}


class FlowProvidersCodec(
    private val flowProviders: FlowProviders

    private
    val valuesStore by lazy {
        val writer = ValueStore.Writer<V> { encoder, value ->
            write(encoder, value)
        }
        val reader = ValueStore.Reader { decoder ->
            read(decoder)
        }
        store.createValueStore(stateType, writer, reader)
    }

    private
    val previousValues = ConcurrentHashMap<K, BlockAddress>()

    private