}
    }

    public void write(Encoder encoder, DependencyGraphEdge value) throws IOException {
        encoder.writeSmallLong(value.getSelector().getResultId());
        encoder.writeBoolean(value.isConstraint());
        encoder.writeSmallLong(value.getFromVariant());
        if (value.getFailure() == null) {
            if (value.getSelectedVariant() != null) {
                encoder.writeByte(SUCCESSFUL);

	{
		var zb0001 string
		zb0001, err = dc.ReadString()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		(*z) = StatusType(zb0001)
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z StatusType) EncodeMsg(en *msgp.Writer) (err error) {
	err = en.WriteString(string(z))
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler

        }
    }

    private void writeComponentReference(ComponentGraphResolveState component, boolean requireAllVariants, Encoder encoder) throws IOException {
        encoder.writeBoolean(false);
        long instanceId = component.getInstanceId();
        components.putIfAbsent(instanceId, component);
        encoder.writeSmallLong(instanceId);
        encoder.writeBoolean(requireAllVariants);

	e.Int(position.Column)
}

type encoder struct {
	b           []byte
	stringTable []byte
	strings     map[string]int
}

func (e *encoder) Pos() int {
	return len(e.b)
}

func (e *encoder) Bytes(b []byte) {
	e.b = append(e.b, b...)
}

func (e *encoder) String(s string) {
	if n, ok := e.strings[s]; ok {
		e.Int(n)
		return
	}
	pos := len(e.stringTable)
	e.strings[s] = pos

        }

        encoder.writeSmallInt(flags);

        encoder.writeSmallLong(event.getProgressOperationId().getId());
        if (parentProgressOperationId != null) {
            encoder.writeSmallLong(parentProgressOperationId.getId());
        }
        encoder.writeLong(event.getTimestamp());
        if ((flags & CATEGORY_NAME) != 0) {
            encoder.writeString(event.getCategory());
        }

        binaryStore.write(encoder -> {
            encoder.writeByte(NODE);
            encoder.writeSmallLong(id);
            moduleVersionIdSerializer.write(encoder, moduleVersionId);
            encoder.writeString(variantName);
        });
    }

    public void done(final Long id) {
        binaryStore.write(encoder -> {
            encoder.writeByte(ROOT);
            encoder.writeSmallLong(id);

    }

    public static void writeLongs(Encoder encoder, long[] array) throws IOException {
        for (long e : array) {
            encoder.writeLong(e);
        }
    }

    public static void writeLengthPrefixedFloats(Encoder encoder, float[] array) throws IOException {
        encoder.writeInt(array.length);
        writeFloats(encoder, array);
    }

    }

    @Override
    public void write(Encoder encoder, ComponentMetadata md) throws Exception {
        moduleVersionIdentifierSerializer.write(encoder, md.getId());
        attributeContainerSerializer.write(encoder, md.getAttributes());
        checkChangingFlag(md);
        writeStatusScheme(encoder, md);
    }

    private void checkChangingFlag(ComponentMetadata md) {

        }
    }

    @Override
    public void write(Encoder encoder, Map<String, FileSystemLocationFingerprint> value) throws Exception {
        encoder.writeSmallInt(value.size());
        for (String key : value.keySet()) {
            encoder.writeString(key);
            FileSystemLocationFingerprint fingerprint = value.get(key);
            writeFingerprint(encoder, fingerprint);
        }
    }

    @Override

    }

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