main_gen.go

package main

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

import (
	"github.com/tinylib/msgp/msgp"
)

// DecodeMsg implements msgp.Decodable
func (z *Actor) 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 "Name":
			z.Name, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Name")
				return
			}
		case "ID":
			z.ID, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "ID")
				return
			}
		case "Vor":
			z.Vor, err = dc.ReadFloat64()
			if err != nil {
				err = msgp.WrapError(err, "Vor")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z Actor) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 3
	// write "Name"
	err = en.Append(0x83, 0xa4, 0x4e, 0x61, 0x6d, 0x65)
	if err != nil {
		return
	}
	err = en.WriteString(z.Name)
	if err != nil {
		err = msgp.WrapError(err, "Name")
		return
	}
	// write "ID"
	err = en.Append(0xa2, 0x49, 0x44)
	if err != nil {
		return
	}
	err = en.WriteString(z.ID)
	if err != nil {
		err = msgp.WrapError(err, "ID")
		return
	}
	// write "Vor"
	err = en.Append(0xa3, 0x56, 0x6f, 0x72)
	if err != nil {
		return
	}
	err = en.WriteFloat64(z.Vor)
	if err != nil {
		err = msgp.WrapError(err, "Vor")
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z Actor) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 3
	// string "Name"
	o = append(o, 0x83, 0xa4, 0x4e, 0x61, 0x6d, 0x65)
	o = msgp.AppendString(o, z.Name)
	// string "ID"
	o = append(o, 0xa2, 0x49, 0x44)
	o = msgp.AppendString(o, z.ID)
	// string "Vor"
	o = append(o, 0xa3, 0x56, 0x6f, 0x72)
	o = msgp.AppendFloat64(o, z.Vor)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *Actor) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "Name":
			z.Name, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Name")
				return
			}
		case "ID":
			z.ID, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "ID")
				return
			}
		case "Vor":
			z.Vor, bts, err = msgp.ReadFloat64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Vor")
				return
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z Actor) Msgsize() (s int) {
	s = 1 + 5 + msgp.StringPrefixSize + len(z.Name) + 3 + msgp.StringPrefixSize + len(z.ID) + 4 + msgp.Float64Size
	return
}

// DecodeMsg implements msgp.Decodable
func (z *ByRating) DecodeMsg(dc *msgp.Reader) (err error) {
	var zb0002 uint32
	zb0002, err = dc.ReadArrayHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if cap((*z)) >= int(zb0002) {
		(*z) = (*z)[:zb0002]
	} else {
		(*z) = make(ByRating, zb0002)
	}
	for zb0001 := range *z {
		err = (*z)[zb0001].DecodeMsg(dc)
		if err != nil {
			err = msgp.WrapError(err, zb0001)
			return
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z ByRating) 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
}

// MarshalMsg implements msgp.Marshaler
func (z ByRating) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	o = msgp.AppendArrayHeader(o, uint32(len(z)))
	for zb0003 := range z {
		o, err = z[zb0003].MarshalMsg(o)
		if err != nil {
			err = msgp.WrapError(err, zb0003)
			return
		}
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *ByRating) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var zb0002 uint32
	zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if cap((*z)) >= int(zb0002) {
		(*z) = (*z)[:zb0002]
	} else {
		(*z) = make(ByRating, zb0002)
	}
	for zb0001 := range *z {
		bts, err = (*z)[zb0001].UnmarshalMsg(bts)
		if err != nil {
			err = msgp.WrapError(err, zb0001)
			return
		}
	}
	o = bts
	return
}

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

// DecodeMsg implements msgp.Decodable
func (z *ByVor) DecodeMsg(dc *msgp.Reader) (err error) {
	var zb0002 uint32
	zb0002, err = dc.ReadArrayHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if cap((*z)) >= int(zb0002) {
		(*z) = (*z)[:zb0002]
	} else {
		(*z) = make(ByVor, zb0002)
	}
	for zb0001 := range *z {
		var field []byte
		_ = field
		var zb0003 uint32
		zb0003, err = dc.ReadMapHeader()
		if err != nil {
			err = msgp.WrapError(err, zb0001)
			return
		}
		for zb0003 > 0 {
			zb0003--
			field, err = dc.ReadMapKeyPtr()
			if err != nil {
				err = msgp.WrapError(err, zb0001)
				return
			}
			switch msgp.UnsafeString(field) {
			case "Name":
				(*z)[zb0001].Name, err = dc.ReadString()
				if err != nil {
					err = msgp.WrapError(err, zb0001, "Name")
					return
				}
			case "ID":
				(*z)[zb0001].ID, err = dc.ReadString()
				if err != nil {
					err = msgp.WrapError(err, zb0001, "ID")
					return
				}
			case "Vor":
				(*z)[zb0001].Vor, err = dc.ReadFloat64()
				if err != nil {
					err = msgp.WrapError(err, zb0001, "Vor")
					return
				}
			default:
				err = dc.Skip()
				if err != nil {
					err = msgp.WrapError(err, zb0001)
					return
				}
			}
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z ByVor) EncodeMsg(en *msgp.Writer) (err error) {
	err = en.WriteArrayHeader(uint32(len(z)))
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0004 := range z {
		// map header, size 3
		// write "Name"
		err = en.Append(0x83, 0xa4, 0x4e, 0x61, 0x6d, 0x65)
		if err != nil {
			return
		}
		err = en.WriteString(z[zb0004].Name)
		if err != nil {
			err = msgp.WrapError(err, zb0004, "Name")
			return
		}
		// write "ID"
		err = en.Append(0xa2, 0x49, 0x44)
		if err != nil {
			return
		}
		err = en.WriteString(z[zb0004].ID)
		if err != nil {
			err = msgp.WrapError(err, zb0004, "ID")
			return
		}
		// write "Vor"
		err = en.Append(0xa3, 0x56, 0x6f, 0x72)
		if err != nil {
			return
		}
		err = en.WriteFloat64(z[zb0004].Vor)
		if err != nil {
			err = msgp.WrapError(err, zb0004, "Vor")
			return
		}
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z ByVor) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	o = msgp.AppendArrayHeader(o, uint32(len(z)))
	for zb0004 := range z {
		// map header, size 3
		// string "Name"
		o = append(o, 0x83, 0xa4, 0x4e, 0x61, 0x6d, 0x65)
		o = msgp.AppendString(o, z[zb0004].Name)
		// string "ID"
		o = append(o, 0xa2, 0x49, 0x44)
		o = msgp.AppendString(o, z[zb0004].ID)
		// string "Vor"
		o = append(o, 0xa3, 0x56, 0x6f, 0x72)
		o = msgp.AppendFloat64(o, z[zb0004].Vor)
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *ByVor) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var zb0002 uint32
	zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if cap((*z)) >= int(zb0002) {
		(*z) = (*z)[:zb0002]
	} else {
		(*z) = make(ByVor, zb0002)
	}
	for zb0001 := range *z {
		var field []byte
		_ = field
		var zb0003 uint32
		zb0003, bts, err = msgp.ReadMapHeaderBytes(bts)
		if err != nil {
			err = msgp.WrapError(err, zb0001)
			return
		}
		for zb0003 > 0 {
			zb0003--
			field, bts, err = msgp.ReadMapKeyZC(bts)
			if err != nil {
				err = msgp.WrapError(err, zb0001)
				return
			}
			switch msgp.UnsafeString(field) {
			case "Name":
				(*z)[zb0001].Name, bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, zb0001, "Name")
					return
				}
			case "ID":
				(*z)[zb0001].ID, bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, zb0001, "ID")
					return
				}
			case "Vor":
				(*z)[zb0001].Vor, bts, err = msgp.ReadFloat64Bytes(bts)
				if err != nil {
					err = msgp.WrapError(err, zb0001, "Vor")
					return
				}
			default:
				bts, err = msgp.Skip(bts)
				if err != nil {
					err = msgp.WrapError(err, zb0001)
					return
				}
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z ByVor) Msgsize() (s int) {
	s = msgp.ArrayHeaderSize
	for zb0004 := range z {
		s += 1 + 5 + msgp.StringPrefixSize + len(z[zb0004].Name) + 3 + msgp.StringPrefixSize + len(z[zb0004].ID) + 4 + msgp.Float64Size
	}
	return
}

// DecodeMsg implements msgp.Decodable
func (z *Child) 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 "Value":
			z.Value, err = dc.ReadInt32()
			if err != nil {
				err = msgp.WrapError(err, "Value")
				return
			}
		case "Link":
			if dc.IsNil() {
				err = dc.ReadNil()
				if err != nil {
					err = msgp.WrapError(err, "Link")
					return
				}
				z.Link = nil
			} else {
				if z.Link == nil {
					z.Link = new(Trie)
				}
				err = z.Link.DecodeMsg(dc)
				if err != nil {
					err = msgp.WrapError(err, "Link")
					return
				}
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *Child) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 2
	// write "Value"
	err = en.Append(0x82, 0xa5, 0x56, 0x61, 0x6c, 0x75, 0x65)
	if err != nil {
		return
	}
	err = en.WriteInt32(z.Value)
	if err != nil {
		err = msgp.WrapError(err, "Value")
		return
	}
	// write "Link"
	err = en.Append(0xa4, 0x4c, 0x69, 0x6e, 0x6b)
	if err != nil {
		return
	}
	if z.Link == nil {
		err = en.WriteNil()
		if err != nil {
			return
		}
	} else {
		err = z.Link.EncodeMsg(en)
		if err != nil {
			err = msgp.WrapError(err, "Link")
			return
		}
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *Child) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 2
	// string "Value"
	o = append(o, 0x82, 0xa5, 0x56, 0x61, 0x6c, 0x75, 0x65)
	o = msgp.AppendInt32(o, z.Value)
	// string "Link"
	o = append(o, 0xa4, 0x4c, 0x69, 0x6e, 0x6b)
	if z.Link == nil {
		o = msgp.AppendNil(o)
	} else {
		o, err = z.Link.MarshalMsg(o)
		if err != nil {
			err = msgp.WrapError(err, "Link")
			return
		}
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *Child) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "Value":
			z.Value, bts, err = msgp.ReadInt32Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Value")
				return
			}
		case "Link":
			if msgp.IsNil(bts) {
				bts, err = msgp.ReadNilBytes(bts)
				if err != nil {
					return
				}
				z.Link = nil
			} else {
				if z.Link == nil {
					z.Link = new(Trie)
				}
				bts, err = z.Link.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "Link")
					return
				}
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *Child) Msgsize() (s int) {
	s = 1 + 6 + msgp.Int32Size + 5
	if z.Link == nil {
		s += msgp.NilSize
	} else {
		s += z.Link.Msgsize()
	}
	return
}

// DecodeMsg implements msgp.Decodable
func (z *FilmLink) 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 "Fid":
			z.Fid, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Fid")
				return
			}
		case "Film":
			z.Film, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Film")
				return
			}
		case "ActorLink":
			z.ActorLink, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "ActorLink")
				return
			}
		case "Rating":
			z.Rating, err = dc.ReadUint8()
			if err != nil {
				err = msgp.WrapError(err, "Rating")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *FilmLink) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 4
	// write "Fid"
	err = en.Append(0x84, 0xa3, 0x46, 0x69, 0x64)
	if err != nil {
		return
	}
	err = en.WriteString(z.Fid)
	if err != nil {
		err = msgp.WrapError(err, "Fid")
		return
	}
	// write "Film"
	err = en.Append(0xa4, 0x46, 0x69, 0x6c, 0x6d)
	if err != nil {
		return
	}
	err = en.WriteString(z.Film)
	if err != nil {
		err = msgp.WrapError(err, "Film")
		return
	}
	// write "ActorLink"
	err = en.Append(0xa9, 0x41, 0x63, 0x74, 0x6f, 0x72, 0x4c, 0x69, 0x6e, 0x6b)
	if err != nil {
		return
	}
	err = en.WriteString(z.ActorLink)
	if err != nil {
		err = msgp.WrapError(err, "ActorLink")
		return
	}
	// write "Rating"
	err = en.Append(0xa6, 0x52, 0x61, 0x74, 0x69, 0x6e, 0x67)
	if err != nil {
		return
	}
	err = en.WriteUint8(z.Rating)
	if err != nil {
		err = msgp.WrapError(err, "Rating")
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *FilmLink) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 4
	// string "Fid"
	o = append(o, 0x84, 0xa3, 0x46, 0x69, 0x64)
	o = msgp.AppendString(o, z.Fid)
	// string "Film"
	o = append(o, 0xa4, 0x46, 0x69, 0x6c, 0x6d)
	o = msgp.AppendString(o, z.Film)
	// string "ActorLink"
	o = append(o, 0xa9, 0x41, 0x63, 0x74, 0x6f, 0x72, 0x4c, 0x69, 0x6e, 0x6b)
	o = msgp.AppendString(o, z.ActorLink)
	// string "Rating"
	o = append(o, 0xa6, 0x52, 0x61, 0x74, 0x69, 0x6e, 0x67)
	o = msgp.AppendUint8(o, z.Rating)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *FilmLink) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "Fid":
			z.Fid, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Fid")
				return
			}
		case "Film":
			z.Film, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Film")
				return
			}
		case "ActorLink":
			z.ActorLink, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "ActorLink")
				return
			}
		case "Rating":
			z.Rating, bts, err = msgp.ReadUint8Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Rating")
				return
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *FilmLink) Msgsize() (s int) {
	s = 1 + 4 + msgp.StringPrefixSize + len(z.Fid) + 5 + msgp.StringPrefixSize + len(z.Film) + 10 + msgp.StringPrefixSize + len(z.ActorLink) + 7 + msgp.Uint8Size
	return
}

// DecodeMsg implements msgp.Decodable
func (z *IMDB) 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 "A2aid":
			var zb0002 uint32
			zb0002, err = dc.ReadMapHeader()
			if err != nil {
				err = msgp.WrapError(err, "A2aid")
				return
			}
			if z.A2aid == nil {
				z.A2aid = make(map[string]string, zb0002)
			} else if len(z.A2aid) > 0 {
				for key := range z.A2aid {
					delete(z.A2aid, key)
				}
			}
			for zb0002 > 0 {
				zb0002--
				var za0001 string
				var za0002 string
				za0001, err = dc.ReadString()
				if err != nil {
					err = msgp.WrapError(err, "A2aid")
					return
				}
				za0002, err = dc.ReadString()
				if err != nil {
					err = msgp.WrapError(err, "A2aid", za0001)
					return
				}
				z.A2aid[za0001] = za0002
			}
		case "Aid2a":
			var zb0003 uint32
			zb0003, err = dc.ReadMapHeader()
			if err != nil {
				err = msgp.WrapError(err, "Aid2a")
				return
			}
			if z.Aid2a == nil {
				z.Aid2a = make(map[string]string, zb0003)
			} else if len(z.Aid2a) > 0 {
				for key := range z.Aid2a {
					delete(z.Aid2a, key)
				}
			}
			for zb0003 > 0 {
				zb0003--
				var za0003 string
				var za0004 string
				za0003, err = dc.ReadString()
				if err != nil {
					err = msgp.WrapError(err, "Aid2a")
					return
				}
				za0004, err = dc.ReadString()
				if err != nil {
					err = msgp.WrapError(err, "Aid2a", za0003)
					return
				}
				z.Aid2a[za0003] = za0004
			}
		case "F2fids":
			var zb0004 uint32
			zb0004, err = dc.ReadMapHeader()
			if err != nil {
				err = msgp.WrapError(err, "F2fids")
				return
			}
			if z.F2fids == nil {
				z.F2fids = make(map[string]map[string]bool, zb0004)
			} else if len(z.F2fids) > 0 {
				for key := range z.F2fids {
					delete(z.F2fids, key)
				}
			}
			for zb0004 > 0 {
				zb0004--
				var za0005 string
				var za0006 map[string]bool
				za0005, err = dc.ReadString()
				if err != nil {
					err = msgp.WrapError(err, "F2fids")
					return
				}
				var zb0005 uint32
				zb0005, err = dc.ReadMapHeader()
				if err != nil {
					err = msgp.WrapError(err, "F2fids", za0005)
					return
				}
				if za0006 == nil {
					za0006 = make(map[string]bool, zb0005)
				} else if len(za0006) > 0 {
					for key := range za0006 {
						delete(za0006, key)
					}
				}
				for zb0005 > 0 {
					zb0005--
					var za0007 string
					var za0008 bool
					za0007, err = dc.ReadString()
					if err != nil {
						err = msgp.WrapError(err, "F2fids", za0005)
						return
					}
					za0008, err = dc.ReadBool()
					if err != nil {
						err = msgp.WrapError(err, "F2fids", za0005, za0007)
						return
					}
					za0006[za0007] = za0008
				}
				z.F2fids[za0005] = za0006
			}
		case "Fid2f":
			var zb0006 uint32
			zb0006, err = dc.ReadMapHeader()
			if err != nil {
				err = msgp.WrapError(err, "Fid2f")
				return
			}
			if z.Fid2f == nil {
				z.Fid2f = make(map[string]string, zb0006)
			} else if len(z.Fid2f) > 0 {
				for key := range z.Fid2f {
					delete(z.Fid2f, key)
				}
			}
			for zb0006 > 0 {
				zb0006--
				var za0009 string
				var za0010 string
				za0009, err = dc.ReadString()
				if err != nil {
					err = msgp.WrapError(err, "Fid2f")
					return
				}
				za0010, err = dc.ReadString()
				if err != nil {
					err = msgp.WrapError(err, "Fid2f", za0009)
					return
				}
				z.Fid2f[za0009] = za0010
			}
		case "Aid2Fids":
			var zb0007 uint32
			zb0007, err = dc.ReadMapHeader()
			if err != nil {
				err = msgp.WrapError(err, "Aid2Fids")
				return
			}
			if z.Aid2Fids == nil {
				z.Aid2Fids = make(map[string]map[string]bool, zb0007)
			} else if len(z.Aid2Fids) > 0 {
				for key := range z.Aid2Fids {
					delete(z.Aid2Fids, key)
				}
			}
			for zb0007 > 0 {
				zb0007--
				var za0011 string
				var za0012 map[string]bool
				za0011, err = dc.ReadString()
				if err != nil {
					err = msgp.WrapError(err, "Aid2Fids")
					return
				}
				var zb0008 uint32
				zb0008, err = dc.ReadMapHeader()
				if err != nil {
					err = msgp.WrapError(err, "Aid2Fids", za0011)
					return
				}
				if za0012 == nil {
					za0012 = make(map[string]bool, zb0008)
				} else if len(za0012) > 0 {
					for key := range za0012 {
						delete(za0012, key)
					}
				}
				for zb0008 > 0 {
					zb0008--
					var za0013 string
					var za0014 bool
					za0013, err = dc.ReadString()
					if err != nil {
						err = msgp.WrapError(err, "Aid2Fids", za0011)
						return
					}
					za0014, err = dc.ReadBool()
					if err != nil {
						err = msgp.WrapError(err, "Aid2Fids", za0011, za0013)
						return
					}
					za0012[za0013] = za0014
				}
				z.Aid2Fids[za0011] = za0012
			}
		case "Fid2Aids":
			var zb0009 uint32
			zb0009, err = dc.ReadMapHeader()
			if err != nil {
				err = msgp.WrapError(err, "Fid2Aids")
				return
			}
			if z.Fid2Aids == nil {
				z.Fid2Aids = make(map[string]map[string]bool, zb0009)
			} else if len(z.Fid2Aids) > 0 {
				for key := range z.Fid2Aids {
					delete(z.Fid2Aids, key)
				}
			}
			for zb0009 > 0 {
				zb0009--
				var za0015 string
				var za0016 map[string]bool
				za0015, err = dc.ReadString()
				if err != nil {
					err = msgp.WrapError(err, "Fid2Aids")
					return
				}
				var zb0010 uint32
				zb0010, err = dc.ReadMapHeader()
				if err != nil {
					err = msgp.WrapError(err, "Fid2Aids", za0015)
					return
				}
				if za0016 == nil {
					za0016 = make(map[string]bool, zb0010)
				} else if len(za0016) > 0 {
					for key := range za0016 {
						delete(za0016, key)
					}
				}
				for zb0010 > 0 {
					zb0010--
					var za0017 string
					var za0018 bool
					za0017, err = dc.ReadString()
					if err != nil {
						err = msgp.WrapError(err, "Fid2Aids", za0015)
						return
					}
					za0018, err = dc.ReadBool()
					if err != nil {
						err = msgp.WrapError(err, "Fid2Aids", za0015, za0017)
						return
					}
					za0016[za0017] = za0018
				}
				z.Fid2Aids[za0015] = za0016
			}
		case "F2Fs":
			var zb0011 uint32
			zb0011, err = dc.ReadMapHeader()
			if err != nil {
				err = msgp.WrapError(err, "F2Fs")
				return
			}
			if z.F2Fs == nil {
				z.F2Fs = make(map[string]uint8, zb0011)
			} else if len(z.F2Fs) > 0 {
				for key := range z.F2Fs {
					delete(z.F2Fs, key)
				}
			}
			for zb0011 > 0 {
				zb0011--
				var za0019 string
				var za0020 uint8
				za0019, err = dc.ReadString()
				if err != nil {
					err = msgp.WrapError(err, "F2Fs")
					return
				}
				za0020, err = dc.ReadUint8()
				if err != nil {
					err = msgp.WrapError(err, "F2Fs", za0019)
					return
				}
				z.F2Fs[za0019] = za0020
			}
		case "F2F":
			var zb0012 uint32
			zb0012, err = dc.ReadMapHeader()
			if err != nil {
				err = msgp.WrapError(err, "F2F")
				return
			}
			if z.F2F == nil {
				z.F2F = make(map[string]map[string]bool, zb0012)
			} else if len(z.F2F) > 0 {
				for key := range z.F2F {
					delete(z.F2F, key)
				}
			}
			for zb0012 > 0 {
				zb0012--
				var za0021 string
				var za0022 map[string]bool
				za0021, err = dc.ReadString()
				if err != nil {
					err = msgp.WrapError(err, "F2F")
					return
				}
				var zb0013 uint32
				zb0013, err = dc.ReadMapHeader()
				if err != nil {
					err = msgp.WrapError(err, "F2F", za0021)
					return
				}
				if za0022 == nil {
					za0022 = make(map[string]bool, zb0013)
				} else if len(za0022) > 0 {
					for key := range za0022 {
						delete(za0022, key)
					}
				}
				for zb0013 > 0 {
					zb0013--
					var za0023 string
					var za0024 bool
					za0023, err = dc.ReadString()
					if err != nil {
						err = msgp.WrapError(err, "F2F", za0021)
						return
					}
					za0024, err = dc.ReadBool()
					if err != nil {
						err = msgp.WrapError(err, "F2F", za0021, za0023)
						return
					}
					za0022[za0023] = za0024
				}
				z.F2F[za0021] = za0022
			}
		case "Frating":
			var zb0014 uint32
			zb0014, err = dc.ReadMapHeader()
			if err != nil {
				err = msgp.WrapError(err, "Frating")
				return
			}
			if z.Frating == nil {
				z.Frating = make(map[string]uint8, zb0014)
			} else if len(z.Frating) > 0 {
				for key := range z.Frating {
					delete(z.Frating, key)
				}
			}
			for zb0014 > 0 {
				zb0014--
				var za0025 string
				var za0026 uint8
				za0025, err = dc.ReadString()
				if err != nil {
					err = msgp.WrapError(err, "Frating")
					return
				}
				za0026, err = dc.ReadUint8()
				if err != nil {
					err = msgp.WrapError(err, "Frating", za0025)
					return
				}
				z.Frating[za0025] = za0026
			}
		case "FBroadlyRated":
			var zb0015 uint32
			zb0015, err = dc.ReadMapHeader()
			if err != nil {
				err = msgp.WrapError(err, "FBroadlyRated")
				return
			}
			if z.FBroadlyRated == nil {
				z.FBroadlyRated = make(map[string]bool, zb0015)
			} else if len(z.FBroadlyRated) > 0 {
				for key := range z.FBroadlyRated {
					delete(z.FBroadlyRated, key)
				}
			}
			for zb0015 > 0 {
				zb0015--
				var za0027 string
				var za0028 bool
				za0027, err = dc.ReadString()
				if err != nil {
					err = msgp.WrapError(err, "FBroadlyRated")
					return
				}
				za0028, err = dc.ReadBool()
				if err != nil {
					err = msgp.WrapError(err, "FBroadlyRated", za0027)
					return
				}
				z.FBroadlyRated[za0027] = za0028
			}
		case "Actors":
			err = z.Actors.DecodeMsg(dc)
			if err != nil {
				err = msgp.WrapError(err, "Actors")
				return
			}
		case "Films":
			err = z.Films.DecodeMsg(dc)
			if err != nil {
				err = msgp.WrapError(err, "Films")
				return
			}
		case "AIds":
			err = z.AIds.DecodeMsg(dc)
			if err != nil {
				err = msgp.WrapError(err, "AIds")
				return
			}
		case "FIds":
			err = z.FIds.DecodeMsg(dc)
			if err != nil {
				err = msgp.WrapError(err, "FIds")
				return
			}
		case "AVor":
			var zb0016 uint32
			zb0016, err = dc.ReadMapHeader()
			if err != nil {
				err = msgp.WrapError(err, "AVor")
				return
			}
			if z.AVor == nil {
				z.AVor = make(map[string]float64, zb0016)
			} else if len(z.AVor) > 0 {
				for key := range z.AVor {
					delete(z.AVor, key)
				}
			}
			for zb0016 > 0 {
				zb0016--
				var za0029 string
				var za0030 float64
				za0029, err = dc.ReadString()
				if err != nil {
					err = msgp.WrapError(err, "AVor")
					return
				}
				za0030, err = dc.ReadFloat64()
				if err != nil {
					err = msgp.WrapError(err, "AVor", za0029)
					return
				}
				z.AVor[za0029] = za0030
			}
		case "ARating":
			var zb0017 uint32
			zb0017, err = dc.ReadMapHeader()
			if err != nil {
				err = msgp.WrapError(err, "ARating")
				return
			}
			if z.ARating == nil {
				z.ARating = make(map[string]float64, zb0017)
			} else if len(z.ARating) > 0 {
				for key := range z.ARating {
					delete(z.ARating, key)
				}
			}
			for zb0017 > 0 {
				zb0017--
				var za0031 string
				var za0032 float64
				za0031, err = dc.ReadString()
				if err != nil {
					err = msgp.WrapError(err, "ARating")
					return
				}
				za0032, err = dc.ReadFloat64()
				if err != nil {
					err = msgp.WrapError(err, "ARating", za0031)
					return
				}
				z.ARating[za0031] = za0032
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *IMDB) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 16
	// write "A2aid"
	err = en.Append(0xde, 0x0, 0x10, 0xa5, 0x41, 0x32, 0x61, 0x69, 0x64)
	if err != nil {
		return
	}
	err = en.WriteMapHeader(uint32(len(z.A2aid)))
	if err != nil {
		err = msgp.WrapError(err, "A2aid")
		return
	}
	for za0001, za0002 := range z.A2aid {
		err = en.WriteString(za0001)
		if err != nil {
			err = msgp.WrapError(err, "A2aid")
			return
		}
		err = en.WriteString(za0002)
		if err != nil {
			err = msgp.WrapError(err, "A2aid", za0001)
			return
		}
	}
	// write "Aid2a"
	err = en.Append(0xa5, 0x41, 0x69, 0x64, 0x32, 0x61)
	if err != nil {
		return
	}
	err = en.WriteMapHeader(uint32(len(z.Aid2a)))
	if err != nil {
		err = msgp.WrapError(err, "Aid2a")
		return
	}
	for za0003, za0004 := range z.Aid2a {
		err = en.WriteString(za0003)
		if err != nil {
			err = msgp.WrapError(err, "Aid2a")
			return
		}
		err = en.WriteString(za0004)
		if err != nil {
			err = msgp.WrapError(err, "Aid2a", za0003)
			return
		}
	}
	// write "F2fids"
	err = en.Append(0xa6, 0x46, 0x32, 0x66, 0x69, 0x64, 0x73)
	if err != nil {
		return
	}
	err = en.WriteMapHeader(uint32(len(z.F2fids)))
	if err != nil {
		err = msgp.WrapError(err, "F2fids")
		return
	}
	for za0005, za0006 := range z.F2fids {
		err = en.WriteString(za0005)
		if err != nil {
			err = msgp.WrapError(err, "F2fids")
			return
		}
		err = en.WriteMapHeader(uint32(len(za0006)))
		if err != nil {
			err = msgp.WrapError(err, "F2fids", za0005)
			return
		}
		for za0007, za0008 := range za0006 {
			err = en.WriteString(za0007)
			if err != nil {
				err = msgp.WrapError(err, "F2fids", za0005)
				return
			}
			err = en.WriteBool(za0008)
			if err != nil {
				err = msgp.WrapError(err, "F2fids", za0005, za0007)
				return
			}
		}
	}
	// write "Fid2f"
	err = en.Append(0xa5, 0x46, 0x69, 0x64, 0x32, 0x66)
	if err != nil {
		return
	}
	err = en.WriteMapHeader(uint32(len(z.Fid2f)))
	if err != nil {
		err = msgp.WrapError(err, "Fid2f")
		return
	}
	for za0009, za0010 := range z.Fid2f {
		err = en.WriteString(za0009)
		if err != nil {
			err = msgp.WrapError(err, "Fid2f")
			return
		}
		err = en.WriteString(za0010)
		if err != nil {
			err = msgp.WrapError(err, "Fid2f", za0009)
			return
		}
	}
	// write "Aid2Fids"
	err = en.Append(0xa8, 0x41, 0x69, 0x64, 0x32, 0x46, 0x69, 0x64, 0x73)
	if err != nil {
		return
	}
	err = en.WriteMapHeader(uint32(len(z.Aid2Fids)))
	if err != nil {
		err = msgp.WrapError(err, "Aid2Fids")
		return
	}
	for za0011, za0012 := range z.Aid2Fids {
		err = en.WriteString(za0011)
		if err != nil {
			err = msgp.WrapError(err, "Aid2Fids")
			return
		}
		err = en.WriteMapHeader(uint32(len(za0012)))
		if err != nil {
			err = msgp.WrapError(err, "Aid2Fids", za0011)
			return
		}
		for za0013, za0014 := range za0012 {
			err = en.WriteString(za0013)
			if err != nil {
				err = msgp.WrapError(err, "Aid2Fids", za0011)
				return
			}
			err = en.WriteBool(za0014)
			if err != nil {
				err = msgp.WrapError(err, "Aid2Fids", za0011, za0013)
				return
			}
		}
	}
	// write "Fid2Aids"
	err = en.Append(0xa8, 0x46, 0x69, 0x64, 0x32, 0x41, 0x69, 0x64, 0x73)
	if err != nil {
		return
	}
	err = en.WriteMapHeader(uint32(len(z.Fid2Aids)))
	if err != nil {
		err = msgp.WrapError(err, "Fid2Aids")
		return
	}
	for za0015, za0016 := range z.Fid2Aids {
		err = en.WriteString(za0015)
		if err != nil {
			err = msgp.WrapError(err, "Fid2Aids")
			return
		}
		err = en.WriteMapHeader(uint32(len(za0016)))
		if err != nil {
			err = msgp.WrapError(err, "Fid2Aids", za0015)
			return
		}
		for za0017, za0018 := range za0016 {
			err = en.WriteString(za0017)
			if err != nil {
				err = msgp.WrapError(err, "Fid2Aids", za0015)
				return
			}
			err = en.WriteBool(za0018)
			if err != nil {
				err = msgp.WrapError(err, "Fid2Aids", za0015, za0017)
				return
			}
		}
	}
	// write "F2Fs"
	err = en.Append(0xa4, 0x46, 0x32, 0x46, 0x73)
	if err != nil {
		return
	}
	err = en.WriteMapHeader(uint32(len(z.F2Fs)))
	if err != nil {
		err = msgp.WrapError(err, "F2Fs")
		return
	}
	for za0019, za0020 := range z.F2Fs {
		err = en.WriteString(za0019)
		if err != nil {
			err = msgp.WrapError(err, "F2Fs")
			return
		}
		err = en.WriteUint8(za0020)
		if err != nil {
			err = msgp.WrapError(err, "F2Fs", za0019)
			return
		}
	}
	// write "F2F"
	err = en.Append(0xa3, 0x46, 0x32, 0x46)
	if err != nil {
		return
	}
	err = en.WriteMapHeader(uint32(len(z.F2F)))
	if err != nil {
		err = msgp.WrapError(err, "F2F")
		return
	}
	for za0021, za0022 := range z.F2F {
		err = en.WriteString(za0021)
		if err != nil {
			err = msgp.WrapError(err, "F2F")
			return
		}
		err = en.WriteMapHeader(uint32(len(za0022)))
		if err != nil {
			err = msgp.WrapError(err, "F2F", za0021)
			return
		}
		for za0023, za0024 := range za0022 {
			err = en.WriteString(za0023)
			if err != nil {
				err = msgp.WrapError(err, "F2F", za0021)
				return
			}
			err = en.WriteBool(za0024)
			if err != nil {
				err = msgp.WrapError(err, "F2F", za0021, za0023)
				return
			}
		}
	}
	// write "Frating"
	err = en.Append(0xa7, 0x46, 0x72, 0x61, 0x74, 0x69, 0x6e, 0x67)
	if err != nil {
		return
	}
	err = en.WriteMapHeader(uint32(len(z.Frating)))
	if err != nil {
		err = msgp.WrapError(err, "Frating")
		return
	}
	for za0025, za0026 := range z.Frating {
		err = en.WriteString(za0025)
		if err != nil {
			err = msgp.WrapError(err, "Frating")
			return
		}
		err = en.WriteUint8(za0026)
		if err != nil {
			err = msgp.WrapError(err, "Frating", za0025)
			return
		}
	}
	// write "FBroadlyRated"
	err = en.Append(0xad, 0x46, 0x42, 0x72, 0x6f, 0x61, 0x64, 0x6c, 0x79, 0x52, 0x61, 0x74, 0x65, 0x64)
	if err != nil {
		return
	}
	err = en.WriteMapHeader(uint32(len(z.FBroadlyRated)))
	if err != nil {
		err = msgp.WrapError(err, "FBroadlyRated")
		return
	}
	for za0027, za0028 := range z.FBroadlyRated {
		err = en.WriteString(za0027)
		if err != nil {
			err = msgp.WrapError(err, "FBroadlyRated")
			return
		}
		err = en.WriteBool(za0028)
		if err != nil {
			err = msgp.WrapError(err, "FBroadlyRated", za0027)
			return
		}
	}
	// write "Actors"
	err = en.Append(0xa6, 0x41, 0x63, 0x74, 0x6f, 0x72, 0x73)
	if err != nil {
		return
	}
	err = z.Actors.EncodeMsg(en)
	if err != nil {
		err = msgp.WrapError(err, "Actors")
		return
	}
	// write "Films"
	err = en.Append(0xa5, 0x46, 0x69, 0x6c, 0x6d, 0x73)
	if err != nil {
		return
	}
	err = z.Films.EncodeMsg(en)
	if err != nil {
		err = msgp.WrapError(err, "Films")
		return
	}
	// write "AIds"
	err = en.Append(0xa4, 0x41, 0x49, 0x64, 0x73)
	if err != nil {
		return
	}
	err = z.AIds.EncodeMsg(en)
	if err != nil {
		err = msgp.WrapError(err, "AIds")
		return
	}
	// write "FIds"
	err = en.Append(0xa4, 0x46, 0x49, 0x64, 0x73)
	if err != nil {
		return
	}
	err = z.FIds.EncodeMsg(en)
	if err != nil {
		err = msgp.WrapError(err, "FIds")
		return
	}
	// write "AVor"
	err = en.Append(0xa4, 0x41, 0x56, 0x6f, 0x72)
	if err != nil {
		return
	}
	err = en.WriteMapHeader(uint32(len(z.AVor)))
	if err != nil {
		err = msgp.WrapError(err, "AVor")
		return
	}
	for za0029, za0030 := range z.AVor {
		err = en.WriteString(za0029)
		if err != nil {
			err = msgp.WrapError(err, "AVor")
			return
		}
		err = en.WriteFloat64(za0030)
		if err != nil {
			err = msgp.WrapError(err, "AVor", za0029)
			return
		}
	}
	// write "ARating"
	err = en.Append(0xa7, 0x41, 0x52, 0x61, 0x74, 0x69, 0x6e, 0x67)
	if err != nil {
		return
	}
	err = en.WriteMapHeader(uint32(len(z.ARating)))
	if err != nil {
		err = msgp.WrapError(err, "ARating")
		return
	}
	for za0031, za0032 := range z.ARating {
		err = en.WriteString(za0031)
		if err != nil {
			err = msgp.WrapError(err, "ARating")
			return
		}
		err = en.WriteFloat64(za0032)
		if err != nil {
			err = msgp.WrapError(err, "ARating", za0031)
			return
		}
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *IMDB) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 16
	// string "A2aid"
	o = append(o, 0xde, 0x0, 0x10, 0xa5, 0x41, 0x32, 0x61, 0x69, 0x64)
	o = msgp.AppendMapHeader(o, uint32(len(z.A2aid)))
	for za0001, za0002 := range z.A2aid {
		o = msgp.AppendString(o, za0001)
		o = msgp.AppendString(o, za0002)
	}
	// string "Aid2a"
	o = append(o, 0xa5, 0x41, 0x69, 0x64, 0x32, 0x61)
	o = msgp.AppendMapHeader(o, uint32(len(z.Aid2a)))
	for za0003, za0004 := range z.Aid2a {
		o = msgp.AppendString(o, za0003)
		o = msgp.AppendString(o, za0004)
	}
	// string "F2fids"
	o = append(o, 0xa6, 0x46, 0x32, 0x66, 0x69, 0x64, 0x73)
	o = msgp.AppendMapHeader(o, uint32(len(z.F2fids)))
	for za0005, za0006 := range z.F2fids {
		o = msgp.AppendString(o, za0005)
		o = msgp.AppendMapHeader(o, uint32(len(za0006)))
		for za0007, za0008 := range za0006 {
			o = msgp.AppendString(o, za0007)
			o = msgp.AppendBool(o, za0008)
		}
	}
	// string "Fid2f"
	o = append(o, 0xa5, 0x46, 0x69, 0x64, 0x32, 0x66)
	o = msgp.AppendMapHeader(o, uint32(len(z.Fid2f)))
	for za0009, za0010 := range z.Fid2f {
		o = msgp.AppendString(o, za0009)
		o = msgp.AppendString(o, za0010)
	}
	// string "Aid2Fids"
	o = append(o, 0xa8, 0x41, 0x69, 0x64, 0x32, 0x46, 0x69, 0x64, 0x73)
	o = msgp.AppendMapHeader(o, uint32(len(z.Aid2Fids)))
	for za0011, za0012 := range z.Aid2Fids {
		o = msgp.AppendString(o, za0011)
		o = msgp.AppendMapHeader(o, uint32(len(za0012)))
		for za0013, za0014 := range za0012 {
			o = msgp.AppendString(o, za0013)
			o = msgp.AppendBool(o, za0014)
		}
	}
	// string "Fid2Aids"
	o = append(o, 0xa8, 0x46, 0x69, 0x64, 0x32, 0x41, 0x69, 0x64, 0x73)
	o = msgp.AppendMapHeader(o, uint32(len(z.Fid2Aids)))
	for za0015, za0016 := range z.Fid2Aids {
		o = msgp.AppendString(o, za0015)
		o = msgp.AppendMapHeader(o, uint32(len(za0016)))
		for za0017, za0018 := range za0016 {
			o = msgp.AppendString(o, za0017)
			o = msgp.AppendBool(o, za0018)
		}
	}
	// string "F2Fs"
	o = append(o, 0xa4, 0x46, 0x32, 0x46, 0x73)
	o = msgp.AppendMapHeader(o, uint32(len(z.F2Fs)))
	for za0019, za0020 := range z.F2Fs {
		o = msgp.AppendString(o, za0019)
		o = msgp.AppendUint8(o, za0020)
	}
	// string "F2F"
	o = append(o, 0xa3, 0x46, 0x32, 0x46)
	o = msgp.AppendMapHeader(o, uint32(len(z.F2F)))
	for za0021, za0022 := range z.F2F {
		o = msgp.AppendString(o, za0021)
		o = msgp.AppendMapHeader(o, uint32(len(za0022)))
		for za0023, za0024 := range za0022 {
			o = msgp.AppendString(o, za0023)
			o = msgp.AppendBool(o, za0024)
		}
	}
	// string "Frating"
	o = append(o, 0xa7, 0x46, 0x72, 0x61, 0x74, 0x69, 0x6e, 0x67)
	o = msgp.AppendMapHeader(o, uint32(len(z.Frating)))
	for za0025, za0026 := range z.Frating {
		o = msgp.AppendString(o, za0025)
		o = msgp.AppendUint8(o, za0026)
	}
	// string "FBroadlyRated"
	o = append(o, 0xad, 0x46, 0x42, 0x72, 0x6f, 0x61, 0x64, 0x6c, 0x79, 0x52, 0x61, 0x74, 0x65, 0x64)
	o = msgp.AppendMapHeader(o, uint32(len(z.FBroadlyRated)))
	for za0027, za0028 := range z.FBroadlyRated {
		o = msgp.AppendString(o, za0027)
		o = msgp.AppendBool(o, za0028)
	}
	// string "Actors"
	o = append(o, 0xa6, 0x41, 0x63, 0x74, 0x6f, 0x72, 0x73)
	o, err = z.Actors.MarshalMsg(o)
	if err != nil {
		err = msgp.WrapError(err, "Actors")
		return
	}
	// string "Films"
	o = append(o, 0xa5, 0x46, 0x69, 0x6c, 0x6d, 0x73)
	o, err = z.Films.MarshalMsg(o)
	if err != nil {
		err = msgp.WrapError(err, "Films")
		return
	}
	// string "AIds"
	o = append(o, 0xa4, 0x41, 0x49, 0x64, 0x73)
	o, err = z.AIds.MarshalMsg(o)
	if err != nil {
		err = msgp.WrapError(err, "AIds")
		return
	}
	// string "FIds"
	o = append(o, 0xa4, 0x46, 0x49, 0x64, 0x73)
	o, err = z.FIds.MarshalMsg(o)
	if err != nil {
		err = msgp.WrapError(err, "FIds")
		return
	}
	// string "AVor"
	o = append(o, 0xa4, 0x41, 0x56, 0x6f, 0x72)
	o = msgp.AppendMapHeader(o, uint32(len(z.AVor)))
	for za0029, za0030 := range z.AVor {
		o = msgp.AppendString(o, za0029)
		o = msgp.AppendFloat64(o, za0030)
	}
	// string "ARating"
	o = append(o, 0xa7, 0x41, 0x52, 0x61, 0x74, 0x69, 0x6e, 0x67)
	o = msgp.AppendMapHeader(o, uint32(len(z.ARating)))
	for za0031, za0032 := range z.ARating {
		o = msgp.AppendString(o, za0031)
		o = msgp.AppendFloat64(o, za0032)
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *IMDB) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "A2aid":
			var zb0002 uint32
			zb0002, bts, err = msgp.ReadMapHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "A2aid")
				return
			}
			if z.A2aid == nil {
				z.A2aid = make(map[string]string, zb0002)
			} else if len(z.A2aid) > 0 {
				for key := range z.A2aid {
					delete(z.A2aid, key)
				}
			}
			for zb0002 > 0 {
				var za0001 string
				var za0002 string
				zb0002--
				za0001, bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "A2aid")
					return
				}
				za0002, bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "A2aid", za0001)
					return
				}
				z.A2aid[za0001] = za0002
			}
		case "Aid2a":
			var zb0003 uint32
			zb0003, bts, err = msgp.ReadMapHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Aid2a")
				return
			}
			if z.Aid2a == nil {
				z.Aid2a = make(map[string]string, zb0003)
			} else if len(z.Aid2a) > 0 {
				for key := range z.Aid2a {
					delete(z.Aid2a, key)
				}
			}
			for zb0003 > 0 {
				var za0003 string
				var za0004 string
				zb0003--
				za0003, bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "Aid2a")
					return
				}
				za0004, bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "Aid2a", za0003)
					return
				}
				z.Aid2a[za0003] = za0004
			}
		case "F2fids":
			var zb0004 uint32
			zb0004, bts, err = msgp.ReadMapHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "F2fids")
				return
			}
			if z.F2fids == nil {
				z.F2fids = make(map[string]map[string]bool, zb0004)
			} else if len(z.F2fids) > 0 {
				for key := range z.F2fids {
					delete(z.F2fids, key)
				}
			}
			for zb0004 > 0 {
				var za0005 string
				var za0006 map[string]bool
				zb0004--
				za0005, bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "F2fids")
					return
				}
				var zb0005 uint32
				zb0005, bts, err = msgp.ReadMapHeaderBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "F2fids", za0005)
					return
				}
				if za0006 == nil {
					za0006 = make(map[string]bool, zb0005)
				} else if len(za0006) > 0 {
					for key := range za0006 {
						delete(za0006, key)
					}
				}
				for zb0005 > 0 {
					var za0007 string
					var za0008 bool
					zb0005--
					za0007, bts, err = msgp.ReadStringBytes(bts)
					if err != nil {
						err = msgp.WrapError(err, "F2fids", za0005)
						return
					}
					za0008, bts, err = msgp.ReadBoolBytes(bts)
					if err != nil {
						err = msgp.WrapError(err, "F2fids", za0005, za0007)
						return
					}
					za0006[za0007] = za0008
				}
				z.F2fids[za0005] = za0006
			}
		case "Fid2f":
			var zb0006 uint32
			zb0006, bts, err = msgp.ReadMapHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Fid2f")
				return
			}
			if z.Fid2f == nil {
				z.Fid2f = make(map[string]string, zb0006)
			} else if len(z.Fid2f) > 0 {
				for key := range z.Fid2f {
					delete(z.Fid2f, key)
				}
			}
			for zb0006 > 0 {
				var za0009 string
				var za0010 string
				zb0006--
				za0009, bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "Fid2f")
					return
				}
				za0010, bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "Fid2f", za0009)
					return
				}
				z.Fid2f[za0009] = za0010
			}
		case "Aid2Fids":
			var zb0007 uint32
			zb0007, bts, err = msgp.ReadMapHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Aid2Fids")
				return
			}
			if z.Aid2Fids == nil {
				z.Aid2Fids = make(map[string]map[string]bool, zb0007)
			} else if len(z.Aid2Fids) > 0 {
				for key := range z.Aid2Fids {
					delete(z.Aid2Fids, key)
				}
			}
			for zb0007 > 0 {
				var za0011 string
				var za0012 map[string]bool
				zb0007--
				za0011, bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "Aid2Fids")
					return
				}
				var zb0008 uint32
				zb0008, bts, err = msgp.ReadMapHeaderBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "Aid2Fids", za0011)
					return
				}
				if za0012 == nil {
					za0012 = make(map[string]bool, zb0008)
				} else if len(za0012) > 0 {
					for key := range za0012 {
						delete(za0012, key)
					}
				}
				for zb0008 > 0 {
					var za0013 string
					var za0014 bool
					zb0008--
					za0013, bts, err = msgp.ReadStringBytes(bts)
					if err != nil {
						err = msgp.WrapError(err, "Aid2Fids", za0011)
						return
					}
					za0014, bts, err = msgp.ReadBoolBytes(bts)
					if err != nil {
						err = msgp.WrapError(err, "Aid2Fids", za0011, za0013)
						return
					}
					za0012[za0013] = za0014
				}
				z.Aid2Fids[za0011] = za0012
			}
		case "Fid2Aids":
			var zb0009 uint32
			zb0009, bts, err = msgp.ReadMapHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Fid2Aids")
				return
			}
			if z.Fid2Aids == nil {
				z.Fid2Aids = make(map[string]map[string]bool, zb0009)
			} else if len(z.Fid2Aids) > 0 {
				for key := range z.Fid2Aids {
					delete(z.Fid2Aids, key)
				}
			}
			for zb0009 > 0 {
				var za0015 string
				var za0016 map[string]bool
				zb0009--
				za0015, bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "Fid2Aids")
					return
				}
				var zb0010 uint32
				zb0010, bts, err = msgp.ReadMapHeaderBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "Fid2Aids", za0015)
					return
				}
				if za0016 == nil {
					za0016 = make(map[string]bool, zb0010)
				} else if len(za0016) > 0 {
					for key := range za0016 {
						delete(za0016, key)
					}
				}
				for zb0010 > 0 {
					var za0017 string
					var za0018 bool
					zb0010--
					za0017, bts, err = msgp.ReadStringBytes(bts)
					if err != nil {
						err = msgp.WrapError(err, "Fid2Aids", za0015)
						return
					}
					za0018, bts, err = msgp.ReadBoolBytes(bts)
					if err != nil {
						err = msgp.WrapError(err, "Fid2Aids", za0015, za0017)
						return
					}
					za0016[za0017] = za0018
				}
				z.Fid2Aids[za0015] = za0016
			}
		case "F2Fs":
			var zb0011 uint32
			zb0011, bts, err = msgp.ReadMapHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "F2Fs")
				return
			}
			if z.F2Fs == nil {
				z.F2Fs = make(map[string]uint8, zb0011)
			} else if len(z.F2Fs) > 0 {
				for key := range z.F2Fs {
					delete(z.F2Fs, key)
				}
			}
			for zb0011 > 0 {
				var za0019 string
				var za0020 uint8
				zb0011--
				za0019, bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "F2Fs")
					return
				}
				za0020, bts, err = msgp.ReadUint8Bytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "F2Fs", za0019)
					return
				}
				z.F2Fs[za0019] = za0020
			}
		case "F2F":
			var zb0012 uint32
			zb0012, bts, err = msgp.ReadMapHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "F2F")
				return
			}
			if z.F2F == nil {
				z.F2F = make(map[string]map[string]bool, zb0012)
			} else if len(z.F2F) > 0 {
				for key := range z.F2F {
					delete(z.F2F, key)
				}
			}
			for zb0012 > 0 {
				var za0021 string
				var za0022 map[string]bool
				zb0012--
				za0021, bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "F2F")
					return
				}
				var zb0013 uint32
				zb0013, bts, err = msgp.ReadMapHeaderBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "F2F", za0021)
					return
				}
				if za0022 == nil {
					za0022 = make(map[string]bool, zb0013)
				} else if len(za0022) > 0 {
					for key := range za0022 {
						delete(za0022, key)
					}
				}
				for zb0013 > 0 {
					var za0023 string
					var za0024 bool
					zb0013--
					za0023, bts, err = msgp.ReadStringBytes(bts)
					if err != nil {
						err = msgp.WrapError(err, "F2F", za0021)
						return
					}
					za0024, bts, err = msgp.ReadBoolBytes(bts)
					if err != nil {
						err = msgp.WrapError(err, "F2F", za0021, za0023)
						return
					}
					za0022[za0023] = za0024
				}
				z.F2F[za0021] = za0022
			}
		case "Frating":
			var zb0014 uint32
			zb0014, bts, err = msgp.ReadMapHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Frating")
				return
			}
			if z.Frating == nil {
				z.Frating = make(map[string]uint8, zb0014)
			} else if len(z.Frating) > 0 {
				for key := range z.Frating {
					delete(z.Frating, key)
				}
			}
			for zb0014 > 0 {
				var za0025 string
				var za0026 uint8
				zb0014--
				za0025, bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "Frating")
					return
				}
				za0026, bts, err = msgp.ReadUint8Bytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "Frating", za0025)
					return
				}
				z.Frating[za0025] = za0026
			}
		case "FBroadlyRated":
			var zb0015 uint32
			zb0015, bts, err = msgp.ReadMapHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "FBroadlyRated")
				return
			}
			if z.FBroadlyRated == nil {
				z.FBroadlyRated = make(map[string]bool, zb0015)
			} else if len(z.FBroadlyRated) > 0 {
				for key := range z.FBroadlyRated {
					delete(z.FBroadlyRated, key)
				}
			}
			for zb0015 > 0 {
				var za0027 string
				var za0028 bool
				zb0015--
				za0027, bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "FBroadlyRated")
					return
				}
				za0028, bts, err = msgp.ReadBoolBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "FBroadlyRated", za0027)
					return
				}
				z.FBroadlyRated[za0027] = za0028
			}
		case "Actors":
			bts, err = z.Actors.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "Actors")
				return
			}
		case "Films":
			bts, err = z.Films.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "Films")
				return
			}
		case "AIds":
			bts, err = z.AIds.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "AIds")
				return
			}
		case "FIds":
			bts, err = z.FIds.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "FIds")
				return
			}
		case "AVor":
			var zb0016 uint32
			zb0016, bts, err = msgp.ReadMapHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "AVor")
				return
			}
			if z.AVor == nil {
				z.AVor = make(map[string]float64, zb0016)
			} else if len(z.AVor) > 0 {
				for key := range z.AVor {
					delete(z.AVor, key)
				}
			}
			for zb0016 > 0 {
				var za0029 string
				var za0030 float64
				zb0016--
				za0029, bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "AVor")
					return
				}
				za0030, bts, err = msgp.ReadFloat64Bytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "AVor", za0029)
					return
				}
				z.AVor[za0029] = za0030
			}
		case "ARating":
			var zb0017 uint32
			zb0017, bts, err = msgp.ReadMapHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "ARating")
				return
			}
			if z.ARating == nil {
				z.ARating = make(map[string]float64, zb0017)
			} else if len(z.ARating) > 0 {
				for key := range z.ARating {
					delete(z.ARating, key)
				}
			}
			for zb0017 > 0 {
				var za0031 string
				var za0032 float64
				zb0017--
				za0031, bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "ARating")
					return
				}
				za0032, bts, err = msgp.ReadFloat64Bytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "ARating", za0031)
					return
				}
				z.ARating[za0031] = za0032
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *IMDB) Msgsize() (s int) {
	s = 3 + 6 + msgp.MapHeaderSize
	if z.A2aid != nil {
		for za0001, za0002 := range z.A2aid {
			_ = za0002
			s += msgp.StringPrefixSize + len(za0001) + msgp.StringPrefixSize + len(za0002)
		}
	}
	s += 6 + msgp.MapHeaderSize
	if z.Aid2a != nil {
		for za0003, za0004 := range z.Aid2a {
			_ = za0004
			s += msgp.StringPrefixSize + len(za0003) + msgp.StringPrefixSize + len(za0004)
		}
	}
	s += 7 + msgp.MapHeaderSize
	if z.F2fids != nil {
		for za0005, za0006 := range z.F2fids {
			_ = za0006
			s += msgp.StringPrefixSize + len(za0005) + msgp.MapHeaderSize
			if za0006 != nil {
				for za0007, za0008 := range za0006 {
					_ = za0008
					s += msgp.StringPrefixSize + len(za0007) + msgp.BoolSize
				}
			}
		}
	}
	s += 6 + msgp.MapHeaderSize
	if z.Fid2f != nil {
		for za0009, za0010 := range z.Fid2f {
			_ = za0010
			s += msgp.StringPrefixSize + len(za0009) + msgp.StringPrefixSize + len(za0010)
		}
	}
	s += 9 + msgp.MapHeaderSize
	if z.Aid2Fids != nil {
		for za0011, za0012 := range z.Aid2Fids {
			_ = za0012
			s += msgp.StringPrefixSize + len(za0011) + msgp.MapHeaderSize
			if za0012 != nil {
				for za0013, za0014 := range za0012 {
					_ = za0014
					s += msgp.StringPrefixSize + len(za0013) + msgp.BoolSize
				}
			}
		}
	}
	s += 9 + msgp.MapHeaderSize
	if z.Fid2Aids != nil {
		for za0015, za0016 := range z.Fid2Aids {
			_ = za0016
			s += msgp.StringPrefixSize + len(za0015) + msgp.MapHeaderSize
			if za0016 != nil {
				for za0017, za0018 := range za0016 {
					_ = za0018
					s += msgp.StringPrefixSize + len(za0017) + msgp.BoolSize
				}
			}
		}
	}
	s += 5 + msgp.MapHeaderSize
	if z.F2Fs != nil {
		for za0019, za0020 := range z.F2Fs {
			_ = za0020
			s += msgp.StringPrefixSize + len(za0019) + msgp.Uint8Size
		}
	}
	s += 4 + msgp.MapHeaderSize
	if z.F2F != nil {
		for za0021, za0022 := range z.F2F {
			_ = za0022
			s += msgp.StringPrefixSize + len(za0021) + msgp.MapHeaderSize
			if za0022 != nil {
				for za0023, za0024 := range za0022 {
					_ = za0024
					s += msgp.StringPrefixSize + len(za0023) + msgp.BoolSize
				}
			}
		}
	}
	s += 8 + msgp.MapHeaderSize
	if z.Frating != nil {
		for za0025, za0026 := range z.Frating {
			_ = za0026
			s += msgp.StringPrefixSize + len(za0025) + msgp.Uint8Size
		}
	}
	s += 14 + msgp.MapHeaderSize
	if z.FBroadlyRated != nil {
		for za0027, za0028 := range z.FBroadlyRated {
			_ = za0028
			s += msgp.StringPrefixSize + len(za0027) + msgp.BoolSize
		}
	}
	s += 7 + z.Actors.Msgsize() + 6 + z.Films.Msgsize() + 5 + z.AIds.Msgsize() + 5 + z.FIds.Msgsize() + 5 + msgp.MapHeaderSize
	if z.AVor != nil {
		for za0029, za0030 := range z.AVor {
			_ = za0030
			s += msgp.StringPrefixSize + len(za0029) + msgp.Float64Size
		}
	}
	s += 8 + msgp.MapHeaderSize
	if z.ARating != nil {
		for za0031, za0032 := range z.ARating {
			_ = za0032
			s += msgp.StringPrefixSize + len(za0031) + msgp.Float64Size
		}
	}
	return
}

// DecodeMsg implements msgp.Decodable
func (z *Trie) 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 "Value":
			z.Value, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Value")
				return
			}
		case "Children":
			var zb0002 uint32
			zb0002, err = dc.ReadArrayHeader()
			if err != nil {
				err = msgp.WrapError(err, "Children")
				return
			}
			if cap(z.Children) >= int(zb0002) {
				z.Children = (z.Children)[:zb0002]
			} else {
				z.Children = make([]Child, zb0002)
			}
			for za0001 := range z.Children {
				var zb0003 uint32
				zb0003, err = dc.ReadMapHeader()
				if err != nil {
					err = msgp.WrapError(err, "Children", za0001)
					return
				}
				for zb0003 > 0 {
					zb0003--
					field, err = dc.ReadMapKeyPtr()
					if err != nil {
						err = msgp.WrapError(err, "Children", za0001)
						return
					}
					switch msgp.UnsafeString(field) {
					case "Value":
						z.Children[za0001].Value, err = dc.ReadInt32()
						if err != nil {
							err = msgp.WrapError(err, "Children", za0001, "Value")
							return
						}
					case "Link":
						if dc.IsNil() {
							err = dc.ReadNil()
							if err != nil {
								err = msgp.WrapError(err, "Children", za0001, "Link")
								return
							}
							z.Children[za0001].Link = nil
						} else {
							if z.Children[za0001].Link == nil {
								z.Children[za0001].Link = new(Trie)
							}
							err = z.Children[za0001].Link.DecodeMsg(dc)
							if err != nil {
								err = msgp.WrapError(err, "Children", za0001, "Link")
								return
							}
						}
					default:
						err = dc.Skip()
						if err != nil {
							err = msgp.WrapError(err, "Children", za0001)
							return
						}
					}
				}
			}
		case "End":
			z.End, err = dc.ReadBool()
			if err != nil {
				err = msgp.WrapError(err, "End")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *Trie) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 3
	// write "Value"
	err = en.Append(0x83, 0xa5, 0x56, 0x61, 0x6c, 0x75, 0x65)
	if err != nil {
		return
	}
	err = en.WriteString(z.Value)
	if err != nil {
		err = msgp.WrapError(err, "Value")
		return
	}
	// write "Children"
	err = en.Append(0xa8, 0x43, 0x68, 0x69, 0x6c, 0x64, 0x72, 0x65, 0x6e)
	if err != nil {
		return
	}
	err = en.WriteArrayHeader(uint32(len(z.Children)))
	if err != nil {
		err = msgp.WrapError(err, "Children")
		return
	}
	for za0001 := range z.Children {
		// map header, size 2
		// write "Value"
		err = en.Append(0x82, 0xa5, 0x56, 0x61, 0x6c, 0x75, 0x65)
		if err != nil {
			return
		}
		err = en.WriteInt32(z.Children[za0001].Value)
		if err != nil {
			err = msgp.WrapError(err, "Children", za0001, "Value")
			return
		}
		// write "Link"
		err = en.Append(0xa4, 0x4c, 0x69, 0x6e, 0x6b)
		if err != nil {
			return
		}
		if z.Children[za0001].Link == nil {
			err = en.WriteNil()
			if err != nil {
				return
			}
		} else {
			err = z.Children[za0001].Link.EncodeMsg(en)
			if err != nil {
				err = msgp.WrapError(err, "Children", za0001, "Link")
				return
			}
		}
	}
	// write "End"
	err = en.Append(0xa3, 0x45, 0x6e, 0x64)
	if err != nil {
		return
	}
	err = en.WriteBool(z.End)
	if err != nil {
		err = msgp.WrapError(err, "End")
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *Trie) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 3
	// string "Value"
	o = append(o, 0x83, 0xa5, 0x56, 0x61, 0x6c, 0x75, 0x65)
	o = msgp.AppendString(o, z.Value)
	// string "Children"
	o = append(o, 0xa8, 0x43, 0x68, 0x69, 0x6c, 0x64, 0x72, 0x65, 0x6e)
	o = msgp.AppendArrayHeader(o, uint32(len(z.Children)))
	for za0001 := range z.Children {
		// map header, size 2
		// string "Value"
		o = append(o, 0x82, 0xa5, 0x56, 0x61, 0x6c, 0x75, 0x65)
		o = msgp.AppendInt32(o, z.Children[za0001].Value)
		// string "Link"
		o = append(o, 0xa4, 0x4c, 0x69, 0x6e, 0x6b)
		if z.Children[za0001].Link == nil {
			o = msgp.AppendNil(o)
		} else {
			o, err = z.Children[za0001].Link.MarshalMsg(o)
			if err != nil {
				err = msgp.WrapError(err, "Children", za0001, "Link")
				return
			}
		}
	}
	// string "End"
	o = append(o, 0xa3, 0x45, 0x6e, 0x64)
	o = msgp.AppendBool(o, z.End)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *Trie) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "Value":
			z.Value, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Value")
				return
			}
		case "Children":
			var zb0002 uint32
			zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Children")
				return
			}
			if cap(z.Children) >= int(zb0002) {
				z.Children = (z.Children)[:zb0002]
			} else {
				z.Children = make([]Child, zb0002)
			}
			for za0001 := range z.Children {
				var zb0003 uint32
				zb0003, bts, err = msgp.ReadMapHeaderBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "Children", za0001)
					return
				}
				for zb0003 > 0 {
					zb0003--
					field, bts, err = msgp.ReadMapKeyZC(bts)
					if err != nil {
						err = msgp.WrapError(err, "Children", za0001)
						return
					}
					switch msgp.UnsafeString(field) {
					case "Value":
						z.Children[za0001].Value, bts, err = msgp.ReadInt32Bytes(bts)
						if err != nil {
							err = msgp.WrapError(err, "Children", za0001, "Value")
							return
						}
					case "Link":
						if msgp.IsNil(bts) {
							bts, err = msgp.ReadNilBytes(bts)
							if err != nil {
								return
							}
							z.Children[za0001].Link = nil
						} else {
							if z.Children[za0001].Link == nil {
								z.Children[za0001].Link = new(Trie)
							}
							bts, err = z.Children[za0001].Link.UnmarshalMsg(bts)
							if err != nil {
								err = msgp.WrapError(err, "Children", za0001, "Link")
								return
							}
						}
					default:
						bts, err = msgp.Skip(bts)
						if err != nil {
							err = msgp.WrapError(err, "Children", za0001)
							return
						}
					}
				}
			}
		case "End":
			z.End, bts, err = msgp.ReadBoolBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "End")
				return
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *Trie) Msgsize() (s int) {
	s = 1 + 6 + msgp.StringPrefixSize + len(z.Value) + 9 + msgp.ArrayHeaderSize
	for za0001 := range z.Children {
		s += 1 + 6 + msgp.Int32Size + 5
		if z.Children[za0001].Link == nil {
			s += msgp.NilSize
		} else {
			s += z.Children[za0001].Link.Msgsize()
		}
	}
	s += 4 + msgp.BoolSize
	return
}