}

    @Override
    public ProgressEvent read(Decoder decoder) throws Exception {
        OperationIdentifier id = new OperationIdentifier(decoder.readSmallLong());
        String status = decoder.readString();
        boolean failing = decoder.readBoolean();
        return new ProgressEvent(id, status, failing);
    }

    private AnnotationProcessorDeclarationSerializer() {
    }

    @Override
    public AnnotationProcessorDeclaration read(Decoder decoder) throws EOFException, Exception {
        String name = decoder.readString();
        IncrementalAnnotationProcessorType type = IncrementalAnnotationProcessorType.values()[decoder.readSmallInt()];
        return new AnnotationProcessorDeclaration(name, type);
    }

    @Override

	if !isIdent(c) {
		r.syntaxError()
		return
	}
	for isIdent(r.peekByte(false)) {
		r.peek = 0
	}
}

// readString reads a quoted string literal from the input.
// If an identifier is not present, readString records a syntax error.
func (r *importReader) readString() {
	switch r.nextByte(true) {
	case '`':
		for r.err == nil {
			if r.nextByte(false) == '`' {
				break
			}
			if r.eof {

        ModuleComponentIdentifier componentIdentifier = (ModuleComponentIdentifier) componentIdentifierSerializer.read(decoder);
        String fileName = decoder.readString();
        return new ModuleComponentFileArtifactIdentifier(componentIdentifier, fileName);
    }

    @Override
    public void write(Encoder encoder, ModuleComponentFileArtifactIdentifier value) throws Exception {

        encoder.writeSmallInt(value.getDefaultValue());
    }

    @Override
    public IntQuestionPromptEvent read(Decoder decoder) throws Exception {
        return new IntQuestionPromptEvent(decoder.readLong(), decoder.readString(), decoder.readSmallInt(), decoder.readSmallInt());
    }

        encoder.writeSmallInt(value.getDefaultOption());
    }

    @Override
    public SelectOptionPromptEvent read(Decoder decoder) throws Exception {
        return new SelectOptionPromptEvent(decoder.readLong(), decoder.readString(), optionsSerializer.read(decoder), decoder.readSmallInt());
    }

                Assume.assumeTrue(JavaVersion.current().isJava11Compatible())
                """
                ((Supplier<String>) () -> {
                    try {
                        return Files.readString(new File("$filePath").toPath());
                    } catch (IOException e) {
                        throw new RuntimeException(e);
                    }
                }).get()
                """.stripIndent()

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

	s1b := []byte(s1)
	b = append(b, s1b...)
	b = appendUleb128(b, 9)
	s2 := "bazbasher"
	s2b := []byte(s2)
	b = append(b, s2b...)

	readStr := func(slr *Reader) string {
		len := slr.ReadULEB128()
		return slr.ReadString(int64(len))
	}

	for i := 0; i < 2; i++ {
		slr := NewReader(b, i == 0)
		g32 := slr.ReadUint32()
		if g32 != e32 {
			t.Fatalf("slr.ReadUint32() got %d want %d", g32, e32)
		}
		g64 := slr.ReadUint64()

				z.DecommissionedBuckets[za0002], err = dc.ReadString()
				if err != nil {
					err = msgp.WrapError(err, "DecommissionedBuckets", za0002)
					return
				}
			}
		case "bkt":
			z.Bucket, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Bucket")
				return
			}
		case "pfx":
			z.Prefix, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Prefix")