}

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

						return
					}
					switch msgp.UnsafeString(field) {
					case "b":
						za0002.Bucket, err = dc.ReadString()
						if err != nil {
							err = msgp.WrapError(err, "Entries", za0001, "Bucket")
							return
						}
					case "o":
						za0002.Object, err = dc.ReadString()
						if err != nil {
							err = msgp.WrapError(err, "Entries", za0001, "Object")
							return
						}

        ServerInfo1 e = null;

        results = new ServerInfo1[numEntries];
        for( int i = 0; i < numEntries; i++ ) {
            results[i] = e = new ServerInfo1();
            e.name = readString( buffer, bufferIndex, 16, false );
            bufferIndex += 16;
            e.versionMajor = (int)( buffer[bufferIndex++] & 0xFF );
            e.versionMinor = (int)( buffer[bufferIndex++] & 0xFF );

        }

        @Override
        public ArtifactsAtRepositoryKey read(Decoder decoder) throws Exception {
            String resolverId = decoder.readString();
            ComponentIdentifier componentId = identifierSerializer.read(decoder);
            String context = decoder.readString();
            return new ArtifactsAtRepositoryKey(resolverId, componentId, context);
        }

        @Override

        try {
            return input.readBoolean();
        } catch (KryoException e) {
            throw maybeEndOfStream(e);
        }
    }

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

    @Override
    public String readNullableString() throws EOFException {
        try {
            int idx = readInt();

        }
    }

    private static InstrumentationArtifactMetadata readMetadata(KryoBackedDecoder decoder) throws EOFException {
        return new InstrumentationArtifactMetadata(decoder.readString(), decoder.readString());
    }

    private static Map<String, Set<String>> readTypesMap(Decoder decoder, HierarchicalNameSerializer nameSerializer) throws Exception {

        writeString(value.name)
        writeClassArray(value.parameterTypes)
    }

    override suspend fun ReadContext.decode(): Method? {
        val declaringClass = readClass()
        val methodName = readString()
        val parameterTypes = readClassArray()
        return declaringClass.getDeclaredMethod(methodName, *parameterTypes)
    }

			return
		}
		switch msgp.UnsafeString(field) {
		case "Num":
			z.Num, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "Num")
				return
			}
		case "String":
			z.String, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "String")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return

		case "Name":
			z.Name, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Name")
				return
			}
		case "Algorithm":
			z.Algorithm, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Algorithm")
				return
			}
		case "Hash":
			z.Hash, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Hash")

			{
				var zb0002 string
				zb0002, err = dc.ReadString()
				if err != nil {
					err = msgp.WrapError(err, "Type")
					return
				}
				z.Type = BatchKeyRotationType(zb0002)
			}
		case "Key":
			z.Key, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Key")
				return
			}
		case "Context":
			z.Context, err = dc.ReadString()
			if err != nil {