throw maybeEndOfStream(e);
        }
    }

    @Override
    public String readString() throws EOFException {
        return readNullableString();
    }

    @Override
    public String readNullableString() throws EOFException {
        try {
            return input.readString();
        } catch (KryoException e) {
            throw maybeEndOfStream(e);
        }
    }

        writeString((value.inputProperties as URI).toASCIIString())
    }

    override suspend fun ReadContext.decode(): ApiTextResourceAdapter =
        textResourceFactory.fromInsecureUri(readString()) as ApiTextResourceAdapter

    private
    val ReadContext.textResourceFactory: TextResourceFactory
        get() = ownerService<FileOperations>().resources.text

        value.run {
            writeString(taskPath)
            write(targetBuild)
        }
    }

    override suspend fun ReadContext.decode(): TaskInAnotherBuild {
        val taskPath = readString()
        val targetBuild = readNonNull<BuildIdentifier>()
        return TaskInAnotherBuild.lazy(
            taskPath,
            targetBuild,
            includedTaskGraph
        )
    }

    override suspend fun WriteContext.encode(value: StringValueSnapshot) {
        writeString(value.value)
    }

    override suspend fun ReadContext.decode(): StringValueSnapshot {
        val value = readString()
        return StringValueSnapshot(value)
    }
}


object IntegerValueSnapshotCodec : Codec<IntegerValueSnapshot> {
    override suspend fun WriteContext.encode(value: IntegerValueSnapshot) {

            write(value.transform)
        }
    }

    override suspend fun ReadContext.decode(): TransformStep {
        return decodePreservingSharedIdentity {
            val path = readString()
            val transform = readNonNull<Transform>()
            val project = getProject(path)
            val services = project.services
            TransformStep(
                transform,

import (
	"github.com/tinylib/msgp/msgp"
)

// DecodeMsg implements msgp.Decodable
func (z *StatusType) DecodeMsg(dc *msgp.Reader) (err error) {
	{
		var zb0001 string
		zb0001, err = dc.ReadString()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		(*z) = StatusType(zb0001)
	}
	return
}

// EncodeMsg implements msgp.Encodable

			readPtr = func(b []byte) uint64 { return uint64(bo.Uint32(b)) }
		} else if ptrSize == 8 {
			readPtr = bo.Uint64
		} else {
			return "", "", errNotGoExe
		}
		vers = readString(x, ptrSize, readPtr, readPtr(data[16:]))
		mod = readString(x, ptrSize, readPtr, readPtr(data[16+ptrSize:]))
	}
	if vers == "" {
		return "", "", errNotGoExe
	}
	if len(mod) >= 33 && mod[len(mod)-17] == '\n' {

    }

    private
    suspend fun ReadContext.readConfiguration(componentId: ComponentIdentifier, factory: CalculatedValueContainerFactory): LocalConfigurationGraphResolveMetadata {
        val configurationName = readString()
        val configurationAttributes = readNonNull<ImmutableAttributes>()
        val dependencies = readDependencies()
        val variants = readVariants(factory).toSet()

                else -> throw IllegalStateException("$clazz instances is not expected to be stored")
            }
        }

        val removals = readList {
            val key = readString()
            ConfigurationCacheEnvironmentChangeTracker.SystemPropertyRemove(key)
        }

        return ConfigurationCacheEnvironmentChangeTracker.CachedEnvironmentState(cleared, updates, removals)
    }

        ReferenceType.SELF_REF ->
            isolate.owner.delegate as Task

        ReferenceType.TASK_REF -> {
            val taskName = readString()
            isolate.owner.service(TaskContainerInternal::class.java).resolveTask(taskName)
        }

        ReferenceType.PROHIBITED -> {
            logUnsupported(
                "deserialize",