writeBoolean(value.isLenient)
        writeCollection(visitor.elements)
    }

    override suspend fun ReadContext.decode(): ArtifactCollectionInternal {
        val displayName = readString()
        val lenient = readBoolean()
        val elements = readList().uncheckedCast<List<Any>>()

        val files = artifactSetConverter.asFileCollection(displayName, lenient,
            elements.map { element ->

                        id = decoder.readSmallLong();
                        ModuleVersionIdentifier moduleVersionId = moduleVersionIdSerializer.read(decoder);
                        String variantName = decoder.readString();
                        allDependencies.put(id, new DefaultResolvedDependency(variantName, moduleVersionId, buildOperationProcessor));
                        break;
                    case ROOT:

            encoder.writeString(message.getResponse());
        }

        @Override
        public UserResponse read(Decoder decoder) throws Exception {
            return new UserResponse(decoder.readString());
        }
    }

    private static class CloseInputSerializer implements Serializer<CloseInput> {
        @Override
        public void write(Encoder encoder, CloseInput value) {
        }

		}

		// Prompt for decryption key if no --key or --private-key are provided
		if len(privateKey) == 0 && !*stdin {
			reader := bufio.NewReader(os.Stdin)
			fmt.Print("Enter Decryption Key: ")

			text, _ := reader.ReadString('\n')
			// convert CRLF to LF
			*keyHex = strings.ReplaceAll(text, "\n", "")
			*keyHex = strings.TrimSpace(*keyHex)
		}
	}

	var inputs []string

	// Parse parameters
	switch {
	case *stdin:

			cmd.Stdin = strings.NewReader(s)
			stderr, err := cmd.StderrPipe()
			if err != nil {
				panic(err)
			}
			qpres := make(chan any, 2)
			go func() {
				br := bufio.NewReader(stderr)
				s, _ := br.ReadString('\n')
				if s != "" {
					qpres <- errors.New(s)
					if cmd.Process != nil {
						// It can get stuck on invalid input, like:
						// echo -n "0000= " | qprint -d
						cmd.Process.Kill()
					}

					}
				}
				for zb0011 > 0 {
					zb0011--
					var za0011 string
					var za0012 string
					za0011, err = dc.ReadString()
					if err != nil {
						err = msgp.WrapError(err, "MetaUser")
						return
					}
					za0012, err = dc.ReadString()
					if err != nil {
						err = msgp.WrapError(err, "MetaUser", za0011)
						return
					}
					z.MetaUser[za0011] = za0012

    }

    override suspend fun ReadContext.decode(): BuildServiceProvider<*, *>? =
        decodePreservingSharedIdentity {
            val buildIdentifier = readNonNull<BuildIdentifier>()
            val name = readString()
            val implementationType = readClassOf<BuildService<*>>()
            val isResolved = readBoolean()
            if (isResolved) {
                val parameters = read() as BuildServiceParameters?

            val mappings = registry.create()!!
            readCollection {
                val name = readString()
                val attributes = readNonNull<AttributeContainer>()
                val mapping = mappings.create(name).attributes
                @Suppress("UNCHECKED_CAST")

            undefined()

        override fun readSmallLong(): Long =
            undefined()

        override fun getInputStream(): InputStream =
            undefined()

        override fun readString(): String =
            undefined()

        override fun readBoolean(): Boolean =
            undefined()

        override fun readBytes(buffer: ByteArray?): Unit =
            undefined()

			// trailing zero, but everyone agrees that name is null-terminated.
			// So we'll just determine the actual length after the fact.
			var err error
			name, err = r.ReadString('\x00')
			if err == io.EOF {
				return nil, fmt.Errorf("missing note name (want %d bytes)", namesz)
			} else if err != nil {
				return nil, err
			}
			namesz = uint32(len(name))
			name = name[:len(name)-1]