decoder.readBytes(hash);
        return HashCode.fromBytes(hash);
    }

    @Override
    public void write(Encoder encoder, HashCode value) throws IOException {
        byte[] hash = value.toByteArray();
        encoder.writeByte((byte) hash.length);
        encoder.writeBytes(hash);
    }

            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();

	}
	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,
	}
}

            encoder.writeBoolean(metadata.isMissing());
            encoder.writeBoolean(metadata.isChanging());
            encoder.writeBoolean(metadata.isExternalVariant());
            encoder.writeString(metadata.getStatus());
            writeStringList(metadata.getStatusScheme());
            moduleSourcesSerializer.write(encoder, metadata.getSources());
        }

            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) {

	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()

// 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]) {

}

    }

    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 {

				return
			}
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *RTimedMetrics) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 4
	// write "LastHour"
	err = en.Append(0x84, 0xa8, 0x4c, 0x61, 0x73, 0x74, 0x48, 0x6f, 0x75, 0x72)
	if err != nil {
		return
	}
	err = z.LastHour.EncodeMsg(en)
	if err != nil {
		err = msgp.WrapError(err, "LastHour")
		return

				return
			}
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *BatchJobReplicateFlags) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 3
	// write "Filter"
	err = en.Append(0x83, 0xa6, 0x46, 0x69, 0x6c, 0x74, 0x65, 0x72)
	if err != nil {
		return
	}
	err = z.Filter.EncodeMsg(en)
	if err != nil {
		err = msgp.WrapError(err, "Filter")
		return
	}