ledger/msgp_gen.go

package ledger

// Code generated by github.com/algorand/msgp DO NOT EDIT.

import (
	"sort"

	"github.com/algorand/msgp/msgp"

	"github.com/algorand/go-algorand/config"
	"github.com/algorand/go-algorand/data/basics"
)

// The following msgp objects are implemented in this file:
// CatchpointCatchupState
//            |-----> MarshalMsg
//            |-----> CanMarshalMsg
//            |-----> (*) UnmarshalMsg
//            |-----> (*) CanUnmarshalMsg
//            |-----> Msgsize
//            |-----> MsgIsZero
//
// CatchpointFileHeader
//           |-----> (*) MarshalMsg
//           |-----> (*) CanMarshalMsg
//           |-----> (*) UnmarshalMsg
//           |-----> (*) CanUnmarshalMsg
//           |-----> (*) Msgsize
//           |-----> (*) MsgIsZero
//
// baseAccountData
//        |-----> (*) MarshalMsg
//        |-----> (*) CanMarshalMsg
//        |-----> (*) UnmarshalMsg
//        |-----> (*) CanUnmarshalMsg
//        |-----> (*) Msgsize
//        |-----> (*) MsgIsZero
//
// baseOnlineAccountData
//           |-----> (*) MarshalMsg
//           |-----> (*) CanMarshalMsg
//           |-----> (*) UnmarshalMsg
//           |-----> (*) CanUnmarshalMsg
//           |-----> (*) Msgsize
//           |-----> (*) MsgIsZero
//
// catchpointFileBalancesChunkV5
//               |-----> (*) MarshalMsg
//               |-----> (*) CanMarshalMsg
//               |-----> (*) UnmarshalMsg
//               |-----> (*) CanUnmarshalMsg
//               |-----> (*) Msgsize
//               |-----> (*) MsgIsZero
//
// catchpointFileBalancesChunkV6
//               |-----> (*) MarshalMsg
//               |-----> (*) CanMarshalMsg
//               |-----> (*) UnmarshalMsg
//               |-----> (*) CanUnmarshalMsg
//               |-----> (*) Msgsize
//               |-----> (*) MsgIsZero
//
// catchpointState
//        |-----> MarshalMsg
//        |-----> CanMarshalMsg
//        |-----> (*) UnmarshalMsg
//        |-----> (*) CanUnmarshalMsg
//        |-----> Msgsize
//        |-----> MsgIsZero
//
// encodedBalanceRecordV5
//            |-----> (*) MarshalMsg
//            |-----> (*) CanMarshalMsg
//            |-----> (*) UnmarshalMsg
//            |-----> (*) CanUnmarshalMsg
//            |-----> (*) Msgsize
//            |-----> (*) MsgIsZero
//
// encodedBalanceRecordV6
//            |-----> (*) MarshalMsg
//            |-----> (*) CanMarshalMsg
//            |-----> (*) UnmarshalMsg
//            |-----> (*) CanUnmarshalMsg
//            |-----> (*) Msgsize
//            |-----> (*) MsgIsZero
//
// resourceFlags
//       |-----> MarshalMsg
//       |-----> CanMarshalMsg
//       |-----> (*) UnmarshalMsg
//       |-----> (*) CanUnmarshalMsg
//       |-----> Msgsize
//       |-----> MsgIsZero
//
// resourcesData
//       |-----> (*) MarshalMsg
//       |-----> (*) CanMarshalMsg
//       |-----> (*) UnmarshalMsg
//       |-----> (*) CanUnmarshalMsg
//       |-----> (*) Msgsize
//       |-----> (*) MsgIsZero
//

// MarshalMsg implements msgp.Marshaler
func (z CatchpointCatchupState) MarshalMsg(b []byte) (o []byte) {
	o = msgp.Require(b, z.Msgsize())
	o = msgp.AppendInt32(o, int32(z))
	return
}

func (_ CatchpointCatchupState) CanMarshalMsg(z interface{}) bool {
	_, ok := (z).(CatchpointCatchupState)
	if !ok {
		_, ok = (z).(*CatchpointCatchupState)
	}
	return ok
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *CatchpointCatchupState) UnmarshalMsg(bts []byte) (o []byte, err error) {
	{
		var zb0001 int32
		zb0001, bts, err = msgp.ReadInt32Bytes(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		(*z) = CatchpointCatchupState(zb0001)
	}
	o = bts
	return
}

func (_ *CatchpointCatchupState) CanUnmarshalMsg(z interface{}) bool {
	_, ok := (z).(*CatchpointCatchupState)
	return ok
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z CatchpointCatchupState) Msgsize() (s int) {
	s = msgp.Int32Size
	return
}

// MsgIsZero returns whether this is a zero value
func (z CatchpointCatchupState) MsgIsZero() bool {
	return z == 0
}

// MarshalMsg implements msgp.Marshaler
func (z *CatchpointFileHeader) MarshalMsg(b []byte) (o []byte) {
	o = msgp.Require(b, z.Msgsize())
	// omitempty: check for empty values
	zb0001Len := uint32(8)
	var zb0001Mask uint16 /* 9 bits */
	if (*z).Totals.MsgIsZero() {
		zb0001Len--
		zb0001Mask |= 0x2
	}
	if (*z).TotalAccounts == 0 {
		zb0001Len--
		zb0001Mask |= 0x4
	}
	if (*z).BalancesRound.MsgIsZero() {
		zb0001Len--
		zb0001Mask |= 0x8
	}
	if (*z).BlockHeaderDigest.MsgIsZero() {
		zb0001Len--
		zb0001Mask |= 0x10
	}
	if (*z).BlocksRound.MsgIsZero() {
		zb0001Len--
		zb0001Mask |= 0x20
	}
	if (*z).Catchpoint == "" {
		zb0001Len--
		zb0001Mask |= 0x40
	}
	if (*z).TotalChunks == 0 {
		zb0001Len--
		zb0001Mask |= 0x80
	}
	if (*z).Version == 0 {
		zb0001Len--
		zb0001Mask |= 0x100
	}
	// variable map header, size zb0001Len
	o = append(o, 0x80|uint8(zb0001Len))
	if zb0001Len != 0 {
		if (zb0001Mask & 0x2) == 0 { // if not empty
			// string "accountTotals"
			o = append(o, 0xad, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x73)
			o = (*z).Totals.MarshalMsg(o)
		}
		if (zb0001Mask & 0x4) == 0 { // if not empty
			// string "accountsCount"
			o = append(o, 0xad, 0x61, 0x63, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x73, 0x43, 0x6f, 0x75, 0x6e, 0x74)
			o = msgp.AppendUint64(o, (*z).TotalAccounts)
		}
		if (zb0001Mask & 0x8) == 0 { // if not empty
			// string "balancesRound"
			o = append(o, 0xad, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x73, 0x52, 0x6f, 0x75, 0x6e, 0x64)
			o = (*z).BalancesRound.MarshalMsg(o)
		}
		if (zb0001Mask & 0x10) == 0 { // if not empty
			// string "blockHeaderDigest"
			o = append(o, 0xb1, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x44, 0x69, 0x67, 0x65, 0x73, 0x74)
			o = (*z).BlockHeaderDigest.MarshalMsg(o)
		}
		if (zb0001Mask & 0x20) == 0 { // if not empty
			// string "blocksRound"
			o = append(o, 0xab, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x73, 0x52, 0x6f, 0x75, 0x6e, 0x64)
			o = (*z).BlocksRound.MarshalMsg(o)
		}
		if (zb0001Mask & 0x40) == 0 { // if not empty
			// string "catchpoint"
			o = append(o, 0xaa, 0x63, 0x61, 0x74, 0x63, 0x68, 0x70, 0x6f, 0x69, 0x6e, 0x74)
			o = msgp.AppendString(o, (*z).Catchpoint)
		}
		if (zb0001Mask & 0x80) == 0 { // if not empty
			// string "chunksCount"
			o = append(o, 0xab, 0x63, 0x68, 0x75, 0x6e, 0x6b, 0x73, 0x43, 0x6f, 0x75, 0x6e, 0x74)
			o = msgp.AppendUint64(o, (*z).TotalChunks)
		}
		if (zb0001Mask & 0x100) == 0 { // if not empty
			// string "version"
			o = append(o, 0xa7, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e)
			o = msgp.AppendUint64(o, (*z).Version)
		}
	}
	return
}

func (_ *CatchpointFileHeader) CanMarshalMsg(z interface{}) bool {
	_, ok := (z).(*CatchpointFileHeader)
	return ok
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *CatchpointFileHeader) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 int
	var zb0002 bool
	zb0001, zb0002, bts, err = msgp.ReadMapHeaderBytes(bts)
	if _, ok := err.(msgp.TypeError); ok {
		zb0001, zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		if zb0001 > 0 {
			zb0001--
			(*z).Version, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "Version")
				return
			}
		}
		if zb0001 > 0 {
			zb0001--
			bts, err = (*z).BalancesRound.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "BalancesRound")
				return
			}
		}
		if zb0001 > 0 {
			zb0001--
			bts, err = (*z).BlocksRound.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "BlocksRound")
				return
			}
		}
		if zb0001 > 0 {
			zb0001--
			bts, err = (*z).Totals.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "Totals")
				return
			}
		}
		if zb0001 > 0 {
			zb0001--
			(*z).TotalAccounts, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "TotalAccounts")
				return
			}
		}
		if zb0001 > 0 {
			zb0001--
			(*z).TotalChunks, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "TotalChunks")
				return
			}
		}
		if zb0001 > 0 {
			zb0001--
			(*z).Catchpoint, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "Catchpoint")
				return
			}
		}
		if zb0001 > 0 {
			zb0001--
			bts, err = (*z).BlockHeaderDigest.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "BlockHeaderDigest")
				return
			}
		}
		if zb0001 > 0 {
			err = msgp.ErrTooManyArrayFields(zb0001)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array")
				return
			}
		}
	} else {
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		if zb0002 {
			(*z) = CatchpointFileHeader{}
		}
		for zb0001 > 0 {
			zb0001--
			field, bts, err = msgp.ReadMapKeyZC(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
			switch string(field) {
			case "version":
				(*z).Version, bts, err = msgp.ReadUint64Bytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "Version")
					return
				}
			case "balancesRound":
				bts, err = (*z).BalancesRound.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "BalancesRound")
					return
				}
			case "blocksRound":
				bts, err = (*z).BlocksRound.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "BlocksRound")
					return
				}
			case "accountTotals":
				bts, err = (*z).Totals.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "Totals")
					return
				}
			case "accountsCount":
				(*z).TotalAccounts, bts, err = msgp.ReadUint64Bytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "TotalAccounts")
					return
				}
			case "chunksCount":
				(*z).TotalChunks, bts, err = msgp.ReadUint64Bytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "TotalChunks")
					return
				}
			case "catchpoint":
				(*z).Catchpoint, bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "Catchpoint")
					return
				}
			case "blockHeaderDigest":
				bts, err = (*z).BlockHeaderDigest.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "BlockHeaderDigest")
					return
				}
			default:
				err = msgp.ErrNoField(string(field))
				if err != nil {
					err = msgp.WrapError(err)
					return
				}
			}
		}
	}
	o = bts
	return
}

func (_ *CatchpointFileHeader) CanUnmarshalMsg(z interface{}) bool {
	_, ok := (z).(*CatchpointFileHeader)
	return ok
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *CatchpointFileHeader) Msgsize() (s int) {
	s = 1 + 8 + msgp.Uint64Size + 14 + (*z).BalancesRound.Msgsize() + 12 + (*z).BlocksRound.Msgsize() + 14 + (*z).Totals.Msgsize() + 14 + msgp.Uint64Size + 12 + msgp.Uint64Size + 11 + msgp.StringPrefixSize + len((*z).Catchpoint) + 18 + (*z).BlockHeaderDigest.Msgsize()
	return
}

// MsgIsZero returns whether this is a zero value
func (z *CatchpointFileHeader) MsgIsZero() bool {
	return ((*z).Version == 0) && ((*z).BalancesRound.MsgIsZero()) && ((*z).BlocksRound.MsgIsZero()) && ((*z).Totals.MsgIsZero()) && ((*z).TotalAccounts == 0) && ((*z).TotalChunks == 0) && ((*z).Catchpoint == "") && ((*z).BlockHeaderDigest.MsgIsZero())
}

// MarshalMsg implements msgp.Marshaler
func (z *baseAccountData) MarshalMsg(b []byte) (o []byte) {
	o = msgp.Require(b, z.Msgsize())
	// omitempty: check for empty values
	zb0001Len := uint32(19)
	var zb0001Mask uint32 /* 21 bits */
	if (*z).baseOnlineAccountData.VoteID.MsgIsZero() {
		zb0001Len--
		zb0001Mask |= 0x1
	}
	if (*z).baseOnlineAccountData.SelectionID.MsgIsZero() {
		zb0001Len--
		zb0001Mask |= 0x2
	}
	if (*z).baseOnlineAccountData.VoteFirstValid.MsgIsZero() {
		zb0001Len--
		zb0001Mask |= 0x4
	}
	if (*z).baseOnlineAccountData.VoteLastValid.MsgIsZero() {
		zb0001Len--
		zb0001Mask |= 0x8
	}
	if (*z).baseOnlineAccountData.VoteKeyDilution == 0 {
		zb0001Len--
		zb0001Mask |= 0x10
	}
	if (*z).baseOnlineAccountData.StateProofID.MsgIsZero() {
		zb0001Len--
		zb0001Mask |= 0x20
	}
	if (*z).Status.MsgIsZero() {
		zb0001Len--
		zb0001Mask |= 0x100
	}
	if (*z).MicroAlgos.MsgIsZero() {
		zb0001Len--
		zb0001Mask |= 0x200
	}
	if (*z).RewardsBase == 0 {
		zb0001Len--
		zb0001Mask |= 0x400
	}
	if (*z).RewardedMicroAlgos.MsgIsZero() {
		zb0001Len--
		zb0001Mask |= 0x800
	}
	if (*z).AuthAddr.MsgIsZero() {
		zb0001Len--
		zb0001Mask |= 0x1000
	}
	if (*z).TotalAppSchemaNumUint == 0 {
		zb0001Len--
		zb0001Mask |= 0x2000
	}
	if (*z).TotalAppSchemaNumByteSlice == 0 {
		zb0001Len--
		zb0001Mask |= 0x4000
	}
	if (*z).TotalExtraAppPages == 0 {
		zb0001Len--
		zb0001Mask |= 0x8000
	}
	if (*z).TotalAssetParams == 0 {
		zb0001Len--
		zb0001Mask |= 0x10000
	}
	if (*z).TotalAssets == 0 {
		zb0001Len--
		zb0001Mask |= 0x20000
	}
	if (*z).TotalAppParams == 0 {
		zb0001Len--
		zb0001Mask |= 0x40000
	}
	if (*z).TotalAppLocalStates == 0 {
		zb0001Len--
		zb0001Mask |= 0x80000
	}
	if (*z).UpdateRound == 0 {
		zb0001Len--
		zb0001Mask |= 0x100000
	}
	// variable map header, size zb0001Len
	o = msgp.AppendMapHeader(o, zb0001Len)
	if zb0001Len != 0 {
		if (zb0001Mask & 0x1) == 0 { // if not empty
			// string "A"
			o = append(o, 0xa1, 0x41)
			o = (*z).baseOnlineAccountData.VoteID.MarshalMsg(o)
		}
		if (zb0001Mask & 0x2) == 0 { // if not empty
			// string "B"
			o = append(o, 0xa1, 0x42)
			o = (*z).baseOnlineAccountData.SelectionID.MarshalMsg(o)
		}
		if (zb0001Mask & 0x4) == 0 { // if not empty
			// string "C"
			o = append(o, 0xa1, 0x43)
			o = (*z).baseOnlineAccountData.VoteFirstValid.MarshalMsg(o)
		}
		if (zb0001Mask & 0x8) == 0 { // if not empty
			// string "D"
			o = append(o, 0xa1, 0x44)
			o = (*z).baseOnlineAccountData.VoteLastValid.MarshalMsg(o)
		}
		if (zb0001Mask & 0x10) == 0 { // if not empty
			// string "E"
			o = append(o, 0xa1, 0x45)
			o = msgp.AppendUint64(o, (*z).baseOnlineAccountData.VoteKeyDilution)
		}
		if (zb0001Mask & 0x20) == 0 { // if not empty
			// string "F"
			o = append(o, 0xa1, 0x46)
			o = (*z).baseOnlineAccountData.StateProofID.MarshalMsg(o)
		}
		if (zb0001Mask & 0x100) == 0 { // if not empty
			// string "a"
			o = append(o, 0xa1, 0x61)
			o = (*z).Status.MarshalMsg(o)
		}
		if (zb0001Mask & 0x200) == 0 { // if not empty
			// string "b"
			o = append(o, 0xa1, 0x62)
			o = (*z).MicroAlgos.MarshalMsg(o)
		}
		if (zb0001Mask & 0x400) == 0 { // if not empty
			// string "c"
			o = append(o, 0xa1, 0x63)
			o = msgp.AppendUint64(o, (*z).RewardsBase)
		}
		if (zb0001Mask & 0x800) == 0 { // if not empty
			// string "d"
			o = append(o, 0xa1, 0x64)
			o = (*z).RewardedMicroAlgos.MarshalMsg(o)
		}
		if (zb0001Mask & 0x1000) == 0 { // if not empty
			// string "e"
			o = append(o, 0xa1, 0x65)
			o = (*z).AuthAddr.MarshalMsg(o)
		}
		if (zb0001Mask & 0x2000) == 0 { // if not empty
			// string "f"
			o = append(o, 0xa1, 0x66)
			o = msgp.AppendUint64(o, (*z).TotalAppSchemaNumUint)
		}
		if (zb0001Mask & 0x4000) == 0 { // if not empty
			// string "g"
			o = append(o, 0xa1, 0x67)
			o = msgp.AppendUint64(o, (*z).TotalAppSchemaNumByteSlice)
		}
		if (zb0001Mask & 0x8000) == 0 { // if not empty
			// string "h"
			o = append(o, 0xa1, 0x68)
			o = msgp.AppendUint32(o, (*z).TotalExtraAppPages)
		}
		if (zb0001Mask & 0x10000) == 0 { // if not empty
			// string "i"
			o = append(o, 0xa1, 0x69)
			o = msgp.AppendUint64(o, (*z).TotalAssetParams)
		}
		if (zb0001Mask & 0x20000) == 0 { // if not empty
			// string "j"
			o = append(o, 0xa1, 0x6a)
			o = msgp.AppendUint64(o, (*z).TotalAssets)
		}
		if (zb0001Mask & 0x40000) == 0 { // if not empty
			// string "k"
			o = append(o, 0xa1, 0x6b)
			o = msgp.AppendUint64(o, (*z).TotalAppParams)
		}
		if (zb0001Mask & 0x80000) == 0 { // if not empty
			// string "l"
			o = append(o, 0xa1, 0x6c)
			o = msgp.AppendUint64(o, (*z).TotalAppLocalStates)
		}
		if (zb0001Mask & 0x100000) == 0 { // if not empty
			// string "z"
			o = append(o, 0xa1, 0x7a)
			o = msgp.AppendUint64(o, (*z).UpdateRound)
		}
	}
	return
}

func (_ *baseAccountData) CanMarshalMsg(z interface{}) bool {
	_, ok := (z).(*baseAccountData)
	return ok
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *baseAccountData) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 int
	var zb0002 bool
	zb0001, zb0002, bts, err = msgp.ReadMapHeaderBytes(bts)
	if _, ok := err.(msgp.TypeError); ok {
		zb0001, zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		if zb0001 > 0 {
			zb0001--
			bts, err = (*z).Status.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "Status")
				return
			}
		}
		if zb0001 > 0 {
			zb0001--
			bts, err = (*z).MicroAlgos.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "MicroAlgos")
				return
			}
		}
		if zb0001 > 0 {
			zb0001--
			(*z).RewardsBase, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "RewardsBase")
				return
			}
		}
		if zb0001 > 0 {
			zb0001--
			bts, err = (*z).RewardedMicroAlgos.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "RewardedMicroAlgos")
				return
			}
		}
		if zb0001 > 0 {
			zb0001--
			bts, err = (*z).AuthAddr.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "AuthAddr")
				return
			}
		}
		if zb0001 > 0 {
			zb0001--
			(*z).TotalAppSchemaNumUint, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "TotalAppSchemaNumUint")
				return
			}
		}
		if zb0001 > 0 {
			zb0001--
			(*z).TotalAppSchemaNumByteSlice, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "TotalAppSchemaNumByteSlice")
				return
			}
		}
		if zb0001 > 0 {
			zb0001--
			(*z).TotalExtraAppPages, bts, err = msgp.ReadUint32Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "TotalExtraAppPages")
				return
			}
		}
		if zb0001 > 0 {
			zb0001--
			(*z).TotalAssetParams, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "TotalAssetParams")
				return
			}
		}
		if zb0001 > 0 {
			zb0001--
			(*z).TotalAssets, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "TotalAssets")
				return
			}
		}
		if zb0001 > 0 {
			zb0001--
			(*z).TotalAppParams, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "TotalAppParams")
				return
			}
		}
		if zb0001 > 0 {
			zb0001--
			(*z).TotalAppLocalStates, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "TotalAppLocalStates")
				return
			}
		}
		if zb0001 > 0 {
			zb0001--
			bts, err = (*z).baseOnlineAccountData.VoteID.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "VoteID")
				return
			}
		}
		if zb0001 > 0 {
			zb0001--
			bts, err = (*z).baseOnlineAccountData.SelectionID.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "SelectionID")
				return
			}
		}
		if zb0001 > 0 {
			zb0001--
			bts, err = (*z).baseOnlineAccountData.VoteFirstValid.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "VoteFirstValid")
				return
			}
		}
		if zb0001 > 0 {
			zb0001--
			bts, err = (*z).baseOnlineAccountData.VoteLastValid.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "VoteLastValid")
				return
			}
		}
		if zb0001 > 0 {
			zb0001--
			(*z).baseOnlineAccountData.VoteKeyDilution, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "VoteKeyDilution")
				return
			}
		}
		if zb0001 > 0 {
			zb0001--
			bts, err = (*z).baseOnlineAccountData.StateProofID.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "StateProofID")
				return
			}
		}
		if zb0001 > 0 {
			zb0001--
			(*z).UpdateRound, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "UpdateRound")
				return
			}
		}
		if zb0001 > 0 {
			err = msgp.ErrTooManyArrayFields(zb0001)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array")
				return
			}
		}
	} else {
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		if zb0002 {
			(*z) = baseAccountData{}
		}
		for zb0001 > 0 {
			zb0001--
			field, bts, err = msgp.ReadMapKeyZC(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
			switch string(field) {
			case "a":
				bts, err = (*z).Status.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "Status")
					return
				}
			case "b":
				bts, err = (*z).MicroAlgos.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "MicroAlgos")
					return
				}
			case "c":
				(*z).RewardsBase, bts, err = msgp.ReadUint64Bytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "RewardsBase")
					return
				}
			case "d":
				bts, err = (*z).RewardedMicroAlgos.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "RewardedMicroAlgos")
					return
				}
			case "e":
				bts, err = (*z).AuthAddr.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "AuthAddr")
					return
				}
			case "f":
				(*z).TotalAppSchemaNumUint, bts, err = msgp.ReadUint64Bytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "TotalAppSchemaNumUint")
					return
				}
			case "g":
				(*z).TotalAppSchemaNumByteSlice, bts, err = msgp.ReadUint64Bytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "TotalAppSchemaNumByteSlice")
					return
				}
			case "h":
				(*z).TotalExtraAppPages, bts, err = msgp.ReadUint32Bytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "TotalExtraAppPages")
					return
				}
			case "i":
				(*z).TotalAssetParams, bts, err = msgp.ReadUint64Bytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "TotalAssetParams")
					return
				}
			case "j":
				(*z).TotalAssets, bts, err = msgp.ReadUint64Bytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "TotalAssets")
					return
				}
			case "k":
				(*z).TotalAppParams, bts, err = msgp.ReadUint64Bytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "TotalAppParams")
					return
				}
			case "l":
				(*z).TotalAppLocalStates, bts, err = msgp.ReadUint64Bytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "TotalAppLocalStates")
					return
				}
			case "A":
				bts, err = (*z).baseOnlineAccountData.VoteID.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "VoteID")
					return
				}
			case "B":
				bts, err = (*z).baseOnlineAccountData.SelectionID.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "SelectionID")
					return
				}
			case "C":
				bts, err = (*z).baseOnlineAccountData.VoteFirstValid.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "VoteFirstValid")
					return
				}
			case "D":
				bts, err = (*z).baseOnlineAccountData.VoteLastValid.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "VoteLastValid")
					return
				}
			case "E":
				(*z).baseOnlineAccountData.VoteKeyDilution, bts, err = msgp.ReadUint64Bytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "VoteKeyDilution")
					return
				}
			case "F":
				bts, err = (*z).baseOnlineAccountData.StateProofID.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "StateProofID")
					return
				}
			case "z":
				(*z).UpdateRound, bts, err = msgp.ReadUint64Bytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "UpdateRound")
					return
				}
			default:
				err = msgp.ErrNoField(string(field))
				if err != nil {
					err = msgp.WrapError(err)
					return
				}
			}
		}
	}
	o = bts
	return
}

func (_ *baseAccountData) CanUnmarshalMsg(z interface{}) bool {
	_, ok := (z).(*baseAccountData)
	return ok
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *baseAccountData) Msgsize() (s int) {
	s = 3 + 2 + (*z).Status.Msgsize() + 2 + (*z).MicroAlgos.Msgsize() + 2 + msgp.Uint64Size + 2 + (*z).RewardedMicroAlgos.Msgsize() + 2 + (*z).AuthAddr.Msgsize() + 2 + msgp.Uint64Size + 2 + msgp.Uint64Size + 2 + msgp.Uint32Size + 2 + msgp.Uint64Size + 2 + msgp.Uint64Size + 2 + msgp.Uint64Size + 2 + msgp.Uint64Size + 2 + (*z).baseOnlineAccountData.VoteID.Msgsize() + 2 + (*z).baseOnlineAccountData.SelectionID.Msgsize() + 2 + (*z).baseOnlineAccountData.VoteFirstValid.Msgsize() + 2 + (*z).baseOnlineAccountData.VoteLastValid.Msgsize() + 2 + msgp.Uint64Size + 2 + (*z).baseOnlineAccountData.StateProofID.Msgsize() + 2 + msgp.Uint64Size
	return
}

// MsgIsZero returns whether this is a zero value
func (z *baseAccountData) MsgIsZero() bool {
	return ((*z).Status.MsgIsZero()) && ((*z).MicroAlgos.MsgIsZero()) && ((*z).RewardsBase == 0) && ((*z).RewardedMicroAlgos.MsgIsZero()) && ((*z).AuthAddr.MsgIsZero()) && ((*z).TotalAppSchemaNumUint == 0) && ((*z).TotalAppSchemaNumByteSlice == 0) && ((*z).TotalExtraAppPages == 0) && ((*z).TotalAssetParams == 0) && ((*z).TotalAssets == 0) && ((*z).TotalAppParams == 0) && ((*z).TotalAppLocalStates == 0) && ((*z).baseOnlineAccountData.VoteID.MsgIsZero()) && ((*z).baseOnlineAccountData.SelectionID.MsgIsZero()) && ((*z).baseOnlineAccountData.VoteFirstValid.MsgIsZero()) && ((*z).baseOnlineAccountData.VoteLastValid.MsgIsZero()) && ((*z).baseOnlineAccountData.VoteKeyDilution == 0) && ((*z).baseOnlineAccountData.StateProofID.MsgIsZero()) && ((*z).UpdateRound == 0)
}

// MarshalMsg implements msgp.Marshaler
func (z *baseOnlineAccountData) MarshalMsg(b []byte) (o []byte) {
	o = msgp.Require(b, z.Msgsize())
	// omitempty: check for empty values
	zb0001Len := uint32(6)
	var zb0001Mask uint8 /* 7 bits */
	if (*z).VoteID.MsgIsZero() {
		zb0001Len--
		zb0001Mask |= 0x1
	}
	if (*z).SelectionID.MsgIsZero() {
		zb0001Len--
		zb0001Mask |= 0x2
	}
	if (*z).VoteFirstValid.MsgIsZero() {
		zb0001Len--
		zb0001Mask |= 0x4
	}
	if (*z).VoteLastValid.MsgIsZero() {
		zb0001Len--
		zb0001Mask |= 0x8
	}
	if (*z).VoteKeyDilution == 0 {
		zb0001Len--
		zb0001Mask |= 0x10
	}
	if (*z).StateProofID.MsgIsZero() {
		zb0001Len--
		zb0001Mask |= 0x20
	}
	// variable map header, size zb0001Len
	o = append(o, 0x80|uint8(zb0001Len))
	if zb0001Len != 0 {
		if (zb0001Mask & 0x1) == 0 { // if not empty
			// string "A"
			o = append(o, 0xa1, 0x41)
			o = (*z).VoteID.MarshalMsg(o)
		}
		if (zb0001Mask & 0x2) == 0 { // if not empty
			// string "B"
			o = append(o, 0xa1, 0x42)
			o = (*z).SelectionID.MarshalMsg(o)
		}
		if (zb0001Mask & 0x4) == 0 { // if not empty
			// string "C"
			o = append(o, 0xa1, 0x43)
			o = (*z).VoteFirstValid.MarshalMsg(o)
		}
		if (zb0001Mask & 0x8) == 0 { // if not empty
			// string "D"
			o = append(o, 0xa1, 0x44)
			o = (*z).VoteLastValid.MarshalMsg(o)
		}
		if (zb0001Mask & 0x10) == 0 { // if not empty
			// string "E"
			o = append(o, 0xa1, 0x45)
			o = msgp.AppendUint64(o, (*z).VoteKeyDilution)
		}
		if (zb0001Mask & 0x20) == 0 { // if not empty
			// string "F"
			o = append(o, 0xa1, 0x46)
			o = (*z).StateProofID.MarshalMsg(o)
		}
	}
	return
}

func (_ *baseOnlineAccountData) CanMarshalMsg(z interface{}) bool {
	_, ok := (z).(*baseOnlineAccountData)
	return ok
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *baseOnlineAccountData) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 int
	var zb0002 bool
	zb0001, zb0002, bts, err = msgp.ReadMapHeaderBytes(bts)
	if _, ok := err.(msgp.TypeError); ok {
		zb0001, zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		if zb0001 > 0 {
			zb0001--
			bts, err = (*z).VoteID.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "VoteID")
				return
			}
		}
		if zb0001 > 0 {
			zb0001--
			bts, err = (*z).SelectionID.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "SelectionID")
				return
			}
		}
		if zb0001 > 0 {
			zb0001--
			bts, err = (*z).VoteFirstValid.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "VoteFirstValid")
				return
			}
		}
		if zb0001 > 0 {
			zb0001--
			bts, err = (*z).VoteLastValid.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "VoteLastValid")
				return
			}
		}
		if zb0001 > 0 {
			zb0001--
			(*z).VoteKeyDilution, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "VoteKeyDilution")
				return
			}
		}
		if zb0001 > 0 {
			zb0001--
			bts, err = (*z).StateProofID.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "StateProofID")
				return
			}
		}
		if zb0001 > 0 {
			err = msgp.ErrTooManyArrayFields(zb0001)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array")
				return
			}
		}
	} else {
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		if zb0002 {
			(*z) = baseOnlineAccountData{}
		}
		for zb0001 > 0 {
			zb0001--
			field, bts, err = msgp.ReadMapKeyZC(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
			switch string(field) {
			case "A":
				bts, err = (*z).VoteID.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "VoteID")
					return
				}
			case "B":
				bts, err = (*z).SelectionID.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "SelectionID")
					return
				}
			case "C":
				bts, err = (*z).VoteFirstValid.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "VoteFirstValid")
					return
				}
			case "D":
				bts, err = (*z).VoteLastValid.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "VoteLastValid")
					return
				}
			case "E":
				(*z).VoteKeyDilution, bts, err = msgp.ReadUint64Bytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "VoteKeyDilution")
					return
				}
			case "F":
				bts, err = (*z).StateProofID.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "StateProofID")
					return
				}
			default:
				err = msgp.ErrNoField(string(field))
				if err != nil {
					err = msgp.WrapError(err)
					return
				}
			}
		}
	}
	o = bts
	return
}

func (_ *baseOnlineAccountData) CanUnmarshalMsg(z interface{}) bool {
	_, ok := (z).(*baseOnlineAccountData)
	return ok
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *baseOnlineAccountData) Msgsize() (s int) {
	s = 1 + 2 + (*z).VoteID.Msgsize() + 2 + (*z).SelectionID.Msgsize() + 2 + (*z).VoteFirstValid.Msgsize() + 2 + (*z).VoteLastValid.Msgsize() + 2 + msgp.Uint64Size + 2 + (*z).StateProofID.Msgsize()
	return
}

// MsgIsZero returns whether this is a zero value
func (z *baseOnlineAccountData) MsgIsZero() bool {
	return ((*z).VoteID.MsgIsZero()) && ((*z).SelectionID.MsgIsZero()) && ((*z).VoteFirstValid.MsgIsZero()) && ((*z).VoteLastValid.MsgIsZero()) && ((*z).VoteKeyDilution == 0) && ((*z).StateProofID.MsgIsZero())
}

// MarshalMsg implements msgp.Marshaler
func (z *catchpointFileBalancesChunkV5) MarshalMsg(b []byte) (o []byte) {
	o = msgp.Require(b, z.Msgsize())
	// omitempty: check for empty values
	zb0002Len := uint32(1)
	var zb0002Mask uint8 /* 2 bits */
	if len((*z).Balances) == 0 {
		zb0002Len--
		zb0002Mask |= 0x2
	}
	// variable map header, size zb0002Len
	o = append(o, 0x80|uint8(zb0002Len))
	if zb0002Len != 0 {
		if (zb0002Mask & 0x2) == 0 { // if not empty
			// string "bl"
			o = append(o, 0xa2, 0x62, 0x6c)
			if (*z).Balances == nil {
				o = msgp.AppendNil(o)
			} else {
				o = msgp.AppendArrayHeader(o, uint32(len((*z).Balances)))
			}
			for zb0001 := range (*z).Balances {
				// omitempty: check for empty values
				zb0003Len := uint32(2)
				var zb0003Mask uint8 /* 3 bits */
				if (*z).Balances[zb0001].AccountData.MsgIsZero() {
					zb0003Len--
					zb0003Mask |= 0x2
				}
				if (*z).Balances[zb0001].Address.MsgIsZero() {
					zb0003Len--
					zb0003Mask |= 0x4
				}
				// variable map header, size zb0003Len
				o = append(o, 0x80|uint8(zb0003Len))
				if (zb0003Mask & 0x2) == 0 { // if not empty
					// string "ad"
					o = append(o, 0xa2, 0x61, 0x64)
					o = (*z).Balances[zb0001].AccountData.MarshalMsg(o)
				}
				if (zb0003Mask & 0x4) == 0 { // if not empty
					// string "pk"
					o = append(o, 0xa2, 0x70, 0x6b)
					o = (*z).Balances[zb0001].Address.MarshalMsg(o)
				}
			}
		}
	}
	return
}

func (_ *catchpointFileBalancesChunkV5) CanMarshalMsg(z interface{}) bool {
	_, ok := (z).(*catchpointFileBalancesChunkV5)
	return ok
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *catchpointFileBalancesChunkV5) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0002 int
	var zb0003 bool
	zb0002, zb0003, bts, err = msgp.ReadMapHeaderBytes(bts)
	if _, ok := err.(msgp.TypeError); ok {
		zb0002, zb0003, bts, err = msgp.ReadArrayHeaderBytes(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		if zb0002 > 0 {
			zb0002--
			var zb0004 int
			var zb0005 bool
			zb0004, zb0005, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "Balances")
				return
			}
			if zb0004 > BalancesPerCatchpointFileChunk {
				err = msgp.ErrOverflow(uint64(zb0004), uint64(BalancesPerCatchpointFileChunk))
				err = msgp.WrapError(err, "struct-from-array", "Balances")
				return
			}
			if zb0005 {
				(*z).Balances = nil
			} else if (*z).Balances != nil && cap((*z).Balances) >= zb0004 {
				(*z).Balances = ((*z).Balances)[:zb0004]
			} else {
				(*z).Balances = make([]encodedBalanceRecordV5, zb0004)
			}
			for zb0001 := range (*z).Balances {
				var zb0006 int
				var zb0007 bool
				zb0006, zb0007, bts, err = msgp.ReadMapHeaderBytes(bts)
				if _, ok := err.(msgp.TypeError); ok {
					zb0006, zb0007, bts, err = msgp.ReadArrayHeaderBytes(bts)
					if err != nil {
						err = msgp.WrapError(err, "struct-from-array", "Balances", zb0001)
						return
					}
					if zb0006 > 0 {
						zb0006--
						bts, err = (*z).Balances[zb0001].Address.UnmarshalMsg(bts)
						if err != nil {
							err = msgp.WrapError(err, "struct-from-array", "Balances", zb0001, "struct-from-array", "Address")
							return
						}
					}
					if zb0006 > 0 {
						zb0006--
						bts, err = (*z).Balances[zb0001].AccountData.UnmarshalMsg(bts)
						if err != nil {
							err = msgp.WrapError(err, "struct-from-array", "Balances", zb0001, "struct-from-array", "AccountData")
							return
						}
					}
					if zb0006 > 0 {
						err = msgp.ErrTooManyArrayFields(zb0006)
						if err != nil {
							err = msgp.WrapError(err, "struct-from-array", "Balances", zb0001, "struct-from-array")
							return
						}
					}
				} else {
					if err != nil {
						err = msgp.WrapError(err, "struct-from-array", "Balances", zb0001)
						return
					}
					if zb0007 {
						(*z).Balances[zb0001] = encodedBalanceRecordV5{}
					}
					for zb0006 > 0 {
						zb0006--
						field, bts, err = msgp.ReadMapKeyZC(bts)
						if err != nil {
							err = msgp.WrapError(err, "struct-from-array", "Balances", zb0001)
							return
						}
						switch string(field) {
						case "pk":
							bts, err = (*z).Balances[zb0001].Address.UnmarshalMsg(bts)
							if err != nil {
								err = msgp.WrapError(err, "struct-from-array", "Balances", zb0001, "Address")
								return
							}
						case "ad":
							bts, err = (*z).Balances[zb0001].AccountData.UnmarshalMsg(bts)
							if err != nil {
								err = msgp.WrapError(err, "struct-from-array", "Balances", zb0001, "AccountData")
								return
							}
						default:
							err = msgp.ErrNoField(string(field))
							if err != nil {
								err = msgp.WrapError(err, "struct-from-array", "Balances", zb0001)
								return
							}
						}
					}
				}
			}
		}
		if zb0002 > 0 {
			err = msgp.ErrTooManyArrayFields(zb0002)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array")
				return
			}
		}
	} else {
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		if zb0003 {
			(*z) = catchpointFileBalancesChunkV5{}
		}
		for zb0002 > 0 {
			zb0002--
			field, bts, err = msgp.ReadMapKeyZC(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
			switch string(field) {
			case "bl":
				var zb0008 int
				var zb0009 bool
				zb0008, zb0009, bts, err = msgp.ReadArrayHeaderBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "Balances")
					return
				}
				if zb0008 > BalancesPerCatchpointFileChunk {
					err = msgp.ErrOverflow(uint64(zb0008), uint64(BalancesPerCatchpointFileChunk))
					err = msgp.WrapError(err, "Balances")
					return
				}
				if zb0009 {
					(*z).Balances = nil
				} else if (*z).Balances != nil && cap((*z).Balances) >= zb0008 {
					(*z).Balances = ((*z).Balances)[:zb0008]
				} else {
					(*z).Balances = make([]encodedBalanceRecordV5, zb0008)
				}
				for zb0001 := range (*z).Balances {
					var zb0010 int
					var zb0011 bool
					zb0010, zb0011, bts, err = msgp.ReadMapHeaderBytes(bts)
					if _, ok := err.(msgp.TypeError); ok {
						zb0010, zb0011, bts, err = msgp.ReadArrayHeaderBytes(bts)
						if err != nil {
							err = msgp.WrapError(err, "Balances", zb0001)
							return
						}
						if zb0010 > 0 {
							zb0010--
							bts, err = (*z).Balances[zb0001].Address.UnmarshalMsg(bts)
							if err != nil {
								err = msgp.WrapError(err, "Balances", zb0001, "struct-from-array", "Address")
								return
							}
						}
						if zb0010 > 0 {
							zb0010--
							bts, err = (*z).Balances[zb0001].AccountData.UnmarshalMsg(bts)
							if err != nil {
								err = msgp.WrapError(err, "Balances", zb0001, "struct-from-array", "AccountData")
								return
							}
						}
						if zb0010 > 0 {
							err = msgp.ErrTooManyArrayFields(zb0010)
							if err != nil {
								err = msgp.WrapError(err, "Balances", zb0001, "struct-from-array")
								return
							}
						}
					} else {
						if err != nil {
							err = msgp.WrapError(err, "Balances", zb0001)
							return
						}
						if zb0011 {
							(*z).Balances[zb0001] = encodedBalanceRecordV5{}
						}
						for zb0010 > 0 {
							zb0010--
							field, bts, err = msgp.ReadMapKeyZC(bts)
							if err != nil {
								err = msgp.WrapError(err, "Balances", zb0001)
								return
							}
							switch string(field) {
							case "pk":
								bts, err = (*z).Balances[zb0001].Address.UnmarshalMsg(bts)
								if err != nil {
									err = msgp.WrapError(err, "Balances", zb0001, "Address")
									return
								}
							case "ad":
								bts, err = (*z).Balances[zb0001].AccountData.UnmarshalMsg(bts)
								if err != nil {
									err = msgp.WrapError(err, "Balances", zb0001, "AccountData")
									return
								}
							default:
								err = msgp.ErrNoField(string(field))
								if err != nil {
									err = msgp.WrapError(err, "Balances", zb0001)
									return
								}
							}
						}
					}
				}
			default:
				err = msgp.ErrNoField(string(field))
				if err != nil {
					err = msgp.WrapError(err)
					return
				}
			}
		}
	}
	o = bts
	return
}

func (_ *catchpointFileBalancesChunkV5) CanUnmarshalMsg(z interface{}) bool {
	_, ok := (z).(*catchpointFileBalancesChunkV5)
	return ok
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *catchpointFileBalancesChunkV5) Msgsize() (s int) {
	s = 1 + 3 + msgp.ArrayHeaderSize
	for zb0001 := range (*z).Balances {
		s += 1 + 3 + (*z).Balances[zb0001].Address.Msgsize() + 3 + (*z).Balances[zb0001].AccountData.Msgsize()
	}
	return
}

// MsgIsZero returns whether this is a zero value
func (z *catchpointFileBalancesChunkV5) MsgIsZero() bool {
	return (len((*z).Balances) == 0)
}

// MarshalMsg implements msgp.Marshaler
func (z *catchpointFileBalancesChunkV6) MarshalMsg(b []byte) (o []byte) {
	o = msgp.Require(b, z.Msgsize())
	// omitempty: check for empty values
	zb0002Len := uint32(1)
	var zb0002Mask uint8 /* 2 bits */
	if len((*z).Balances) == 0 {
		zb0002Len--
		zb0002Mask |= 0x2
	}
	// variable map header, size zb0002Len
	o = append(o, 0x80|uint8(zb0002Len))
	if zb0002Len != 0 {
		if (zb0002Mask & 0x2) == 0 { // if not empty
			// string "bl"
			o = append(o, 0xa2, 0x62, 0x6c)
			if (*z).Balances == nil {
				o = msgp.AppendNil(o)
			} else {
				o = msgp.AppendArrayHeader(o, uint32(len((*z).Balances)))
			}
			for zb0001 := range (*z).Balances {
				o = (*z).Balances[zb0001].MarshalMsg(o)
			}
		}
	}
	return
}

func (_ *catchpointFileBalancesChunkV6) CanMarshalMsg(z interface{}) bool {
	_, ok := (z).(*catchpointFileBalancesChunkV6)
	return ok
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *catchpointFileBalancesChunkV6) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0002 int
	var zb0003 bool
	zb0002, zb0003, bts, err = msgp.ReadMapHeaderBytes(bts)
	if _, ok := err.(msgp.TypeError); ok {
		zb0002, zb0003, bts, err = msgp.ReadArrayHeaderBytes(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		if zb0002 > 0 {
			zb0002--
			var zb0004 int
			var zb0005 bool
			zb0004, zb0005, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "Balances")
				return
			}
			if zb0004 > BalancesPerCatchpointFileChunk {
				err = msgp.ErrOverflow(uint64(zb0004), uint64(BalancesPerCatchpointFileChunk))
				err = msgp.WrapError(err, "struct-from-array", "Balances")
				return
			}
			if zb0005 {
				(*z).Balances = nil
			} else if (*z).Balances != nil && cap((*z).Balances) >= zb0004 {
				(*z).Balances = ((*z).Balances)[:zb0004]
			} else {
				(*z).Balances = make([]encodedBalanceRecordV6, zb0004)
			}
			for zb0001 := range (*z).Balances {
				bts, err = (*z).Balances[zb0001].UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "struct-from-array", "Balances", zb0001)
					return
				}
			}
		}
		if zb0002 > 0 {
			err = msgp.ErrTooManyArrayFields(zb0002)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array")
				return
			}
		}
	} else {
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		if zb0003 {
			(*z) = catchpointFileBalancesChunkV6{}
		}
		for zb0002 > 0 {
			zb0002--
			field, bts, err = msgp.ReadMapKeyZC(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
			switch string(field) {
			case "bl":
				var zb0006 int
				var zb0007 bool
				zb0006, zb0007, bts, err = msgp.ReadArrayHeaderBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "Balances")
					return
				}
				if zb0006 > BalancesPerCatchpointFileChunk {
					err = msgp.ErrOverflow(uint64(zb0006), uint64(BalancesPerCatchpointFileChunk))
					err = msgp.WrapError(err, "Balances")
					return
				}
				if zb0007 {
					(*z).Balances = nil
				} else if (*z).Balances != nil && cap((*z).Balances) >= zb0006 {
					(*z).Balances = ((*z).Balances)[:zb0006]
				} else {
					(*z).Balances = make([]encodedBalanceRecordV6, zb0006)
				}
				for zb0001 := range (*z).Balances {
					bts, err = (*z).Balances[zb0001].UnmarshalMsg(bts)
					if err != nil {
						err = msgp.WrapError(err, "Balances", zb0001)
						return
					}
				}
			default:
				err = msgp.ErrNoField(string(field))
				if err != nil {
					err = msgp.WrapError(err)
					return
				}
			}
		}
	}
	o = bts
	return
}

func (_ *catchpointFileBalancesChunkV6) CanUnmarshalMsg(z interface{}) bool {
	_, ok := (z).(*catchpointFileBalancesChunkV6)
	return ok
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *catchpointFileBalancesChunkV6) Msgsize() (s int) {
	s = 1 + 3 + msgp.ArrayHeaderSize
	for zb0001 := range (*z).Balances {
		s += (*z).Balances[zb0001].Msgsize()
	}
	return
}

// MsgIsZero returns whether this is a zero value
func (z *catchpointFileBalancesChunkV6) MsgIsZero() bool {
	return (len((*z).Balances) == 0)
}

// MarshalMsg implements msgp.Marshaler
func (z catchpointState) MarshalMsg(b []byte) (o []byte) {
	o = msgp.Require(b, z.Msgsize())
	o = msgp.AppendString(o, string(z))
	return
}

func (_ catchpointState) CanMarshalMsg(z interface{}) bool {
	_, ok := (z).(catchpointState)
	if !ok {
		_, ok = (z).(*catchpointState)
	}
	return ok
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *catchpointState) UnmarshalMsg(bts []byte) (o []byte, err error) {
	{
		var zb0001 string
		zb0001, bts, err = msgp.ReadStringBytes(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		(*z) = catchpointState(zb0001)
	}
	o = bts
	return
}

func (_ *catchpointState) CanUnmarshalMsg(z interface{}) bool {
	_, ok := (z).(*catchpointState)
	return ok
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z catchpointState) Msgsize() (s int) {
	s = msgp.StringPrefixSize + len(string(z))
	return
}

// MsgIsZero returns whether this is a zero value
func (z catchpointState) MsgIsZero() bool {
	return z == ""
}

// MarshalMsg implements msgp.Marshaler
func (z *encodedBalanceRecordV5) MarshalMsg(b []byte) (o []byte) {
	o = msgp.Require(b, z.Msgsize())
	// omitempty: check for empty values
	zb0001Len := uint32(2)
	var zb0001Mask uint8 /* 3 bits */
	if (*z).AccountData.MsgIsZero() {
		zb0001Len--
		zb0001Mask |= 0x2
	}
	if (*z).Address.MsgIsZero() {
		zb0001Len--
		zb0001Mask |= 0x4
	}
	// variable map header, size zb0001Len
	o = append(o, 0x80|uint8(zb0001Len))
	if zb0001Len != 0 {
		if (zb0001Mask & 0x2) == 0 { // if not empty
			// string "ad"
			o = append(o, 0xa2, 0x61, 0x64)
			o = (*z).AccountData.MarshalMsg(o)
		}
		if (zb0001Mask & 0x4) == 0 { // if not empty
			// string "pk"
			o = append(o, 0xa2, 0x70, 0x6b)
			o = (*z).Address.MarshalMsg(o)
		}
	}
	return
}

func (_ *encodedBalanceRecordV5) CanMarshalMsg(z interface{}) bool {
	_, ok := (z).(*encodedBalanceRecordV5)
	return ok
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *encodedBalanceRecordV5) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 int
	var zb0002 bool
	zb0001, zb0002, bts, err = msgp.ReadMapHeaderBytes(bts)
	if _, ok := err.(msgp.TypeError); ok {
		zb0001, zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		if zb0001 > 0 {
			zb0001--
			bts, err = (*z).Address.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "Address")
				return
			}
		}
		if zb0001 > 0 {
			zb0001--
			bts, err = (*z).AccountData.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "AccountData")
				return
			}
		}
		if zb0001 > 0 {
			err = msgp.ErrTooManyArrayFields(zb0001)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array")
				return
			}
		}
	} else {
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		if zb0002 {
			(*z) = encodedBalanceRecordV5{}
		}
		for zb0001 > 0 {
			zb0001--
			field, bts, err = msgp.ReadMapKeyZC(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
			switch string(field) {
			case "pk":
				bts, err = (*z).Address.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "Address")
					return
				}
			case "ad":
				bts, err = (*z).AccountData.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "AccountData")
					return
				}
			default:
				err = msgp.ErrNoField(string(field))
				if err != nil {
					err = msgp.WrapError(err)
					return
				}
			}
		}
	}
	o = bts
	return
}

func (_ *encodedBalanceRecordV5) CanUnmarshalMsg(z interface{}) bool {
	_, ok := (z).(*encodedBalanceRecordV5)
	return ok
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *encodedBalanceRecordV5) Msgsize() (s int) {
	s = 1 + 3 + (*z).Address.Msgsize() + 3 + (*z).AccountData.Msgsize()
	return
}

// MsgIsZero returns whether this is a zero value
func (z *encodedBalanceRecordV5) MsgIsZero() bool {
	return ((*z).Address.MsgIsZero()) && ((*z).AccountData.MsgIsZero())
}

// MarshalMsg implements msgp.Marshaler
func (z *encodedBalanceRecordV6) MarshalMsg(b []byte) (o []byte) {
	o = msgp.Require(b, z.Msgsize())
	// omitempty: check for empty values
	zb0003Len := uint32(3)
	var zb0003Mask uint8 /* 4 bits */
	if (*z).Address.MsgIsZero() {
		zb0003Len--
		zb0003Mask |= 0x2
	}
	if (*z).AccountData.MsgIsZero() {
		zb0003Len--
		zb0003Mask |= 0x4
	}
	if len((*z).Resources) == 0 {
		zb0003Len--
		zb0003Mask |= 0x8
	}
	// variable map header, size zb0003Len
	o = append(o, 0x80|uint8(zb0003Len))
	if zb0003Len != 0 {
		if (zb0003Mask & 0x2) == 0 { // if not empty
			// string "a"
			o = append(o, 0xa1, 0x61)
			o = (*z).Address.MarshalMsg(o)
		}
		if (zb0003Mask & 0x4) == 0 { // if not empty
			// string "b"
			o = append(o, 0xa1, 0x62)
			o = (*z).AccountData.MarshalMsg(o)
		}
		if (zb0003Mask & 0x8) == 0 { // if not empty
			// string "c"
			o = append(o, 0xa1, 0x63)
			if (*z).Resources == nil {
				o = msgp.AppendNil(o)
			} else {
				o = msgp.AppendMapHeader(o, uint32(len((*z).Resources)))
			}
			zb0001_keys := make([]uint64, 0, len((*z).Resources))
			for zb0001 := range (*z).Resources {
				zb0001_keys = append(zb0001_keys, zb0001)
			}
			sort.Sort(SortUint64(zb0001_keys))
			for _, zb0001 := range zb0001_keys {
				zb0002 := (*z).Resources[zb0001]
				_ = zb0002
				o = msgp.AppendUint64(o, zb0001)
				o = zb0002.MarshalMsg(o)
			}
		}
	}
	return
}

func (_ *encodedBalanceRecordV6) CanMarshalMsg(z interface{}) bool {
	_, ok := (z).(*encodedBalanceRecordV6)
	return ok
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *encodedBalanceRecordV6) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0003 int
	var zb0004 bool
	zb0003, zb0004, bts, err = msgp.ReadMapHeaderBytes(bts)
	if _, ok := err.(msgp.TypeError); ok {
		zb0003, zb0004, bts, err = msgp.ReadArrayHeaderBytes(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		if zb0003 > 0 {
			zb0003--
			bts, err = (*z).Address.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "Address")
				return
			}
		}
		if zb0003 > 0 {
			zb0003--
			bts, err = (*z).AccountData.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "AccountData")
				return
			}
		}
		if zb0003 > 0 {
			zb0003--
			var zb0005 int
			var zb0006 bool
			zb0005, zb0006, bts, err = msgp.ReadMapHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "Resources")
				return
			}
			if zb0005 > basics.MaxEncodedAccountDataSize {
				err = msgp.ErrOverflow(uint64(zb0005), uint64(basics.MaxEncodedAccountDataSize))
				err = msgp.WrapError(err, "struct-from-array", "Resources")
				return
			}
			if zb0006 {
				(*z).Resources = nil
			} else if (*z).Resources == nil {
				(*z).Resources = make(map[uint64]msgp.Raw, zb0005)
			}
			for zb0005 > 0 {
				var zb0001 uint64
				var zb0002 msgp.Raw
				zb0005--
				zb0001, bts, err = msgp.ReadUint64Bytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "struct-from-array", "Resources")
					return
				}
				bts, err = zb0002.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "struct-from-array", "Resources", zb0001)
					return
				}
				(*z).Resources[zb0001] = zb0002
			}
		}
		if zb0003 > 0 {
			err = msgp.ErrTooManyArrayFields(zb0003)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array")
				return
			}
		}
	} else {
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		if zb0004 {
			(*z) = encodedBalanceRecordV6{}
		}
		for zb0003 > 0 {
			zb0003--
			field, bts, err = msgp.ReadMapKeyZC(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
			switch string(field) {
			case "a":
				bts, err = (*z).Address.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "Address")
					return
				}
			case "b":
				bts, err = (*z).AccountData.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "AccountData")
					return
				}
			case "c":
				var zb0007 int
				var zb0008 bool
				zb0007, zb0008, bts, err = msgp.ReadMapHeaderBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "Resources")
					return
				}
				if zb0007 > basics.MaxEncodedAccountDataSize {
					err = msgp.ErrOverflow(uint64(zb0007), uint64(basics.MaxEncodedAccountDataSize))
					err = msgp.WrapError(err, "Resources")
					return
				}
				if zb0008 {
					(*z).Resources = nil
				} else if (*z).Resources == nil {
					(*z).Resources = make(map[uint64]msgp.Raw, zb0007)
				}
				for zb0007 > 0 {
					var zb0001 uint64
					var zb0002 msgp.Raw
					zb0007--
					zb0001, bts, err = msgp.ReadUint64Bytes(bts)
					if err != nil {
						err = msgp.WrapError(err, "Resources")
						return
					}
					bts, err = zb0002.UnmarshalMsg(bts)
					if err != nil {
						err = msgp.WrapError(err, "Resources", zb0001)
						return
					}
					(*z).Resources[zb0001] = zb0002
				}
			default:
				err = msgp.ErrNoField(string(field))
				if err != nil {
					err = msgp.WrapError(err)
					return
				}
			}
		}
	}
	o = bts
	return
}

func (_ *encodedBalanceRecordV6) CanUnmarshalMsg(z interface{}) bool {
	_, ok := (z).(*encodedBalanceRecordV6)
	return ok
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *encodedBalanceRecordV6) Msgsize() (s int) {
	s = 1 + 2 + (*z).Address.Msgsize() + 2 + (*z).AccountData.Msgsize() + 2 + msgp.MapHeaderSize
	if (*z).Resources != nil {
		for zb0001, zb0002 := range (*z).Resources {
			_ = zb0001
			_ = zb0002
			s += 0 + msgp.Uint64Size + zb0002.Msgsize()
		}
	}
	return
}

// MsgIsZero returns whether this is a zero value
func (z *encodedBalanceRecordV6) MsgIsZero() bool {
	return ((*z).Address.MsgIsZero()) && ((*z).AccountData.MsgIsZero()) && (len((*z).Resources) == 0)
}

// MarshalMsg implements msgp.Marshaler
func (z resourceFlags) MarshalMsg(b []byte) (o []byte) {
	o = msgp.Require(b, z.Msgsize())
	o = msgp.AppendUint8(o, uint8(z))
	return
}

func (_ resourceFlags) CanMarshalMsg(z interface{}) bool {
	_, ok := (z).(resourceFlags)
	if !ok {
		_, ok = (z).(*resourceFlags)
	}
	return ok
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *resourceFlags) UnmarshalMsg(bts []byte) (o []byte, err error) {
	{
		var zb0001 uint8
		zb0001, bts, err = msgp.ReadUint8Bytes(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		(*z) = resourceFlags(zb0001)
	}
	o = bts
	return
}

func (_ *resourceFlags) CanUnmarshalMsg(z interface{}) bool {
	_, ok := (z).(*resourceFlags)
	return ok
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z resourceFlags) Msgsize() (s int) {
	s = msgp.Uint8Size
	return
}

// MsgIsZero returns whether this is a zero value
func (z resourceFlags) MsgIsZero() bool {
	return z == 0
}

// MarshalMsg implements msgp.Marshaler
func (z *resourcesData) MarshalMsg(b []byte) (o []byte) {
	o = msgp.Require(b, z.Msgsize())
	// omitempty: check for empty values
	zb0002Len := uint32(26)
	var zb0002Mask uint32 /* 27 bits */
	if (*z).Total == 0 {
		zb0002Len--
		zb0002Mask |= 0x2
	}
	if (*z).Decimals == 0 {
		zb0002Len--
		zb0002Mask |= 0x4
	}
	if (*z).DefaultFrozen == false {
		zb0002Len--
		zb0002Mask |= 0x8
	}
	if (*z).UnitName == "" {
		zb0002Len--
		zb0002Mask |= 0x10
	}
	if (*z).AssetName == "" {
		zb0002Len--
		zb0002Mask |= 0x20
	}
	if (*z).URL == "" {
		zb0002Len--
		zb0002Mask |= 0x40
	}
	if (*z).MetadataHash == ([32]byte{}) {
		zb0002Len--
		zb0002Mask |= 0x80
	}
	if (*z).Manager.MsgIsZero() {
		zb0002Len--
		zb0002Mask |= 0x100
	}
	if (*z).Reserve.MsgIsZero() {
		zb0002Len--
		zb0002Mask |= 0x200
	}
	if (*z).Freeze.MsgIsZero() {
		zb0002Len--
		zb0002Mask |= 0x400
	}
	if (*z).Clawback.MsgIsZero() {
		zb0002Len--
		zb0002Mask |= 0x800
	}
	if (*z).Amount == 0 {
		zb0002Len--
		zb0002Mask |= 0x1000
	}
	if (*z).Frozen == false {
		zb0002Len--
		zb0002Mask |= 0x2000
	}
	if (*z).SchemaNumUint == 0 {
		zb0002Len--
		zb0002Mask |= 0x4000
	}
	if (*z).SchemaNumByteSlice == 0 {
		zb0002Len--
		zb0002Mask |= 0x8000
	}
	if (*z).KeyValue.MsgIsZero() {
		zb0002Len--
		zb0002Mask |= 0x10000
	}
	if len((*z).ApprovalProgram) == 0 {
		zb0002Len--
		zb0002Mask |= 0x20000
	}
	if len((*z).ClearStateProgram) == 0 {
		zb0002Len--
		zb0002Mask |= 0x40000
	}
	if (*z).GlobalState.MsgIsZero() {
		zb0002Len--
		zb0002Mask |= 0x80000
	}
	if (*z).LocalStateSchemaNumUint == 0 {
		zb0002Len--
		zb0002Mask |= 0x100000
	}
	if (*z).LocalStateSchemaNumByteSlice == 0 {
		zb0002Len--
		zb0002Mask |= 0x200000
	}
	if (*z).GlobalStateSchemaNumUint == 0 {
		zb0002Len--
		zb0002Mask |= 0x400000
	}
	if (*z).GlobalStateSchemaNumByteSlice == 0 {
		zb0002Len--
		zb0002Mask |= 0x800000
	}
	if (*z).ExtraProgramPages == 0 {
		zb0002Len--
		zb0002Mask |= 0x1000000
	}
	if (*z).ResourceFlags == 0 {
		zb0002Len--
		zb0002Mask |= 0x2000000
	}
	if (*z).UpdateRound == 0 {
		zb0002Len--
		zb0002Mask |= 0x4000000
	}
	// variable map header, size zb0002Len
	o = msgp.AppendMapHeader(o, zb0002Len)
	if zb0002Len != 0 {
		if (zb0002Mask & 0x2) == 0 { // if not empty
			// string "a"
			o = append(o, 0xa1, 0x61)
			o = msgp.AppendUint64(o, (*z).Total)
		}
		if (zb0002Mask & 0x4) == 0 { // if not empty
			// string "b"
			o = append(o, 0xa1, 0x62)
			o = msgp.AppendUint32(o, (*z).Decimals)
		}
		if (zb0002Mask & 0x8) == 0 { // if not empty
			// string "c"
			o = append(o, 0xa1, 0x63)
			o = msgp.AppendBool(o, (*z).DefaultFrozen)
		}
		if (zb0002Mask & 0x10) == 0 { // if not empty
			// string "d"
			o = append(o, 0xa1, 0x64)
			o = msgp.AppendString(o, (*z).UnitName)
		}
		if (zb0002Mask & 0x20) == 0 { // if not empty
			// string "e"
			o = append(o, 0xa1, 0x65)
			o = msgp.AppendString(o, (*z).AssetName)
		}
		if (zb0002Mask & 0x40) == 0 { // if not empty
			// string "f"
			o = append(o, 0xa1, 0x66)
			o = msgp.AppendString(o, (*z).URL)
		}
		if (zb0002Mask & 0x80) == 0 { // if not empty
			// string "g"
			o = append(o, 0xa1, 0x67)
			o = msgp.AppendBytes(o, ((*z).MetadataHash)[:])
		}
		if (zb0002Mask & 0x100) == 0 { // if not empty
			// string "h"
			o = append(o, 0xa1, 0x68)
			o = (*z).Manager.MarshalMsg(o)
		}
		if (zb0002Mask & 0x200) == 0 { // if not empty
			// string "i"
			o = append(o, 0xa1, 0x69)
			o = (*z).Reserve.MarshalMsg(o)
		}
		if (zb0002Mask & 0x400) == 0 { // if not empty
			// string "j"
			o = append(o, 0xa1, 0x6a)
			o = (*z).Freeze.MarshalMsg(o)
		}
		if (zb0002Mask & 0x800) == 0 { // if not empty
			// string "k"
			o = append(o, 0xa1, 0x6b)
			o = (*z).Clawback.MarshalMsg(o)
		}
		if (zb0002Mask & 0x1000) == 0 { // if not empty
			// string "l"
			o = append(o, 0xa1, 0x6c)
			o = msgp.AppendUint64(o, (*z).Amount)
		}
		if (zb0002Mask & 0x2000) == 0 { // if not empty
			// string "m"
			o = append(o, 0xa1, 0x6d)
			o = msgp.AppendBool(o, (*z).Frozen)
		}
		if (zb0002Mask & 0x4000) == 0 { // if not empty
			// string "n"
			o = append(o, 0xa1, 0x6e)
			o = msgp.AppendUint64(o, (*z).SchemaNumUint)
		}
		if (zb0002Mask & 0x8000) == 0 { // if not empty
			// string "o"
			o = append(o, 0xa1, 0x6f)
			o = msgp.AppendUint64(o, (*z).SchemaNumByteSlice)
		}
		if (zb0002Mask & 0x10000) == 0 { // if not empty
			// string "p"
			o = append(o, 0xa1, 0x70)
			o = (*z).KeyValue.MarshalMsg(o)
		}
		if (zb0002Mask & 0x20000) == 0 { // if not empty
			// string "q"
			o = append(o, 0xa1, 0x71)
			o = msgp.AppendBytes(o, (*z).ApprovalProgram)
		}
		if (zb0002Mask & 0x40000) == 0 { // if not empty
			// string "r"
			o = append(o, 0xa1, 0x72)
			o = msgp.AppendBytes(o, (*z).ClearStateProgram)
		}
		if (zb0002Mask & 0x80000) == 0 { // if not empty
			// string "s"
			o = append(o, 0xa1, 0x73)
			o = (*z).GlobalState.MarshalMsg(o)
		}
		if (zb0002Mask & 0x100000) == 0 { // if not empty
			// string "t"
			o = append(o, 0xa1, 0x74)
			o = msgp.AppendUint64(o, (*z).LocalStateSchemaNumUint)
		}
		if (zb0002Mask & 0x200000) == 0 { // if not empty
			// string "u"
			o = append(o, 0xa1, 0x75)
			o = msgp.AppendUint64(o, (*z).LocalStateSchemaNumByteSlice)
		}
		if (zb0002Mask & 0x400000) == 0 { // if not empty
			// string "v"
			o = append(o, 0xa1, 0x76)
			o = msgp.AppendUint64(o, (*z).GlobalStateSchemaNumUint)
		}
		if (zb0002Mask & 0x800000) == 0 { // if not empty
			// string "w"
			o = append(o, 0xa1, 0x77)
			o = msgp.AppendUint64(o, (*z).GlobalStateSchemaNumByteSlice)
		}
		if (zb0002Mask & 0x1000000) == 0 { // if not empty
			// string "x"
			o = append(o, 0xa1, 0x78)
			o = msgp.AppendUint32(o, (*z).ExtraProgramPages)
		}
		if (zb0002Mask & 0x2000000) == 0 { // if not empty
			// string "y"
			o = append(o, 0xa1, 0x79)
			o = msgp.AppendUint8(o, uint8((*z).ResourceFlags))
		}
		if (zb0002Mask & 0x4000000) == 0 { // if not empty
			// string "z"
			o = append(o, 0xa1, 0x7a)
			o = msgp.AppendUint64(o, (*z).UpdateRound)
		}
	}
	return
}

func (_ *resourcesData) CanMarshalMsg(z interface{}) bool {
	_, ok := (z).(*resourcesData)
	return ok
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *resourcesData) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0002 int
	var zb0003 bool
	zb0002, zb0003, bts, err = msgp.ReadMapHeaderBytes(bts)
	if _, ok := err.(msgp.TypeError); ok {
		zb0002, zb0003, bts, err = msgp.ReadArrayHeaderBytes(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		if zb0002 > 0 {
			zb0002--
			(*z).Total, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "Total")
				return
			}
		}
		if zb0002 > 0 {
			zb0002--
			(*z).Decimals, bts, err = msgp.ReadUint32Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "Decimals")
				return
			}
		}
		if zb0002 > 0 {
			zb0002--
			(*z).DefaultFrozen, bts, err = msgp.ReadBoolBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "DefaultFrozen")
				return
			}
		}
		if zb0002 > 0 {
			zb0002--
			(*z).UnitName, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "UnitName")
				return
			}
		}
		if zb0002 > 0 {
			zb0002--
			(*z).AssetName, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "AssetName")
				return
			}
		}
		if zb0002 > 0 {
			zb0002--
			(*z).URL, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "URL")
				return
			}
		}
		if zb0002 > 0 {
			zb0002--
			bts, err = msgp.ReadExactBytes(bts, ((*z).MetadataHash)[:])
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "MetadataHash")
				return
			}
		}
		if zb0002 > 0 {
			zb0002--
			bts, err = (*z).Manager.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "Manager")
				return
			}
		}
		if zb0002 > 0 {
			zb0002--
			bts, err = (*z).Reserve.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "Reserve")
				return
			}
		}
		if zb0002 > 0 {
			zb0002--
			bts, err = (*z).Freeze.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "Freeze")
				return
			}
		}
		if zb0002 > 0 {
			zb0002--
			bts, err = (*z).Clawback.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "Clawback")
				return
			}
		}
		if zb0002 > 0 {
			zb0002--
			(*z).Amount, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "Amount")
				return
			}
		}
		if zb0002 > 0 {
			zb0002--
			(*z).Frozen, bts, err = msgp.ReadBoolBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "Frozen")
				return
			}
		}
		if zb0002 > 0 {
			zb0002--
			(*z).SchemaNumUint, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "SchemaNumUint")
				return
			}
		}
		if zb0002 > 0 {
			zb0002--
			(*z).SchemaNumByteSlice, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "SchemaNumByteSlice")
				return
			}
		}
		if zb0002 > 0 {
			zb0002--
			bts, err = (*z).KeyValue.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "KeyValue")
				return
			}
		}
		if zb0002 > 0 {
			zb0002--
			var zb0004 int
			zb0004, err = msgp.ReadBytesBytesHeader(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "ApprovalProgram")
				return
			}
			if zb0004 > config.MaxAvailableAppProgramLen {
				err = msgp.ErrOverflow(uint64(zb0004), uint64(config.MaxAvailableAppProgramLen))
				return
			}
			(*z).ApprovalProgram, bts, err = msgp.ReadBytesBytes(bts, (*z).ApprovalProgram)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "ApprovalProgram")
				return
			}
		}
		if zb0002 > 0 {
			zb0002--
			var zb0005 int
			zb0005, err = msgp.ReadBytesBytesHeader(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "ClearStateProgram")
				return
			}
			if zb0005 > config.MaxAvailableAppProgramLen {
				err = msgp.ErrOverflow(uint64(zb0005), uint64(config.MaxAvailableAppProgramLen))
				return
			}
			(*z).ClearStateProgram, bts, err = msgp.ReadBytesBytes(bts, (*z).ClearStateProgram)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "ClearStateProgram")
				return
			}
		}
		if zb0002 > 0 {
			zb0002--
			bts, err = (*z).GlobalState.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "GlobalState")
				return
			}
		}
		if zb0002 > 0 {
			zb0002--
			(*z).LocalStateSchemaNumUint, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "LocalStateSchemaNumUint")
				return
			}
		}
		if zb0002 > 0 {
			zb0002--
			(*z).LocalStateSchemaNumByteSlice, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "LocalStateSchemaNumByteSlice")
				return
			}
		}
		if zb0002 > 0 {
			zb0002--
			(*z).GlobalStateSchemaNumUint, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "GlobalStateSchemaNumUint")
				return
			}
		}
		if zb0002 > 0 {
			zb0002--
			(*z).GlobalStateSchemaNumByteSlice, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "GlobalStateSchemaNumByteSlice")
				return
			}
		}
		if zb0002 > 0 {
			zb0002--
			(*z).ExtraProgramPages, bts, err = msgp.ReadUint32Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "ExtraProgramPages")
				return
			}
		}
		if zb0002 > 0 {
			zb0002--
			{
				var zb0006 uint8
				zb0006, bts, err = msgp.ReadUint8Bytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "struct-from-array", "ResourceFlags")
					return
				}
				(*z).ResourceFlags = resourceFlags(zb0006)
			}
		}
		if zb0002 > 0 {
			zb0002--
			(*z).UpdateRound, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array", "UpdateRound")
				return
			}
		}
		if zb0002 > 0 {
			err = msgp.ErrTooManyArrayFields(zb0002)
			if err != nil {
				err = msgp.WrapError(err, "struct-from-array")
				return
			}
		}
	} else {
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		if zb0003 {
			(*z) = resourcesData{}
		}
		for zb0002 > 0 {
			zb0002--
			field, bts, err = msgp.ReadMapKeyZC(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
			switch string(field) {
			case "a":
				(*z).Total, bts, err = msgp.ReadUint64Bytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "Total")
					return
				}
			case "b":
				(*z).Decimals, bts, err = msgp.ReadUint32Bytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "Decimals")
					return
				}
			case "c":
				(*z).DefaultFrozen, bts, err = msgp.ReadBoolBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "DefaultFrozen")
					return
				}
			case "d":
				(*z).UnitName, bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "UnitName")
					return
				}
			case "e":
				(*z).AssetName, bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "AssetName")
					return
				}
			case "f":
				(*z).URL, bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "URL")
					return
				}
			case "g":
				bts, err = msgp.ReadExactBytes(bts, ((*z).MetadataHash)[:])
				if err != nil {
					err = msgp.WrapError(err, "MetadataHash")
					return
				}
			case "h":
				bts, err = (*z).Manager.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "Manager")
					return
				}
			case "i":
				bts, err = (*z).Reserve.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "Reserve")
					return
				}
			case "j":
				bts, err = (*z).Freeze.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "Freeze")
					return
				}
			case "k":
				bts, err = (*z).Clawback.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "Clawback")
					return
				}
			case "l":
				(*z).Amount, bts, err = msgp.ReadUint64Bytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "Amount")
					return
				}
			case "m":
				(*z).Frozen, bts, err = msgp.ReadBoolBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "Frozen")
					return
				}
			case "n":
				(*z).SchemaNumUint, bts, err = msgp.ReadUint64Bytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "SchemaNumUint")
					return
				}
			case "o":
				(*z).SchemaNumByteSlice, bts, err = msgp.ReadUint64Bytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "SchemaNumByteSlice")
					return
				}
			case "p":
				bts, err = (*z).KeyValue.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "KeyValue")
					return
				}
			case "q":
				var zb0007 int
				zb0007, err = msgp.ReadBytesBytesHeader(bts)
				if err != nil {
					err = msgp.WrapError(err, "ApprovalProgram")
					return
				}
				if zb0007 > config.MaxAvailableAppProgramLen {
					err = msgp.ErrOverflow(uint64(zb0007), uint64(config.MaxAvailableAppProgramLen))
					return
				}
				(*z).ApprovalProgram, bts, err = msgp.ReadBytesBytes(bts, (*z).ApprovalProgram)
				if err != nil {
					err = msgp.WrapError(err, "ApprovalProgram")
					return
				}
			case "r":
				var zb0008 int
				zb0008, err = msgp.ReadBytesBytesHeader(bts)
				if err != nil {
					err = msgp.WrapError(err, "ClearStateProgram")
					return
				}
				if zb0008 > config.MaxAvailableAppProgramLen {
					err = msgp.ErrOverflow(uint64(zb0008), uint64(config.MaxAvailableAppProgramLen))
					return
				}
				(*z).ClearStateProgram, bts, err = msgp.ReadBytesBytes(bts, (*z).ClearStateProgram)
				if err != nil {
					err = msgp.WrapError(err, "ClearStateProgram")
					return
				}
			case "s":
				bts, err = (*z).GlobalState.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "GlobalState")
					return
				}
			case "t":
				(*z).LocalStateSchemaNumUint, bts, err = msgp.ReadUint64Bytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "LocalStateSchemaNumUint")
					return
				}
			case "u":
				(*z).LocalStateSchemaNumByteSlice, bts, err = msgp.ReadUint64Bytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "LocalStateSchemaNumByteSlice")
					return
				}
			case "v":
				(*z).GlobalStateSchemaNumUint, bts, err = msgp.ReadUint64Bytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "GlobalStateSchemaNumUint")
					return
				}
			case "w":
				(*z).GlobalStateSchemaNumByteSlice, bts, err = msgp.ReadUint64Bytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "GlobalStateSchemaNumByteSlice")
					return
				}
			case "x":
				(*z).ExtraProgramPages, bts, err = msgp.ReadUint32Bytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "ExtraProgramPages")
					return
				}
			case "y":
				{
					var zb0009 uint8
					zb0009, bts, err = msgp.ReadUint8Bytes(bts)
					if err != nil {
						err = msgp.WrapError(err, "ResourceFlags")
						return
					}
					(*z).ResourceFlags = resourceFlags(zb0009)
				}
			case "z":
				(*z).UpdateRound, bts, err = msgp.ReadUint64Bytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "UpdateRound")
					return
				}
			default:
				err = msgp.ErrNoField(string(field))
				if err != nil {
					err = msgp.WrapError(err)
					return
				}
			}
		}
	}
	o = bts
	return
}

func (_ *resourcesData) CanUnmarshalMsg(z interface{}) bool {
	_, ok := (z).(*resourcesData)
	return ok
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *resourcesData) Msgsize() (s int) {
	s = 3 + 2 + msgp.Uint64Size + 2 + msgp.Uint32Size + 2 + msgp.BoolSize + 2 + msgp.StringPrefixSize + len((*z).UnitName) + 2 + msgp.StringPrefixSize + len((*z).AssetName) + 2 + msgp.StringPrefixSize + len((*z).URL) + 2 + msgp.ArrayHeaderSize + (32 * (msgp.ByteSize)) + 2 + (*z).Manager.Msgsize() + 2 + (*z).Reserve.Msgsize() + 2 + (*z).Freeze.Msgsize() + 2 + (*z).Clawback.Msgsize() + 2 + msgp.Uint64Size + 2 + msgp.BoolSize + 2 + msgp.Uint64Size + 2 + msgp.Uint64Size + 2 + (*z).KeyValue.Msgsize() + 2 + msgp.BytesPrefixSize + len((*z).ApprovalProgram) + 2 + msgp.BytesPrefixSize + len((*z).ClearStateProgram) + 2 + (*z).GlobalState.Msgsize() + 2 + msgp.Uint64Size + 2 + msgp.Uint64Size + 2 + msgp.Uint64Size + 2 + msgp.Uint64Size + 2 + msgp.Uint32Size + 2 + msgp.Uint8Size + 2 + msgp.Uint64Size
	return
}

// MsgIsZero returns whether this is a zero value
func (z *resourcesData) MsgIsZero() bool {
	return ((*z).Total == 0) && ((*z).Decimals == 0) && ((*z).DefaultFrozen == false) && ((*z).UnitName == "") && ((*z).AssetName == "") && ((*z).URL == "") && ((*z).MetadataHash == ([32]byte{})) && ((*z).Manager.MsgIsZero()) && ((*z).Reserve.MsgIsZero()) && ((*z).Freeze.MsgIsZero()) && ((*z).Clawback.MsgIsZero()) && ((*z).Amount == 0) && ((*z).Frozen == false) && ((*z).SchemaNumUint == 0) && ((*z).SchemaNumByteSlice == 0) && ((*z).KeyValue.MsgIsZero()) && (len((*z).ApprovalProgram) == 0) && (len((*z).ClearStateProgram) == 0) && ((*z).GlobalState.MsgIsZero()) && ((*z).LocalStateSchemaNumUint == 0) && ((*z).LocalStateSchemaNumByteSlice == 0) && ((*z).GlobalStateSchemaNumUint == 0) && ((*z).GlobalStateSchemaNumByteSlice == 0) && ((*z).ExtraProgramPages == 0) && ((*z).ResourceFlags == 0) && ((*z).UpdateRound == 0)
}