serialize.fmt

	func write8(w io.Writer, x uint8) {
		_, err := w.Write([]byte{x})
		chk(err)
	}
	
	func write16(w io.Writer, x uint16) {
		buf := make([]byte, 2)
		be.PutUint16(buf, x)
		_, err := w.Write(buf)
		chk(err)
	}
	
	func write32(w io.Writer, x uint32) {
		buf := make([]byte, 4)
		be.PutUint32(buf, x)
		_, err := w.Write(buf)
		chk(err)
	}
	
	func write64(w io.Writer, x uint64) {
		buf := make([]byte, 8)
		be.PutUint64(buf, x)
		_, err := w.Write(buf)
		chk(err)
	}

byte	write8(w, uint8(x))
uint8	write8(w, uint8(x))
uint16	write16(w, uint16(x))
uint32	write32(w, uint32(x))
uint64	write64(w, uint64(x))

int8	write8(w, uint8(x))
int16	write16(w, uint16(x))
int32	write32(w, uint32(x))
int64	write64(w, uint64(x))

bool	if x { write8(w, 1) } else { write8(w, 0) }

float32	write32(w, math.Float32bits(x))
float64	write64(w, math.Float64bits(x))

AOMsg	writeAOMsg(w, x)

image/color.NRGBA	w.Write([]byte{x.A, x.R, x.G, x.B})

map[uint16]*NodeMeta	{
		if x == nil {
			write8(w, 0)
		} else {
			write8(w, 2)
			// len(map[uint16]...) always < math.MaxUint16
			write16(w, uint16(len(x)))
			keys := make([]uint16, 0, len(x))
			for key := range x {
				keys = append(keys, key)
			}
			sort.Slice(keys, func(i, j int) bool {
				i2pos := func(i int) [3]int16 {
					return Blkpos2Pos([3]int16{}, keys[i])
				}

				p, q := i2pos(i), i2pos(j)

				for i := range p {
					switch {
					case p[i] < q[i]:
						return true
					case p[i] > q[i]:
						return false
					}
				}

				return false
			})
			for _, key := range keys {
				write16(w, key)
				chk(serialize(w, x[key]))
			}
		}
	}

map[[3]int16]*NodeMeta	{
		w := zlib.NewWriter(w)

		if x == nil {
			write8(w, 0)
		} else {
			write8(w, 2)
			if len(x) > math.MaxUint16 {
				chk(ErrTooLong)
			}
			write16(w, uint16(len(x)))
			keys := make([][3]int16, 0, len(x))
			for key := range x {
				keys = append(keys, key)
			}
			sort.Slice(keys, func(i, j int) bool {
				p, q := keys[i], keys[j]

				for i := range p {
					switch {
					case p[i] < q[i]:
						return true
					case p[i] > q[i]:
						return false
					}
				}

				return false
			})
			for _, key := range keys {
				for _, n := range key {
					write16(w, uint16(n))
				}
				chk(serialize(w, x[key]))
			}
		}

		chk(w.Close())
	}

PointedThing	chk(writePointedThing(w, x))

[]AOMsg	{ // For AOInitData.Msgs.
		if len(x) > math.MaxUint8 {
			chk(ErrTooLong)
		}
		write8(w, uint8(len(x)))
		for _, msg := range x {
			var b bytes.Buffer
			chk(writeAOMsg(&b, msg))
			if b.Len() > math.MaxUint32 {
				chk(ErrTooLong)
			}
			write32(w, uint32(b.Len()))
			_, err := b.WriteTo(w)
			chk(err)
		}
	}

[]NodeDef	{ // For ToCltNodeDefs.Defs.
		if len(x) > math.MaxUint16 {
			chk(ErrTooLong)
		}
		write16(w, uint16(len(x)))
		var b bytes.Buffer
		for i := range x {
			x[i].serialize(&b)
		}
		if b.Len() > math.MaxUint32 {
			chk(ErrTooLong)
		}
		write32(w, uint32(b.Len()))
		_, err := b.WriteTo(w)
		chk(err)
	}

map[string]PointabilityType	{ // For Pointabilities.
		if len(x) > math.MaxUint32 {
			chk(ErrTooLong)
		}
		write32(w, uint32(len(x)))
		for name, typ := range x {
			if len(name) > math.MaxUint16 {
				chk(ErrTooLong)
			}
			chk(serialize(w, name))
			write8(w, uint8(typ))
		}
	}

map[float32]image/color.NRGBA	{ // For WearBarParams.ColorStops.
		if len(x) > math.MaxUint16 {
			chk(ErrTooLong)
		}
		write16(w, uint16(len(x)))
		for wear, c := range x {
			write32(w, uint32(wear))
			// Same as image/color.NRGBA, but it doesn't implement
			// serializer.
			_, err := w.Write([]byte{c.A, c.R, c.G, c.B})
			chk(err)
		}
	}