return
	}
	err = en.WriteString(z.DiskID)
	if err != nil {
		err = msgp.WrapError(err, "DiskID")
		return
	}
	// write "m"
	err = en.Append(0xa1, 0x6d)
	if err != nil {
		return
	}
	err = en.WriteInt(z.ScanMode)
	if err != nil {
		err = msgp.WrapError(err, "ScanMode")
		return
	}
	// write "c"
	err = en.Append(0xa1, 0x63)
	if err != nil {
		return
	}
	if z.Cache == nil {
		err = en.WriteNil()

   */
  private void writeObject(ObjectOutputStream s) throws IOException {
    s.defaultWriteObject();

    // Write out array length
    int length = length();
    s.writeInt(length);

    // Write out all elements in the proper order.
    for (int i = 0; i < length; i++) {
      s.writeDouble(get(i));
    }
  }

func (z *PoolStatus) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 4
	// write "id"
	err = en.Append(0x84, 0xa2, 0x69, 0x64)
	if err != nil {
		return
	}
	err = en.WriteInt(z.ID)
	if err != nil {
		err = msgp.WrapError(err, "ID")
		return
	}
	// write "cl"
	err = en.Append(0xa2, 0x63, 0x6c)
	if err != nil {
		return
	}
	err = en.WriteString(z.CmdLine)

    @Override
    public final void writeChar(final int v) throws SmbException {
        Encdec.enc_uint16be((short) v, tmp, 0);
        write(tmp, 0, 2);
    }

    @Override
    public final void writeInt(final int v) throws SmbException {
        Encdec.enc_uint32be(v, tmp, 0);
        write(tmp, 0, 4);
    }

    @Override
    public final void writeLong(final long v) throws SmbException {

	if err != nil {
		err = msgp.WrapError(err, "ForwardTo")
		return
	}
	// write "Limit"
	err = en.Append(0xa5, 0x4c, 0x69, 0x6d, 0x69, 0x74)
	if err != nil {
		return
	}
	err = en.WriteInt(z.Limit)
	if err != nil {
		err = msgp.WrapError(err, "Limit")
		return
	}
	// write "DiskID"
	err = en.Append(0xa6, 0x44, 0x69, 0x73, 0x6b, 0x49, 0x44)
	if err != nil {
		return
	}

        dst[start + ANDX_COMMAND_OFFSET] = this.andxCommand;
        dst[start + ANDX_RESERVED_OFFSET] = (byte) 0x00;
        this.andxOffset = dstIndex - this.headerStart;
        SMBUtil.writeInt2(this.andxOffset, dst, start + ANDX_OFFSET_OFFSET);

        this.andx.setUseUnicode(this.isUseUnicode());
        if (this.andx instanceof AndXServerMessageBlock) {

            /*

                }
                index++;
            }
        }
        return -1;
    }

    @Override
    public void writeExternal(final ObjectOutput s) throws IOException {
        s.writeInt(size);
        for (Entry e = header.next; e != header; e = e.next) {
            s.writeObject(e.element);
        }
    }

    @SuppressWarnings("unchecked")
    @Override

        dos.writeShort(Short.reverseBytes(value));
    }

    private void writeLittleEndianInt(DataOutputStream dos, int value) throws IOException {
        dos.writeInt(Integer.reverseBytes(value));
    }

    private void writeLittleEndianLong(DataOutputStream dos, long value) throws IOException {
        dos.writeLong(Long.reverseBytes(value));
    }

    @Test

      try {
        output.writeFloat(v);
      } catch (IOException impossible) {
        throw new AssertionError(impossible);
      }
    }

    @Override
    public void writeInt(int v) {
      try {
        output.writeInt(v);
      } catch (IOException impossible) {
        throw new AssertionError(impossible);
      }
    }

    @Override
    public void writeLong(long v) {
      try {

func (z ActiveWorkerStat) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 3
	// write "Curr"
	err = en.Append(0x83, 0xa4, 0x43, 0x75, 0x72, 0x72)
	if err != nil {
		return
	}
	err = en.WriteInt(z.Curr)
	if err != nil {
		err = msgp.WrapError(err, "Curr")
		return
	}
	// write "Avg"
	err = en.Append(0xa3, 0x41, 0x76, 0x67)
	if err != nil {
		return
	}
	err = en.WriteFloat32(z.Avg)