// Deprecated: EncodeMsg implements msgp.Encodable
431297
func (z interval16) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 2
	// write "start"
	err = en.Append(0x82, 0xa5, 0x73, 0x74, 0x61, 0x72, 0x74)
	if err != nil {
		return err
	}
	err = en.WriteUint16(z.start)
	if err != nil {
		return
	}
	// write "last"
	err = en.Append(0xa4, 0x6c, 0x61, 0x73, 0x74)
	if err != nil {
		return err
	}
	err = en.WriteUint16(z.last())
	if err != nil {
		return
	}
	return
}
1053249
func (n *Notification) EncodeMsg(w *msgp.Writer) error {
	var bm msgp.Encodable

	if n.Body != nil {
		var ok bool
		bm, ok = n.Body.(msgp.Encodable)
		if !ok {
			return ErrNotEncodable
		}
	}

	var err error

	if err = w.WriteArrayHeader(NotificationPackSize); err != nil {
		return err
	}

	if err = w.WriteInt(NotificationType); err != nil {
		return err
	}

	if err = w.WriteString(n.Method); err != nil {
		return err
	}

	// No body to encode. Write a zero-length params array.
	if bm == nil {
		return w.WriteArrayHeader(0)
	}

	// 1-item array containing the body.
	if err = w.WriteArrayHeader(1); err != nil {
		return err
	}

	return msgp.Encode(w, bm)
}
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
}
210693
func (z SeriesListForPickle) EncodeMsg(en *msgp.Writer) (err error) {
	err = en.WriteArrayHeader(uint32(len(z)))
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0003 := range z {
		err = z[zb0003].EncodeMsg(en)
		if err != nil {
			err = msgp.WrapError(err, zb0003)
			return
		}
	}
	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
}
524435
func MsgPackEncode(b *[]byte, in interface{}) error {
	return codec.NewEncoderBytes(b, MsgpackHandle).Encode(in)
}
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
}
241486
func (z *arrayContainer) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 1
	// write "content"
	err = en.Append(0x81, 0xa7, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74)
	if err != nil {
		return err
	}
	err = en.WriteArrayHeader(uint32(len(z.content)))
	if err != nil {
		return
	}
	for zxvk := range z.content {
		err = en.WriteUint16(z.content[zxvk])
		if err != nil {
			return
		}
	}
	return
}
790171
func (p *Buffer) EncodeMessage(pb Message) error {
	siz := Size(pb)
	p.EncodeVarint(uint64(siz))
	return p.Marshal(pb)
}
773755
func (z *Archive) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 5
	// write "MetricDefinition"
	err = en.Append(0x85, 0xb0, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x44, 0x65, 0x66, 0x69, 0x6e, 0x69, 0x74, 0x69, 0x6f, 0x6e)
	if err != nil {
		return
	}
	err = z.MetricDefinition.EncodeMsg(en)
	if err != nil {
		err = msgp.WrapError(err, "MetricDefinition")
		return
	}
	// write "SchemaId"
	err = en.Append(0xa8, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x49, 0x64)
	if err != nil {
		return
	}
	err = en.WriteUint16(z.SchemaId)
	if err != nil {
		err = msgp.WrapError(err, "SchemaId")
		return
	}
	// write "AggId"
	err = en.Append(0xa5, 0x41, 0x67, 0x67, 0x49, 0x64)
	if err != nil {
		return
	}
	err = en.WriteUint16(z.AggId)
	if err != nil {
		err = msgp.WrapError(err, "AggId")
		return
	}
	// write "IrId"
	err = en.Append(0xa4, 0x49, 0x72, 0x49, 0x64)
	if err != nil {
		return
	}
	err = en.WriteUint16(z.IrId)
	if err != nil {
		err = msgp.WrapError(err, "IrId")
		return
	}
	// write "LastSave"
	err = en.Append(0xa8, 0x4c, 0x61, 0x73, 0x74, 0x53, 0x61, 0x76, 0x65)
	if err != nil {
		return
	}
	err = en.WriteUint32(z.LastSave)
	if err != nil {
		err = msgp.WrapError(err, "LastSave")
		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
}
904298
func (z *MetricsDeleteResp) DecodeMsg(dc *msgp.Reader) (err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, err = dc.ReadMapHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, err = dc.ReadMapKeyPtr()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "DeletedDefs":
			z.DeletedDefs, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "DeletedDefs")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				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
}
539946
func (z uint16Slice) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	o = msgp.AppendArrayHeader(o, uint32(len(z)))
	for zzpf := range z {
		o = msgp.AppendUint16(o, z[zzpf])
	}
	return
}
810086
func (z *IterGen) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 3
	// write "T0"
	err = en.Append(0x83, 0xa2, 0x54, 0x30)
	if err != nil {
		return
	}
	err = en.WriteUint32(z.T0)
	if err != nil {
		err = msgp.WrapError(err, "T0")
		return
	}
	// write "IntervalHint"
	err = en.Append(0xac, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x48, 0x69, 0x6e, 0x74)
	if err != nil {
		return
	}
	err = en.WriteUint32(z.IntervalHint)
	if err != nil {
		err = msgp.WrapError(err, "IntervalHint")
		return
	}
	// write "B"
	err = en.Append(0xa1, 0x42)
	if err != nil {
		return
	}
	err = en.WriteBytes(z.B)
	if err != nil {
		err = msgp.WrapError(err, "B")
		return
	}
	return
}
460775
func (z *arrayContainer) 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 "content":
			var zbai uint32
			zbai, err = dc.ReadArrayHeader()
			if err != nil {
				return
			}
			if cap(z.content) >= int(zbai) {
				z.content = (z.content)[:zbai]
			} else {
				z.content = make([]uint16, zbai)
			}
			for zxvk := range z.content {
				z.content[zxvk], err = dc.ReadUint16()
				if err != nil {
					return
				}
			}
		default:
			err = dc.Skip()
			if err != nil {
				return
			}
		}
	}
	return
}
734714
func (z *runIterator16) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 4
	// write "rc"
	err = en.Append(0x84, 0xa2, 0x72, 0x63)
	if err != nil {
		return err
	}
	if z.rc == nil {
		err = en.WriteNil()
		if err != nil {
			return
		}
	} else {
		err = z.rc.EncodeMsg(en)
		if err != nil {
			return
		}
	}
	// write "curIndex"
	err = en.Append(0xa8, 0x63, 0x75, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78)
	if err != nil {
		return err
	}
	err = en.WriteInt64(z.curIndex)
	if err != nil {
		return
	}
	// write "curPosInIndex"
	err = en.Append(0xad, 0x63, 0x75, 0x72, 0x50, 0x6f, 0x73, 0x49, 0x6e, 0x49, 0x6e, 0x64, 0x65, 0x78)
	if err != nil {
		return err
	}
	err = en.WriteUint16(z.curPosInIndex)
	if err != nil {
		return
	}
	// write "curSeq"
	err = en.Append(0xa6, 0x63, 0x75, 0x72, 0x53, 0x65, 0x71)
	if err != nil {
		return err
	}
	err = en.WriteInt64(z.curSeq)
	if err != nil {
		return
	}
	return
}