encoder.writeInt(array.length);
        writeInts(encoder, array);
    }

    public static void writeInts(Encoder encoder, int[] array) throws IOException {
        for (int e : array) {
            encoder.writeInt(e);
        }
    }

    public static void writeLengthPrefixedLongs(Encoder encoder, long[] array) throws IOException {
        encoder.writeInt(array.length);

		return
	}
	err = en.WriteUint8(uint8(z.Type))
	if err != nil {
		err = msgp.WrapError(err, "Type")
		return
	}
	err = en.WriteUint8(uint8(z.Flags))
	if err != nil {
		err = msgp.WrapError(err, "Flags")
		return
	}
	err = en.WriteUint8(z.EcN)
	if err != nil {
		err = msgp.WrapError(err, "EcN")
		return
	}
	err = en.WriteUint8(z.EcM)
	if err != nil {

    @Override
    public void writeSmallLong(long value) {
        output.writeLong(value, true);
    }

    @Override
    public void writeInt(int value) {
        output.writeInt(value);
    }

    @Override
    public void writeSmallInt(int value) {
        output.writeInt(value, true);
    }

    @Override
    public void writeShort(short value) throws IOException {
        output.writeShort(value);
    }

      frameHeader(
        streamId = 0,
        length = 8,
        type = TYPE_PING,
        flags = if (ack) FLAG_ACK else FLAG_NONE,
      )
      sink.writeInt(payload1)
      sink.writeInt(payload2)
      sink.flush()
    }
  }

  /**
   * Tell the peer to stop creating streams and that we last processed `lastGoodStreamId`, or zero
   * if no streams were processed.
   *

    }

    override fun defaultWriteObject() = record {
        beanStateWriterFor(beanType).run {
            writeStateOf(bean)
        }
    }

    override fun writeInt(`val`: Int) = record {
        writeInt(`val`)
    }

    override fun writeUTF(str: String) = record {
        writeString(str)
    }

    override fun writeObjectOverride(obj: Any?) = record {
        write(obj)
    }

    @Override
    public void writeSmallLong(long value) {
        output.writeLong(value, true);
    }

    @Override
    public void writeInt(int value) {
        output.writeInt(value);
    }

    @Override
    public void writeSmallInt(int value) {
        output.writeInt(value, true);
    }

    @Override
    public void writeShort(short value) throws IOException {
        output.writeShort(value);
    }

        }
        return result;
    }

    @Override
    public void write(Encoder encoder, IntSet value) throws Exception {
        encoder.writeInt(value.size());
        IntIterator iterator = value.iterator();
        while(iterator.hasNext()) {
            encoder.writeInt(iterator.nextInt());
        }
    }

    }

    @Override
    public void writeLong(long value) throws IOException {
        outputStream.writeLong(value);
    }

    @Override
    public void writeInt(int value) throws IOException {
        outputStream.writeInt(value);
    }

    @Override
    public void writeShort(short value) throws IOException {
        outputStream.writeShort(value);
    }

    @Override

            }
            encoder.writeBoolean(context.idleTimeout != null);
            if (context.idleTimeout != null) {
                encoder.writeInt(context.idleTimeout);
            }
            encoder.writeInt(context.daemonOpts.size());
            for (String daemonOpt : context.daemonOpts) {
                encoder.writeString(daemonOpt);
            }

            outstr.writeInt(sharedPackages.size());
            for (String str : sharedPackages) {
                outstr.writeUTF(str);
            }

            // Serialize the worker implementation classpath, this is consumed by GradleWorkerMain
            if (runAsModule || implementationModulePath == null) {
                outstr.writeInt(implementationClassPath.size());