// Deprecated: EncodeMsg implements msgp.Encodable
188136
func (z contype) EncodeMsg(en *msgp.Writer) (err error) {
	err = en.WriteUint8(uint8(z))
	if err != nil {
		return
	}
	return
}
132180
func (z uint16Slice) EncodeMsg(en *msgp.Writer) (err error) {
	err = en.WriteArrayHeader(uint32(len(z)))
	if err != nil {
		return
	}
	for zzpf := range z {
		err = en.WriteUint16(z[zzpf])
		if err != nil {
			return
		}
	}
	return
}
558035
func (z *Key) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 3
	// string "u"
	o = append(o, 0x83, 0xa1, 0x75)
	o = msgp.AppendBytes(o, []byte(z.UUID))
	// string "v"
	o = append(o, 0xa1, 0x76)
	o, err = msgp.AppendIntf(o, z.Value)
	if err != nil {
		return
	}
	// string "p"
	o = append(o, 0xa1, 0x70)
	o = msgp.AppendBytes(o, z.Payload)
	return
}
956330
func (z *Tr) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 4
	// string "u"
	o = append(o, 0x84, 0xa1, 0x75)
	o, err = z.UUID.MarshalMsg(o)
	if err != nil {
		return
	}
	// string "c"
	o = append(o, 0xa1, 0x63)
	o = msgp.AppendInt(o, z.Count)
	// string "r"
	o = append(o, 0xa1, 0x72)
	o, err = z.Root.MarshalMsg(o)
	if err != nil {
		return
	}
	// string "nw"
	o = append(o, 0xa2, 0x6e, 0x77)
	o = msgp.AppendInt(o, z.NodeWidth)
	return
}
812888
func (z *bitmapContainer) DecodeMsg(dc *msgp.Reader) (err error) {
	var field []byte
	_ = field
	var zbzg uint32
	zbzg, err = dc.ReadMapHeader()
	if err != nil {
		return
	}
	for zbzg > 0 {
		zbzg--
		field, err = dc.ReadMapKeyPtr()
		if err != nil {
			return
		}
		switch msgp.UnsafeString(field) {
		case "cardinality":
			z.cardinality, err = dc.ReadInt()
			if err != nil {
				return
			}
		case "bitmap":
			var zbai uint32
			zbai, err = dc.ReadArrayHeader()
			if err != nil {
				return
			}
			if cap(z.bitmap) >= int(zbai) {
				z.bitmap = (z.bitmap)[:zbai]
			} else {
				z.bitmap = make([]uint64, zbai)
			}
			for zxvk := range z.bitmap {
				z.bitmap[zxvk], err = dc.ReadUint64()
				if err != nil {
					return
				}
			}
		default:
			err = dc.Skip()
			if err != nil {
				return
			}
		}
	}
	return
}
28171
func (z *roaringArray) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 4
	// write "keys"
	err = en.Append(0x84, 0xa4, 0x6b, 0x65, 0x79, 0x73)
	if err != nil {
		return err
	}
	err = en.WriteArrayHeader(uint32(len(z.keys)))
	if err != nil {
		return
	}
	for zhct := range z.keys {
		err = en.WriteUint16(z.keys[zhct])
		if err != nil {
			return
		}
	}
	// write "needCopyOnWrite"
	err = en.Append(0xaf, 0x6e, 0x65, 0x65, 0x64, 0x43, 0x6f, 0x70, 0x79, 0x4f, 0x6e, 0x57, 0x72, 0x69, 0x74, 0x65)
	if err != nil {
		return err
	}
	err = en.WriteArrayHeader(uint32(len(z.needCopyOnWrite)))
	if err != nil {
		return
	}
	for zcua := range z.needCopyOnWrite {
		err = en.WriteBool(z.needCopyOnWrite[zcua])
		if err != nil {
			return
		}
	}
	// write "copyOnWrite"
	err = en.Append(0xab, 0x63, 0x6f, 0x70, 0x79, 0x4f, 0x6e, 0x57, 0x72, 0x69, 0x74, 0x65)
	if err != nil {
		return err
	}
	err = en.WriteBool(z.copyOnWrite)
	if err != nil {
		return
	}
	// write "conserz"
	err = en.Append(0xa7, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x72, 0x7a)
	if err != nil {
		return err
	}
	err = en.WriteArrayHeader(uint32(len(z.conserz)))
	if err != nil {
		return
	}
	for zxhx := range z.conserz {
		// map header, size 2
		// write "t"
		err = en.Append(0x82, 0xa1, 0x74)
		if err != nil {
			return err
		}
		err = en.WriteUint8(uint8(z.conserz[zxhx].t))
		if err != nil {
			return
		}
		// write "r"
		err = en.Append(0xa1, 0x72)
		if err != nil {
			return err
		}
		err = z.conserz[zxhx].r.EncodeMsg(en)
		if err != nil {
			return
		}
	}
	return
}
1318723
func (z *NestOuter) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 1
	// write "inner"
	err = en.Append(0x81, 0xa5, 0x69, 0x6e, 0x6e, 0x65, 0x72)
	if err != nil {
		return
	}
	if z.Inner == nil {
		err = en.WriteNil()
		if err != nil {
			return
		}
	} else {
		// map header, size 1
		// write "hello"
		err = en.Append(0x81, 0xa5, 0x68, 0x65, 0x6c, 0x6c, 0x6f)
		if err != nil {
			return
		}
		err = en.WriteString(z.Inner.Hello)
		if err != nil {
			return
		}
	}
	return
}
893358
func (z *containerSerz) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 2
	// write "t"
	err = en.Append(0x82, 0xa1, 0x74)
	if err != nil {
		return err
	}
	err = en.WriteUint8(uint8(z.t))
	if err != nil {
		return
	}
	// write "r"
	err = en.Append(0xa1, 0x72)
	if err != nil {
		return err
	}
	err = z.r.EncodeMsg(en)
	if err != nil {
		return
	}
	return
}
320216
func (z *bitmapContainerShortIterator) DecodeMsg(dc *msgp.Reader) (err error) {
	var field []byte
	_ = field
	var zhct uint32
	zhct, err = dc.ReadMapHeader()
	if err != nil {
		return
	}
	for zhct > 0 {
		zhct--
		field, err = dc.ReadMapKeyPtr()
		if err != nil {
			return
		}
		switch msgp.UnsafeString(field) {
		case "ptr":
			if dc.IsNil() {
				err = dc.ReadNil()
				if err != nil {
					return
				}
				z.ptr = nil
			} else {
				if z.ptr == nil {
					z.ptr = new(bitmapContainer)
				}
				var zcua uint32
				zcua, err = dc.ReadMapHeader()
				if err != nil {
					return
				}
				for zcua > 0 {
					zcua--
					field, err = dc.ReadMapKeyPtr()
					if err != nil {
						return
					}
					switch msgp.UnsafeString(field) {
					case "cardinality":
						z.ptr.cardinality, err = dc.ReadInt()
						if err != nil {
							return
						}
					case "bitmap":
						var zxhx uint32
						zxhx, err = dc.ReadArrayHeader()
						if err != nil {
							return
						}
						if cap(z.ptr.bitmap) >= int(zxhx) {
							z.ptr.bitmap = (z.ptr.bitmap)[:zxhx]
						} else {
							z.ptr.bitmap = make([]uint64, zxhx)
						}
						for zwht := range z.ptr.bitmap {
							z.ptr.bitmap[zwht], err = dc.ReadUint64()
							if err != nil {
								return
							}
						}
					default:
						err = dc.Skip()
						if err != nil {
							return
						}
					}
				}
			}
		case "i":
			z.i, err = dc.ReadInt()
			if err != nil {
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				return
			}
		}
	}
	return
}
516051
func (z Entry) EncodeMsg(en *msgp.Writer) (err error) {
	// array header, size 2
	err = en.Append(0x92)
	if err != nil {
		return
	}
	err = en.WriteInt64(z.Time)
	if err != nil {
		err = msgp.WrapError(err, "Time")
		return
	}
	err = en.WriteIntf(z.Record)
	if err != nil {
		err = msgp.WrapError(err, "Record")
		return
	}
	return
}
22985
func (z *bitmapContainerShortIterator) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 2
	// write "ptr"
	err = en.Append(0x82, 0xa3, 0x70, 0x74, 0x72)
	if err != nil {
		return err
	}
	if z.ptr == nil {
		err = en.WriteNil()
		if err != nil {
			return
		}
	} else {
		// map header, size 2
		// write "cardinality"
		err = en.Append(0x82, 0xab, 0x63, 0x61, 0x72, 0x64, 0x69, 0x6e, 0x61, 0x6c, 0x69, 0x74, 0x79)
		if err != nil {
			return err
		}
		err = en.WriteInt(z.ptr.cardinality)
		if err != nil {
			return
		}
		// write "bitmap"
		err = en.Append(0xa6, 0x62, 0x69, 0x74, 0x6d, 0x61, 0x70)
		if err != nil {
			return err
		}
		err = en.WriteArrayHeader(uint32(len(z.ptr.bitmap)))
		if err != nil {
			return
		}
		for zwht := range z.ptr.bitmap {
			err = en.WriteUint64(z.ptr.bitmap[zwht])
			if err != nil {
				return
			}
		}
	}
	// write "i"
	err = en.Append(0xa1, 0x69)
	if err != nil {
		return err
	}
	err = en.WriteInt(z.i)
	if err != nil {
		return
	}
	return
}
778382
func (z *Entry) DecodeMsg(dc *msgp.Reader) (err error) {
	var zb0001 uint32
	zb0001, err = dc.ReadArrayHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if zb0001 != 2 {
		err = msgp.ArrayError{Wanted: 2, Got: zb0001}
		return
	}
	z.Time, err = dc.ReadInt64()
	if err != nil {
		err = msgp.WrapError(err, "Time")
		return
	}
	z.Record, err = dc.ReadIntf()
	if err != nil {
		err = msgp.WrapError(err, "Record")
		return
	}
	return
}
85043
func DecodeMsg(msg *pstypes.WebSocketMessage) (interface{}, error) {
	if msg == nil {
		return nil, fmt.Errorf("empty message")
	}

	switch msg.EventId {
	// Event types with a raw string Message field
	case "subscribeResp", "unsubscribeResp", "ping":
		return msg.Message, nil
	case "address":
		var am pstypes.AddressMessage
		err := json.Unmarshal([]byte(msg.Message), &am)
		return &am, err
	case "newtxs":
		var newtxs pstypes.TxList
		err := json.Unmarshal([]byte(msg.Message), &newtxs)
		return &newtxs, err
	case "newblock":
		var newblock exptypes.WebsocketBlock
		err := json.Unmarshal([]byte(msg.Message), &newblock)
		return &newblock, err
	case "mempool":
		var mpshort exptypes.MempoolShort
		err := json.Unmarshal([]byte(msg.Message), &mpshort)
		return &mpshort, err
	default:
		return nil, fmt.Errorf("unrecognized event type")
	}
}
366776
func (z MetricsDeleteResp) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 1
	// string "DeletedDefs"
	o = append(o, 0x81, 0xab, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x44, 0x65, 0x66, 0x73)
	o = msgp.AppendInt(o, z.DeletedDefs)
	return
}
783323
func (z *Row) DecodeMsg(dc *msgp.Reader) (err error) {
	var sawTopNil bool
	if dc.IsNil() {
		sawTopNil = true
		err = dc.ReadNil()
		if err != nil {
			return
		}
		dc.PushAlwaysNil()
	}

	var field []byte
	_ = field
	const maxFields2zgensym_56fd93edf47ccbd5_3 = 3

	// -- templateDecodeMsg starts here--
	var totalEncodedFields2zgensym_56fd93edf47ccbd5_3 uint32
	totalEncodedFields2zgensym_56fd93edf47ccbd5_3, err = dc.ReadMapHeader()
	if err != nil {
		return
	}
	encodedFieldsLeft2zgensym_56fd93edf47ccbd5_3 := totalEncodedFields2zgensym_56fd93edf47ccbd5_3
	missingFieldsLeft2zgensym_56fd93edf47ccbd5_3 := maxFields2zgensym_56fd93edf47ccbd5_3 - totalEncodedFields2zgensym_56fd93edf47ccbd5_3

	var nextMiss2zgensym_56fd93edf47ccbd5_3 int32 = -1
	var found2zgensym_56fd93edf47ccbd5_3 [maxFields2zgensym_56fd93edf47ccbd5_3]bool
	var curField2zgensym_56fd93edf47ccbd5_3 string

doneWithStruct2zgensym_56fd93edf47ccbd5_3:
	// First fill all the encoded fields, then
	// treat the remaining, missing fields, as Nil.
	for encodedFieldsLeft2zgensym_56fd93edf47ccbd5_3 > 0 || missingFieldsLeft2zgensym_56fd93edf47ccbd5_3 > 0 {
		//fmt.Printf("encodedFieldsLeft: %v, missingFieldsLeft: %v, found: '%v', fields: '%#v'\n", encodedFieldsLeft2zgensym_56fd93edf47ccbd5_3, missingFieldsLeft2zgensym_56fd93edf47ccbd5_3, msgp.ShowFound(found2zgensym_56fd93edf47ccbd5_3[:]), decodeMsgFieldOrder2zgensym_56fd93edf47ccbd5_3)
		if encodedFieldsLeft2zgensym_56fd93edf47ccbd5_3 > 0 {
			encodedFieldsLeft2zgensym_56fd93edf47ccbd5_3--
			field, err = dc.ReadMapKeyPtr()
			if err != nil {
				return
			}
			curField2zgensym_56fd93edf47ccbd5_3 = msgp.UnsafeString(field)
		} else {
			//missing fields need handling
			if nextMiss2zgensym_56fd93edf47ccbd5_3 < 0 {
				// tell the reader to only give us Nils
				// until further notice.
				dc.PushAlwaysNil()
				nextMiss2zgensym_56fd93edf47ccbd5_3 = 0
			}
			for nextMiss2zgensym_56fd93edf47ccbd5_3 < maxFields2zgensym_56fd93edf47ccbd5_3 && (found2zgensym_56fd93edf47ccbd5_3[nextMiss2zgensym_56fd93edf47ccbd5_3] || decodeMsgFieldSkip2zgensym_56fd93edf47ccbd5_3[nextMiss2zgensym_56fd93edf47ccbd5_3]) {
				nextMiss2zgensym_56fd93edf47ccbd5_3++
			}
			if nextMiss2zgensym_56fd93edf47ccbd5_3 == maxFields2zgensym_56fd93edf47ccbd5_3 {
				// filled all the empty fields!
				break doneWithStruct2zgensym_56fd93edf47ccbd5_3
			}
			missingFieldsLeft2zgensym_56fd93edf47ccbd5_3--
			curField2zgensym_56fd93edf47ccbd5_3 = decodeMsgFieldOrder2zgensym_56fd93edf47ccbd5_3[nextMiss2zgensym_56fd93edf47ccbd5_3]
		}
		//fmt.Printf("switching on curField: '%v'\n", curField2zgensym_56fd93edf47ccbd5_3)
		switch curField2zgensym_56fd93edf47ccbd5_3 {
		// -- templateDecodeMsg ends here --

		case "K__slc":
			found2zgensym_56fd93edf47ccbd5_3[0] = true
			var zgensym_56fd93edf47ccbd5_4 uint32
			zgensym_56fd93edf47ccbd5_4, err = dc.ReadArrayHeader()
			if err != nil {
				return
			}
			if cap(z.K) >= int(zgensym_56fd93edf47ccbd5_4) {
				z.K = (z.K)[:zgensym_56fd93edf47ccbd5_4]
			} else {
				z.K = make([]interface{}, zgensym_56fd93edf47ccbd5_4)
			}
			for zgensym_56fd93edf47ccbd5_0 := range z.K {
				z.K[zgensym_56fd93edf47ccbd5_0], err = dc.ReadIntf()
				if err != nil {
					return
				}
			}
		case "V__slc":
			found2zgensym_56fd93edf47ccbd5_3[1] = true
			var zgensym_56fd93edf47ccbd5_5 uint32
			zgensym_56fd93edf47ccbd5_5, err = dc.ReadArrayHeader()
			if err != nil {
				return
			}
			if cap(z.V) >= int(zgensym_56fd93edf47ccbd5_5) {
				z.V = (z.V)[:zgensym_56fd93edf47ccbd5_5]
			} else {
				z.V = make([]interface{}, zgensym_56fd93edf47ccbd5_5)
			}
			for zgensym_56fd93edf47ccbd5_1 := range z.V {
				z.V[zgensym_56fd93edf47ccbd5_1], err = dc.ReadIntf()
				if err != nil {
					return
				}
			}
		case "T__i64":
			found2zgensym_56fd93edf47ccbd5_3[2] = true
			z.T, err = dc.ReadInt64()
			if err != nil {
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				return
			}
		}
	}
	if nextMiss2zgensym_56fd93edf47ccbd5_3 != -1 {
		dc.PopAlwaysNil()
	}

	if sawTopNil {
		dc.PopAlwaysNil()
	}

	if p, ok := interface{}(z).(msgp.PostLoad); ok {
		p.PostLoadHook()
	}

	return
}
523274
func (z *runContainer16) DecodeMsg(dc *msgp.Reader) (err error) {
	var field []byte
	_ = field
	var zdnj uint32
	zdnj, err = dc.ReadMapHeader()
	if err != nil {
		return
	}
	for zdnj > 0 {
		zdnj--
		field, err = dc.ReadMapKeyPtr()
		if err != nil {
			return
		}
		switch msgp.UnsafeString(field) {
		case "iv":
			var zobc uint32
			zobc, err = dc.ReadArrayHeader()
			if err != nil {
				return
			}
			if cap(z.iv) >= int(zobc) {
				z.iv = (z.iv)[:zobc]
			} else {
				z.iv = make([]interval16, zobc)
			}
			for zxpk := range z.iv {
				var zsnv uint32
				zsnv, err = dc.ReadMapHeader()
				if err != nil {
					return
				}
				for zsnv > 0 {
					zsnv--
					field, err = dc.ReadMapKeyPtr()
					if err != nil {
						return
					}
					switch msgp.UnsafeString(field) {
					case "start":
						z.iv[zxpk].start, err = dc.ReadUint16()
						if err != nil {
							return
						}
					case "last":
						z.iv[zxpk].length, err = dc.ReadUint16()
						z.iv[zxpk].length -= z.iv[zxpk].start
						if err != nil {
							return
						}
					default:
						err = dc.Skip()
						if err != nil {
							return
						}
					}
				}
			}
		case "card":
			z.card, err = dc.ReadInt64()
			if err != nil {
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				return
			}
		}
	}
	return
}
603242
func (z *Person) DecodeMsg(dc *msgp.Reader) (err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, err = dc.ReadMapHeader()
	if err != nil {
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, err = dc.ReadMapKeyPtr()
		if err != nil {
			return
		}
		switch msgp.UnsafeString(field) {
		case "first":
			z.First, err = dc.ReadString()
			if err != nil {
				return
			}
		case "last":
			z.Last, err = dc.ReadString()
			if err != nil {
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				return
			}
		}
	}
	return
}