public class UserInputResumeEventSerializer implements Serializer<UserInputResumeEvent> {

    @Override
    public void write(Encoder encoder, UserInputResumeEvent event) throws Exception {
        encoder.writeLong(event.getTimestamp());
    }

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

		base.Fatalf("InitConst c op %v", c.Op())
	}
	s := n.Linksym()
	switch u := c.Val(); u.Kind() {
	case constant.Bool:
		i := int64(obj.Bool2int(constant.BoolVal(u)))
		s.WriteInt(base.Ctxt, noff, wid, i)

	case constant.Int:
		s.WriteInt(base.Ctxt, noff, wid, ir.IntVal(c.Type(), u))

	case constant.Float:
		f, _ := constant.Float64Val(u)
		switch c.Type().Kind() {
		case types.TFLOAT32:

	return ctxt.LookupInit(name, func(s *LSym) {
		s.Size = 16
		if ctxt.Arch.ByteOrder == binary.LittleEndian {
			s.WriteInt(ctxt, 0, 8, lo)
			s.WriteInt(ctxt, 8, 8, hi)
		} else {
			s.WriteInt(ctxt, 0, 8, hi)
			s.WriteInt(ctxt, 8, 8, lo)
		}
		s.Type = objabi.SRODATA
		s.Set(AttrLocal, true)
		s.Set(AttrContentAddressable, true)
		ctxt.constSyms = append(ctxt.constSyms, s)

    val totalRuleBytes: Int,
    val totalExceptionRuleBytes: Int,
  ) {
    fun writeOut(sink: BufferedSink) {
      with(sink) {
        writeInt(totalRuleBytes)
        for (domain in sortedRules) {
          write(domain).writeByte(NEWLINE)
        }
        writeInt(totalExceptionRuleBytes)
        for (domain in sortedExceptionRules) {
          write(domain).writeByte(NEWLINE)
        }
      }
    }
  }

}

// WriteInt writes an integer i of size siz into s at offset off.
func (s *LSym) WriteInt(ctxt *Link, off int64, siz int, i int64) {
	s.prepwrite(ctxt, off, siz)
	switch siz {
	default:
		ctxt.Diag("WriteInt: bad integer size: %d", siz)
	case 1:
		s.P[off] = byte(i)
	case 2:
		ctxt.Arch.ByteOrder.PutUint16(s.P[off:], uint16(i))
	case 4:

func (z testRequest) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 2
	// write "Num"
	err = en.Append(0x82, 0xa3, 0x4e, 0x75, 0x6d)
	if err != nil {
		return
	}
	err = en.WriteInt(z.Num)
	if err != nil {
		err = msgp.WrapError(err, "Num")
		return
	}
	// write "String"
	err = en.Append(0xa6, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67)
	if err != nil {
		return
	}

public class IntQuestionPromptEventSerializer implements Serializer<IntQuestionPromptEvent> {
    @Override
    public void write(Encoder encoder, IntQuestionPromptEvent value) throws Exception {
        encoder.writeLong(value.getTimestamp());
        encoder.writeString(value.getQuestion());
        encoder.writeSmallInt(value.getMinValue());
        encoder.writeSmallInt(value.getDefaultValue());
    }

    @Override

    @Override
    public void write(Encoder encoder, SelectOptionPromptEvent value) throws Exception {
        encoder.writeLong(value.getTimestamp());
        encoder.writeString(value.getQuestion());
        optionsSerializer.write(encoder, value.getOptions());
        encoder.writeSmallInt(value.getDefaultOption());
    }

    @Override

            BlockPayload payload = getPayload();

            // Write header
            outputStream.writeByte(payload.getType());
            outputStream.writeInt(payloadSize);
            long finalSize = pos + HEADER_SIZE + TAIL_SIZE + payloadSize;

            // Write body
            payload.write(outputStream);

            // Write count

class OrdinalNodeCodec(
    private val ordinalGroups: OrdinalGroupFactory
) : Codec<OrdinalNode> {
    override suspend fun WriteContext.encode(value: OrdinalNode) {
        writeEnum(value.type)
        writeInt(value.ordinalGroup.ordinal)
    }

    override suspend fun ReadContext.decode(): OrdinalNode {
        val ordinalType = readEnum<OrdinalNode.Type>()
        val ordinal = readInt()