zip/internal/layout/zap_gen.go

// Code generated by zip; DO NOT EDIT.

package layout

import (
	"encoding/binary"
	"fmt"
	"math"
	"strings"

	zap "github.com/zap-proto/go"
)

// ---- Ided --------------------------------------------------------------

const (
	idedIDAt   = 0
	idedNameAt = 32
	idedIDsAt  = 40
	idedLeafAt = 48
	idedSize   = 56
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*Ided)(nil)

// MarshalZAP writes Ided from constant offsets.
func (x *Ided) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(idedSize + 256)
	iDsAt, iDsN := 0, len(x.IDs)
	if iDsN > 0 {
		var blob []byte
		for i := range x.IDs {
			enc := x.IDs[i][:]
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		iDsAt = b.WriteBytes(blob)
	}
	ob := b.StartObject(idedSize)
	ob.SetBytesFixed(idedIDAt, x.ID[:])
	ob.SetText(idedNameAt, string(x.Name))
	innerLeaf, err := x.Leaf.MarshalZAP()
	if err != nil {
		return nil, err
	}
	ob.SetBytes(idedLeafAt, innerLeaf)
	if iDsN > 0 {
		ob.SetList(idedIDsAt, iDsAt, iDsN)
	}
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads Ided out of the buffer that arrived.
func (x *Ided) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("Ided: %w", err)
	}
	o := m.Root()
	copy(x.ID[:], o.BytesFixed(idedIDAt, 32))
	x.Name = string(strings.Clone(o.Text(idedNameAt)))
	if l := o.List(idedIDsAt); l.Len() > 0 {
		var rows [][32]uint8
		l.EachBytes(func(_ int, raw []byte) bool {
			var e [32]uint8
			copy(e[:], raw)
			rows = append(rows, e)
			return true
		})
		x.IDs = rows
	}
	if raw := o.Bytes(idedLeafAt); len(raw) > 0 {
		if err := x.Leaf.UnmarshalZAP(raw); err != nil {
			return err
		}
	}
	return nil
}

// ---- Leaf --------------------------------------------------------------

const (
	leafNAt  = 0
	leafSAt  = 8
	leafSize = 16
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*Leaf)(nil)

// MarshalZAP writes Leaf from constant offsets.
func (x *Leaf) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(leafSize + 256)
	ob := b.StartObject(leafSize)
	ob.SetUint32(leafNAt, uint32(x.N))
	ob.SetText(leafSAt, string(x.S))
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads Leaf out of the buffer that arrived.
func (x *Leaf) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("Leaf: %w", err)
	}
	o := m.Root()
	x.N = uint32(o.Uint32(leafNAt))
	x.S = string(strings.Clone(o.Text(leafSAt)))
	return nil
}

// ---- Trunk -------------------------------------------------------------

const (
	trunkBAt     = 0
	trunkI8At    = 1
	trunkI16At   = 2
	trunkI32At   = 4
	trunkI64At   = 8
	trunkU8At    = 16
	trunkU16At   = 18
	trunkU32At   = 20
	trunkU64At   = 24
	trunkF32At   = 32
	trunkF64At   = 40
	trunkCAt     = 48
	trunkTextAt  = 56
	trunkRawAt   = 64
	trunkLeafAt  = 72
	trunkPtrUAt  = 80
	trunkPtrSAt  = 88
	trunkPtrBAt  = 96
	trunkPtrLAt  = 104
	trunkNumsAt  = 112
	trunkSigsAt  = 120
	trunkBigsAt  = 128
	trunkStrsAt  = 136
	trunkBufsAt  = 144
	trunkBitsAt  = 152
	trunkKidsAt  = 160
	trunkPtrsAt  = 168
	trunkSealAt  = 176
	trunkSealsAt = 184
	trunkPKidsAt = 192
	trunkPNumsAt = 200
	trunkPtrI8At = 208
	trunkPtrI6At = 216
	trunkPtrI3At = 224
	trunkPtrI4At = 232
	trunkPtrU1At = 240
	trunkPtrU6At = 248
	trunkPtrU3At = 256
	trunkPtrF3At = 264
	trunkPtrF6At = 272
	trunkPtrCAt  = 280
	trunkPtrRAt  = 288
	trunkSize    = 296
)

var _ interface {
	MarshalZAP() ([]byte, error)
	UnmarshalZAP([]byte) error
} = (*Trunk)(nil)

// MarshalZAP writes Trunk from constant offsets.
func (x *Trunk) MarshalZAP() ([]byte, error) {
	if x == nil {
		return nil, nil
	}
	b := zap.NewBuilder(trunkSize + 256)
	ptrUAt, ptrUN := 0, 0
	if x.PtrU != nil {
		var full [8]byte
		binary.LittleEndian.PutUint64(full[:], uint64((*x.PtrU)))
		enc := full[:8]
		ptrUAt = b.WriteBytes(append(binary.LittleEndian.AppendUint32(nil, uint32(len(enc))), enc...))
		ptrUN = 1
	}
	ptrSAt, ptrSN := 0, 0
	if x.PtrS != nil {
		enc := []byte((*x.PtrS))
		ptrSAt = b.WriteBytes(append(binary.LittleEndian.AppendUint32(nil, uint32(len(enc))), enc...))
		ptrSN = 1
	}
	ptrBAt, ptrBN := 0, 0
	if x.PtrB != nil {
		enc := []byte{0}
		if *x.PtrB {
			enc[0] = 1
		}
		ptrBAt = b.WriteBytes(append(binary.LittleEndian.AppendUint32(nil, uint32(len(enc))), enc...))
		ptrBN = 1
	}
	numsAt, numsN := 0, len(x.Nums)
	if numsN > 0 {
		var blob []byte
		for i := range x.Nums {
			var full [8]byte
			binary.LittleEndian.PutUint64(full[:], uint64(x.Nums[i]))
			enc := full[:4]
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		numsAt = b.WriteBytes(blob)
	}
	sigsAt, sigsN := 0, len(x.Sigs)
	if sigsN > 0 {
		var blob []byte
		for i := range x.Sigs {
			var full [8]byte
			binary.LittleEndian.PutUint64(full[:], uint64(x.Sigs[i]))
			enc := full[:4]
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		sigsAt = b.WriteBytes(blob)
	}
	bigsAt, bigsN := 0, len(x.Bigs)
	if bigsN > 0 {
		var blob []byte
		for i := range x.Bigs {
			var full [8]byte
			binary.LittleEndian.PutUint64(full[:], math.Float64bits(float64(x.Bigs[i])))
			enc := full[:8]
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		bigsAt = b.WriteBytes(blob)
	}
	strsAt, strsN := 0, len(x.Strs)
	if strsN > 0 {
		var blob []byte
		for i := range x.Strs {
			enc := []byte(x.Strs[i])
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		strsAt = b.WriteBytes(blob)
	}
	bufsAt, bufsN := 0, len(x.Bufs)
	if bufsN > 0 {
		var blob []byte
		for i := range x.Bufs {
			enc := []byte(x.Bufs[i])
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		bufsAt = b.WriteBytes(blob)
	}
	bitsAt, bitsN := 0, len(x.Bits)
	if bitsN > 0 {
		var blob []byte
		for i := range x.Bits {
			enc := []byte{0}
			if x.Bits[i] {
				enc[0] = 1
			}
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		bitsAt = b.WriteBytes(blob)
	}
	kidsAt, kidsN := 0, len(x.Kids)
	if kidsN > 0 {
		var blob []byte
		for i := range x.Kids {
			enc, err := x.Kids[i].MarshalZAP()
			if err != nil {
				return nil, err
			}
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		kidsAt = b.WriteBytes(blob)
	}
	ptrsAt, ptrsN := 0, len(x.Ptrs)
	if ptrsN > 0 {
		var blob []byte
		for i := range x.Ptrs {
			elem := x.Ptrs[i]
			if elem == nil {
				elem = new(Leaf)
			}
			enc, err := elem.MarshalZAP()
			if err != nil {
				return nil, err
			}
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		ptrsAt = b.WriteBytes(blob)
	}
	sealsAt, sealsN := 0, len(x.Seals)
	if sealsN > 0 {
		var blob []byte
		for range x.Seals {
			eb := zap.NewBuilder(zap.HeaderSize)
			eb.StartObject(0).FinishAsRoot()
			enc := eb.Finish()
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		sealsAt = b.WriteBytes(blob)
	}
	pKidsAt, pKidsN := 0, 0
	if x.PKids != nil {
		pKidsN = len((*x.PKids))
	}
	if pKidsN > 0 {
		var blob []byte
		for i := range *x.PKids {
			enc, err := (*x.PKids)[i].MarshalZAP()
			if err != nil {
				return nil, err
			}
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		pKidsAt = b.WriteBytes(blob)
	}
	pNumsAt, pNumsN := 0, 0
	if x.PNums != nil {
		pNumsN = len((*x.PNums))
	}
	if pNumsN > 0 {
		var blob []byte
		for i := range *x.PNums {
			var full [8]byte
			binary.LittleEndian.PutUint64(full[:], uint64((*x.PNums)[i]))
			enc := full[:4]
			var n [4]byte
			binary.LittleEndian.PutUint32(n[:], uint32(len(enc)))
			blob = append(blob, n[:]...)
			blob = append(blob, enc...)
		}
		pNumsAt = b.WriteBytes(blob)
	}
	ptrI8At, ptrI8N := 0, 0
	if x.PtrI8 != nil {
		var full [8]byte
		binary.LittleEndian.PutUint64(full[:], uint64((*x.PtrI8)))
		enc := full[:1]
		ptrI8At = b.WriteBytes(append(binary.LittleEndian.AppendUint32(nil, uint32(len(enc))), enc...))
		ptrI8N = 1
	}
	ptrI6At, ptrI6N := 0, 0
	if x.PtrI6 != nil {
		var full [8]byte
		binary.LittleEndian.PutUint64(full[:], uint64((*x.PtrI6)))
		enc := full[:2]
		ptrI6At = b.WriteBytes(append(binary.LittleEndian.AppendUint32(nil, uint32(len(enc))), enc...))
		ptrI6N = 1
	}
	ptrI3At, ptrI3N := 0, 0
	if x.PtrI3 != nil {
		var full [8]byte
		binary.LittleEndian.PutUint64(full[:], uint64((*x.PtrI3)))
		enc := full[:4]
		ptrI3At = b.WriteBytes(append(binary.LittleEndian.AppendUint32(nil, uint32(len(enc))), enc...))
		ptrI3N = 1
	}
	ptrI4At, ptrI4N := 0, 0
	if x.PtrI4 != nil {
		var full [8]byte
		binary.LittleEndian.PutUint64(full[:], uint64((*x.PtrI4)))
		enc := full[:8]
		ptrI4At = b.WriteBytes(append(binary.LittleEndian.AppendUint32(nil, uint32(len(enc))), enc...))
		ptrI4N = 1
	}
	ptrU1At, ptrU1N := 0, 0
	if x.PtrU1 != nil {
		var full [8]byte
		binary.LittleEndian.PutUint64(full[:], uint64((*x.PtrU1)))
		enc := full[:1]
		ptrU1At = b.WriteBytes(append(binary.LittleEndian.AppendUint32(nil, uint32(len(enc))), enc...))
		ptrU1N = 1
	}
	ptrU6At, ptrU6N := 0, 0
	if x.PtrU6 != nil {
		var full [8]byte
		binary.LittleEndian.PutUint64(full[:], uint64((*x.PtrU6)))
		enc := full[:2]
		ptrU6At = b.WriteBytes(append(binary.LittleEndian.AppendUint32(nil, uint32(len(enc))), enc...))
		ptrU6N = 1
	}
	ptrU3At, ptrU3N := 0, 0
	if x.PtrU3 != nil {
		var full [8]byte
		binary.LittleEndian.PutUint64(full[:], uint64((*x.PtrU3)))
		enc := full[:4]
		ptrU3At = b.WriteBytes(append(binary.LittleEndian.AppendUint32(nil, uint32(len(enc))), enc...))
		ptrU3N = 1
	}
	ptrF3At, ptrF3N := 0, 0
	if x.PtrF3 != nil {
		var full [8]byte
		binary.LittleEndian.PutUint64(full[:], uint64(math.Float32bits(float32((*x.PtrF3)))))
		enc := full[:4]
		ptrF3At = b.WriteBytes(append(binary.LittleEndian.AppendUint32(nil, uint32(len(enc))), enc...))
		ptrF3N = 1
	}
	ptrF6At, ptrF6N := 0, 0
	if x.PtrF6 != nil {
		var full [8]byte
		binary.LittleEndian.PutUint64(full[:], math.Float64bits(float64((*x.PtrF6))))
		enc := full[:8]
		ptrF6At = b.WriteBytes(append(binary.LittleEndian.AppendUint32(nil, uint32(len(enc))), enc...))
		ptrF6N = 1
	}
	ptrCAt, ptrCN := 0, 0
	if x.PtrC != nil {
		var full [8]byte
		binary.LittleEndian.PutUint64(full[:], uint64((*x.PtrC)))
		enc := full[:8]
		ptrCAt = b.WriteBytes(append(binary.LittleEndian.AppendUint32(nil, uint32(len(enc))), enc...))
		ptrCN = 1
	}
	ptrRAt, ptrRN := 0, 0
	if x.PtrR != nil {
		enc := []byte((*x.PtrR))
		ptrRAt = b.WriteBytes(append(binary.LittleEndian.AppendUint32(nil, uint32(len(enc))), enc...))
		ptrRN = 1
	}
	ob := b.StartObject(trunkSize)
	ob.SetBool(trunkBAt, bool(x.B))
	ob.SetInt8(trunkI8At, int8(x.I8))
	ob.SetInt16(trunkI16At, int16(x.I16))
	ob.SetInt32(trunkI32At, int32(x.I32))
	ob.SetInt64(trunkI64At, int64(x.I64))
	ob.SetUint8(trunkU8At, uint8(x.U8))
	ob.SetUint16(trunkU16At, uint16(x.U16))
	ob.SetUint32(trunkU32At, uint32(x.U32))
	ob.SetUint64(trunkU64At, uint64(x.U64))
	ob.SetFloat32(trunkF32At, float32(x.F32))
	ob.SetFloat64(trunkF64At, float64(x.F64))
	ob.SetUint64(trunkCAt, uint64(x.C))
	ob.SetText(trunkTextAt, string(x.Text))
	ob.SetBytes(trunkRawAt, []byte(x.Raw))
	innerLeaf, err := x.Leaf.MarshalZAP()
	if err != nil {
		return nil, err
	}
	ob.SetBytes(trunkLeafAt, innerLeaf)
	if x.PtrL != nil {
		innerPtrL, err := x.PtrL.MarshalZAP()
		if err != nil {
			return nil, err
		}
		ob.SetBytes(trunkPtrLAt, innerPtrL)
	}
	{
		eb := zap.NewBuilder(zap.HeaderSize)
		eb.StartObject(0).FinishAsRoot()
		ob.SetBytes(trunkSealAt, eb.Finish())
	}
	if ptrUN > 0 {
		ob.SetList(trunkPtrUAt, ptrUAt, ptrUN)
	}
	if ptrSN > 0 {
		ob.SetList(trunkPtrSAt, ptrSAt, ptrSN)
	}
	if ptrBN > 0 {
		ob.SetList(trunkPtrBAt, ptrBAt, ptrBN)
	}
	if numsN > 0 {
		ob.SetList(trunkNumsAt, numsAt, numsN)
	}
	if sigsN > 0 {
		ob.SetList(trunkSigsAt, sigsAt, sigsN)
	}
	if bigsN > 0 {
		ob.SetList(trunkBigsAt, bigsAt, bigsN)
	}
	if strsN > 0 {
		ob.SetList(trunkStrsAt, strsAt, strsN)
	}
	if bufsN > 0 {
		ob.SetList(trunkBufsAt, bufsAt, bufsN)
	}
	if bitsN > 0 {
		ob.SetList(trunkBitsAt, bitsAt, bitsN)
	}
	if kidsN > 0 {
		ob.SetList(trunkKidsAt, kidsAt, kidsN)
	}
	if ptrsN > 0 {
		ob.SetList(trunkPtrsAt, ptrsAt, ptrsN)
	}
	if sealsN > 0 {
		ob.SetList(trunkSealsAt, sealsAt, sealsN)
	}
	if pKidsN > 0 {
		ob.SetList(trunkPKidsAt, pKidsAt, pKidsN)
	}
	if pNumsN > 0 {
		ob.SetList(trunkPNumsAt, pNumsAt, pNumsN)
	}
	if ptrI8N > 0 {
		ob.SetList(trunkPtrI8At, ptrI8At, ptrI8N)
	}
	if ptrI6N > 0 {
		ob.SetList(trunkPtrI6At, ptrI6At, ptrI6N)
	}
	if ptrI3N > 0 {
		ob.SetList(trunkPtrI3At, ptrI3At, ptrI3N)
	}
	if ptrI4N > 0 {
		ob.SetList(trunkPtrI4At, ptrI4At, ptrI4N)
	}
	if ptrU1N > 0 {
		ob.SetList(trunkPtrU1At, ptrU1At, ptrU1N)
	}
	if ptrU6N > 0 {
		ob.SetList(trunkPtrU6At, ptrU6At, ptrU6N)
	}
	if ptrU3N > 0 {
		ob.SetList(trunkPtrU3At, ptrU3At, ptrU3N)
	}
	if ptrF3N > 0 {
		ob.SetList(trunkPtrF3At, ptrF3At, ptrF3N)
	}
	if ptrF6N > 0 {
		ob.SetList(trunkPtrF6At, ptrF6At, ptrF6N)
	}
	if ptrCN > 0 {
		ob.SetList(trunkPtrCAt, ptrCAt, ptrCN)
	}
	if ptrRN > 0 {
		ob.SetList(trunkPtrRAt, ptrRAt, ptrRN)
	}
	ob.FinishAsRoot()
	return b.Finish(), nil
}

// UnmarshalZAP reads Trunk out of the buffer that arrived.
func (x *Trunk) UnmarshalZAP(data []byte) error {
	if x == nil || len(data) == 0 {
		return nil
	}
	m, err := zap.Parse(data)
	if err != nil {
		return fmt.Errorf("Trunk: %w", err)
	}
	o := m.Root()
	x.B = bool(o.Bool(trunkBAt))
	x.I8 = int8(o.Int8(trunkI8At))
	x.I16 = int16(o.Int16(trunkI16At))
	x.I32 = int32(o.Int32(trunkI32At))
	x.I64 = int64(o.Int64(trunkI64At))
	x.U8 = uint8(o.Uint8(trunkU8At))
	x.U16 = uint16(o.Uint16(trunkU16At))
	x.U32 = uint32(o.Uint32(trunkU32At))
	x.U64 = uint64(o.Uint64(trunkU64At))
	x.F32 = float32(o.Float32(trunkF32At))
	x.F64 = float64(o.Float64(trunkF64At))
	x.C = Count(o.Uint64(trunkCAt))
	x.Text = string(strings.Clone(o.Text(trunkTextAt)))
	x.Raw = []uint8(append([]byte(nil), o.Bytes(trunkRawAt)...))
	if raw := o.Bytes(trunkLeafAt); len(raw) > 0 {
		if err := x.Leaf.UnmarshalZAP(raw); err != nil {
			return err
		}
	}
	if l := o.List(trunkPtrUAt); l.Len() > 0 {
		raw := l.BytesAt(0)
		var full [8]byte
		copy(full[:], raw)
		v := uint64(binary.LittleEndian.Uint64(full[:]))
		x.PtrU = &v
	}
	if l := o.List(trunkPtrSAt); l.Len() > 0 {
		raw := l.BytesAt(0)
		v := string(raw)
		x.PtrS = &v
	}
	if l := o.List(trunkPtrBAt); l.Len() > 0 {
		raw := l.BytesAt(0)
		v := bool(len(raw) > 0 && raw[0] != 0)
		x.PtrB = &v
	}
	if raw := o.Bytes(trunkPtrLAt); len(raw) > 0 {
		var v Leaf
		if err := v.UnmarshalZAP(raw); err != nil {
			return err
		}
		x.PtrL = &v
	}
	if l := o.List(trunkNumsAt); l.Len() > 0 {
		var rows []uint32
		l.EachBytes(func(_ int, raw []byte) bool {
			var full [8]byte
			copy(full[:], raw)
			e := uint32(binary.LittleEndian.Uint64(full[:]))
			rows = append(rows, e)
			return true
		})
		x.Nums = rows
	}
	if l := o.List(trunkSigsAt); l.Len() > 0 {
		var rows []int32
		l.EachBytes(func(_ int, raw []byte) bool {
			var full [8]byte
			copy(full[:], raw)
			e := int32(int64(binary.LittleEndian.Uint64(full[:])<<32) >> 32)
			rows = append(rows, e)
			return true
		})
		x.Sigs = rows
	}
	if l := o.List(trunkBigsAt); l.Len() > 0 {
		var rows []float64
		l.EachBytes(func(_ int, raw []byte) bool {
			var full [8]byte
			copy(full[:], raw)
			e := float64(math.Float64frombits(binary.LittleEndian.Uint64(full[:])))
			rows = append(rows, e)
			return true
		})
		x.Bigs = rows
	}
	if l := o.List(trunkStrsAt); l.Len() > 0 {
		var rows []string
		l.EachBytes(func(_ int, raw []byte) bool {
			e := string(raw)
			rows = append(rows, e)
			return true
		})
		x.Strs = rows
	}
	if l := o.List(trunkBufsAt); l.Len() > 0 {
		var rows [][]uint8
		l.EachBytes(func(_ int, raw []byte) bool {
			e := []uint8(append([]byte(nil), raw...))
			rows = append(rows, e)
			return true
		})
		x.Bufs = rows
	}
	if l := o.List(trunkBitsAt); l.Len() > 0 {
		var rows []bool
		l.EachBytes(func(_ int, raw []byte) bool {
			e := bool(len(raw) > 0 && raw[0] != 0)
			rows = append(rows, e)
			return true
		})
		x.Bits = rows
	}
	if l := o.List(trunkKidsAt); l.Len() > 0 {
		var rows []Leaf
		var ferr error
		l.EachBytes(func(_ int, raw []byte) bool {
			var e Leaf
			if ferr = e.UnmarshalZAP(raw); ferr != nil {
				return false
			}
			rows = append(rows, e)
			return true
		})
		if ferr != nil {
			return ferr
		}
		x.Kids = rows
	}
	if l := o.List(trunkPtrsAt); l.Len() > 0 {
		var rows []*Leaf
		var ferr error
		l.EachBytes(func(_ int, raw []byte) bool {
			e := new(Leaf)
			if ferr = e.UnmarshalZAP(raw); ferr != nil {
				return false
			}
			rows = append(rows, e)
			return true
		})
		if ferr != nil {
			return ferr
		}
		x.Ptrs = rows
	}
	if l := o.List(trunkSealsAt); l.Len() > 0 {
		var rows []Sealed
		l.EachBytes(func(_ int, raw []byte) bool {
			var e Sealed
			rows = append(rows, e)
			return true
		})
		x.Seals = rows
	}
	if l := o.List(trunkPKidsAt); l.Len() > 0 {
		var rows []Leaf
		var ferr error
		l.EachBytes(func(_ int, raw []byte) bool {
			var e Leaf
			if ferr = e.UnmarshalZAP(raw); ferr != nil {
				return false
			}
			rows = append(rows, e)
			return true
		})
		if ferr != nil {
			return ferr
		}
		x.PKids = &rows
	}
	if l := o.List(trunkPNumsAt); l.Len() > 0 {
		var rows []uint32
		l.EachBytes(func(_ int, raw []byte) bool {
			var full [8]byte
			copy(full[:], raw)
			e := uint32(binary.LittleEndian.Uint64(full[:]))
			rows = append(rows, e)
			return true
		})
		x.PNums = &rows
	}
	if l := o.List(trunkPtrI8At); l.Len() > 0 {
		raw := l.BytesAt(0)
		var full [8]byte
		copy(full[:], raw)
		v := int8(int64(binary.LittleEndian.Uint64(full[:])<<56) >> 56)
		x.PtrI8 = &v
	}
	if l := o.List(trunkPtrI6At); l.Len() > 0 {
		raw := l.BytesAt(0)
		var full [8]byte
		copy(full[:], raw)
		v := int16(int64(binary.LittleEndian.Uint64(full[:])<<48) >> 48)
		x.PtrI6 = &v
	}
	if l := o.List(trunkPtrI3At); l.Len() > 0 {
		raw := l.BytesAt(0)
		var full [8]byte
		copy(full[:], raw)
		v := int32(int64(binary.LittleEndian.Uint64(full[:])<<32) >> 32)
		x.PtrI3 = &v
	}
	if l := o.List(trunkPtrI4At); l.Len() > 0 {
		raw := l.BytesAt(0)
		var full [8]byte
		copy(full[:], raw)
		v := int64(int64(binary.LittleEndian.Uint64(full[:])<<0) >> 0)
		x.PtrI4 = &v
	}
	if l := o.List(trunkPtrU1At); l.Len() > 0 {
		raw := l.BytesAt(0)
		var full [8]byte
		copy(full[:], raw)
		v := uint8(binary.LittleEndian.Uint64(full[:]))
		x.PtrU1 = &v
	}
	if l := o.List(trunkPtrU6At); l.Len() > 0 {
		raw := l.BytesAt(0)
		var full [8]byte
		copy(full[:], raw)
		v := uint16(binary.LittleEndian.Uint64(full[:]))
		x.PtrU6 = &v
	}
	if l := o.List(trunkPtrU3At); l.Len() > 0 {
		raw := l.BytesAt(0)
		var full [8]byte
		copy(full[:], raw)
		v := uint32(binary.LittleEndian.Uint64(full[:]))
		x.PtrU3 = &v
	}
	if l := o.List(trunkPtrF3At); l.Len() > 0 {
		raw := l.BytesAt(0)
		var full [8]byte
		copy(full[:], raw)
		v := float32(math.Float32frombits(uint32(binary.LittleEndian.Uint64(full[:]))))
		x.PtrF3 = &v
	}
	if l := o.List(trunkPtrF6At); l.Len() > 0 {
		raw := l.BytesAt(0)
		var full [8]byte
		copy(full[:], raw)
		v := float64(math.Float64frombits(binary.LittleEndian.Uint64(full[:])))
		x.PtrF6 = &v
	}
	if l := o.List(trunkPtrCAt); l.Len() > 0 {
		raw := l.BytesAt(0)
		var full [8]byte
		copy(full[:], raw)
		v := Count(binary.LittleEndian.Uint64(full[:]))
		x.PtrC = &v
	}
	if l := o.List(trunkPtrRAt); l.Len() > 0 {
		raw := l.BytesAt(0)
		v := []uint8(append([]byte(nil), raw...))
		x.PtrR = &v
	}
	return nil
}