}
	return obj, gvk, err
}

type encoderWithAllocator struct {
	encoder      EncoderWithAllocator
	memAllocator MemoryAllocator
}

// NewEncoderWithAllocator returns a new encoder
func NewEncoderWithAllocator(e EncoderWithAllocator, a MemoryAllocator) Encoder {
	return &encoderWithAllocator{
		encoder:      e,
		memAllocator: a,
	}
}

            return CompilerApiData.withConstantsMapping(sourceToClassMapping, new ConstantToDependentsMapping(constantDependents));
        }

        @Override
        public void write(Encoder encoder, CompilerApiData value) throws Exception {
            encoder.writeBoolean(value.isAvailable());
            if (value.isAvailable()) {
                HierarchicalNameSerializer nameSerializer = classNameSerializerSupplier.get();

	if err != nil {
		return nil, err
	}
	return &rootNode, nil
}

func streamYaml(writer io.Writer, indent *int, in *yaml.Node) error {
	encoder := yaml.NewEncoder(writer)
	encoder.SetIndent(*indent)
	err := encoder.Encode(in)
	if err != nil {
		return err
	}
	return encoder.Close()

            return new FileInfo(hash, length, timestamp);
        }

        @Override
        public void write(Encoder encoder, FileInfo value) throws Exception {
            hashCodeSerializer.write(encoder, value.hash);
            encoder.writeLong(value.timestamp);
            encoder.writeLong(value.length);
        }

        @Override
        public boolean equals(Object obj) {

    }

    @Override
    public void write(Encoder encoder, AttributeContainer container) throws IOException {
        encoder.writeSmallInt(container.keySet().size());
        for (Attribute<?> attribute : container.keySet()) {
            encoder.writeString(attribute.getName());
            Class<?> type = attribute.getType();
            if (type == Boolean.class) {
                encoder.writeByte(BOOLEAN_ATTRIBUTE);

        }
    }

    private static void writeMetadata(InstrumentationArtifactMetadata metadata, KryoBackedEncoder encoder) {
        encoder.writeString(metadata.getArtifactName());
        encoder.writeString(metadata.getArtifactHash());
    }

    private static void writeTypesMap(Map<String, Set<String>> typesMap, Encoder encoder, HierarchicalNameSerializer nameSerializer) throws Exception {

    }

    private static class VersionRefSerializer implements Serializer<VersionRef> {
        @Override
        public void write(Encoder encoder, VersionRef value) throws Exception {
            GitVersionRef gitRef = (GitVersionRef) value;
            encoder.writeString(gitRef.getVersion());
            encoder.writeString(gitRef.getCanonicalId());
        }

        @Override
        public VersionRef read(Decoder decoder) throws Exception {

// license that can be found in the LICENSE file.

package a

func Marshal[foobar any]() {
	_ = NewEncoder[foobar]()
}

func NewEncoder[foobar any]() *Encoder[foobar] {
	return nil
}

type Encoder[foobar any] struct {
}

func (e *Encoder[foobar]) EncodeToken(t Token[foobar]) {

}

		return e, reedsolomon.ErrMaxShardNum
	}

	e = Erasure{
		dataBlocks:   dataBlocks,
		parityBlocks: parityBlocks,
		blockSize:    blockSize,
	}

	// Encoder when needed.
	var enc reedsolomon.Encoder
	var once sync.Once
	e.encoder = func() reedsolomon.Encoder {
		once.Do(func() {
			e, err := reedsolomon.New(dataBlocks, parityBlocks, reedsolomon.WithAutoGoroutines(int(e.ShardSize())))
			if err != nil {

        try {
            if (encoder != null) {
                encoder.done();
                encoder.flush();
            }
            return new SimpleBinaryData(file, offset);
        } finally {
            offset = -1;
        }
    }

    @Override
    public void close() {
        try {
            if (encoder != null) {
                encoder.close();
            }
        } finally {