index_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 *DocList) 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(DocList, 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 DocList) 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 DocList) 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 *DocList) 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(DocList, 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 DocList) Msgsize() (s int) {
	s = msgp.ArrayHeaderSize
	for zb0003 := range z {
		s += z[zb0003].Msgsize()
	}
	return
}

// DecodeMsg implements msgp.Decodable
func (z *DocRelevance) 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 "Document":
			z.Document, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Document")
				return
			}
		case "Count":
			z.Count, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "Count")
				return
			}
		case "Distance":
			z.Distance, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "Distance")
				return
			}
		case "Rank":
			z.Rank, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "Rank")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *DocRelevance) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 4
	// write "Document"
	err = en.Append(0x84, 0xa8, 0x44, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74)
	if err != nil {
		return
	}
	err = en.WriteString(z.Document)
	if err != nil {
		err = msgp.WrapError(err, "Document")
		return
	}
	// write "Count"
	err = en.Append(0xa5, 0x43, 0x6f, 0x75, 0x6e, 0x74)
	if err != nil {
		return
	}
	err = en.WriteInt(z.Count)
	if err != nil {
		err = msgp.WrapError(err, "Count")
		return
	}
	// write "Distance"
	err = en.Append(0xa8, 0x44, 0x69, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65)
	if err != nil {
		return
	}
	err = en.WriteInt(z.Distance)
	if err != nil {
		err = msgp.WrapError(err, "Distance")
		return
	}
	// write "Rank"
	err = en.Append(0xa4, 0x52, 0x61, 0x6e, 0x6b)
	if err != nil {
		return
	}
	err = en.WriteInt(z.Rank)
	if err != nil {
		err = msgp.WrapError(err, "Rank")
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *DocRelevance) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 4
	// string "Document"
	o = append(o, 0x84, 0xa8, 0x44, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74)
	o = msgp.AppendString(o, z.Document)
	// string "Count"
	o = append(o, 0xa5, 0x43, 0x6f, 0x75, 0x6e, 0x74)
	o = msgp.AppendInt(o, z.Count)
	// string "Distance"
	o = append(o, 0xa8, 0x44, 0x69, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65)
	o = msgp.AppendInt(o, z.Distance)
	// string "Rank"
	o = append(o, 0xa4, 0x52, 0x61, 0x6e, 0x6b)
	o = msgp.AppendInt(o, z.Rank)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *DocRelevance) 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 "Document":
			z.Document, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Document")
				return
			}
		case "Count":
			z.Count, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Count")
				return
			}
		case "Distance":
			z.Distance, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Distance")
				return
			}
		case "Rank":
			z.Rank, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Rank")
				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 *DocRelevance) Msgsize() (s int) {
	s = 1 + 9 + msgp.StringPrefixSize + len(z.Document) + 6 + msgp.IntSize + 9 + msgp.IntSize + 5 + msgp.IntSize
	return
}

// DecodeMsg implements msgp.Decodable
func (z *Document) 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 "WordCount":
			var zb0002 uint32
			zb0002, err = dc.ReadMapHeader()
			if err != nil {
				err = msgp.WrapError(err, "WordCount")
				return
			}
			if z.WordCount == nil {
				z.WordCount = make(map[string]int, zb0002)
			} else if len(z.WordCount) > 0 {
				for key := range z.WordCount {
					delete(z.WordCount, key)
				}
			}
			for zb0002 > 0 {
				zb0002--
				var za0001 string
				var za0002 int
				za0001, err = dc.ReadString()
				if err != nil {
					err = msgp.WrapError(err, "WordCount")
					return
				}
				za0002, err = dc.ReadInt()
				if err != nil {
					err = msgp.WrapError(err, "WordCount", za0001)
					return
				}
				z.WordCount[za0001] = za0002
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *Document) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 2
	// write "Name"
	err = en.Append(0x82, 0xa4, 0x4e, 0x61, 0x6d, 0x65)
	if err != nil {
		return
	}
	err = en.WriteString(z.Name)
	if err != nil {
		err = msgp.WrapError(err, "Name")
		return
	}
	// write "WordCount"
	err = en.Append(0xa9, 0x57, 0x6f, 0x72, 0x64, 0x43, 0x6f, 0x75, 0x6e, 0x74)
	if err != nil {
		return
	}
	err = en.WriteMapHeader(uint32(len(z.WordCount)))
	if err != nil {
		err = msgp.WrapError(err, "WordCount")
		return
	}
	for za0001, za0002 := range z.WordCount {
		err = en.WriteString(za0001)
		if err != nil {
			err = msgp.WrapError(err, "WordCount")
			return
		}
		err = en.WriteInt(za0002)
		if err != nil {
			err = msgp.WrapError(err, "WordCount", za0001)
			return
		}
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *Document) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 2
	// string "Name"
	o = append(o, 0x82, 0xa4, 0x4e, 0x61, 0x6d, 0x65)
	o = msgp.AppendString(o, z.Name)
	// string "WordCount"
	o = append(o, 0xa9, 0x57, 0x6f, 0x72, 0x64, 0x43, 0x6f, 0x75, 0x6e, 0x74)
	o = msgp.AppendMapHeader(o, uint32(len(z.WordCount)))
	for za0001, za0002 := range z.WordCount {
		o = msgp.AppendString(o, za0001)
		o = msgp.AppendInt(o, za0002)
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *Document) 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 "WordCount":
			var zb0002 uint32
			zb0002, bts, err = msgp.ReadMapHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "WordCount")
				return
			}
			if z.WordCount == nil {
				z.WordCount = make(map[string]int, zb0002)
			} else if len(z.WordCount) > 0 {
				for key := range z.WordCount {
					delete(z.WordCount, key)
				}
			}
			for zb0002 > 0 {
				var za0001 string
				var za0002 int
				zb0002--
				za0001, bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "WordCount")
					return
				}
				za0002, bts, err = msgp.ReadIntBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "WordCount", za0001)
					return
				}
				z.WordCount[za0001] = za0002
			}
		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 *Document) Msgsize() (s int) {
	s = 1 + 5 + msgp.StringPrefixSize + len(z.Name) + 10 + msgp.MapHeaderSize
	if z.WordCount != nil {
		for za0001, za0002 := range z.WordCount {
			_ = za0002
			s += msgp.StringPrefixSize + len(za0001) + msgp.IntSize
		}
	}
	return
}

// DecodeMsg implements msgp.Decodable
func (z *Index) 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 "Words":
			var zb0002 uint32
			zb0002, err = dc.ReadMapHeader()
			if err != nil {
				err = msgp.WrapError(err, "Words")
				return
			}
			if z.Words == nil {
				z.Words = make(map[string]*WordColumn, zb0002)
			} else if len(z.Words) > 0 {
				for key := range z.Words {
					delete(z.Words, key)
				}
			}
			for zb0002 > 0 {
				zb0002--
				var za0001 string
				var za0002 *WordColumn
				za0001, err = dc.ReadString()
				if err != nil {
					err = msgp.WrapError(err, "Words")
					return
				}
				if dc.IsNil() {
					err = dc.ReadNil()
					if err != nil {
						err = msgp.WrapError(err, "Words", za0001)
						return
					}
					za0002 = nil
				} else {
					if za0002 == nil {
						za0002 = new(WordColumn)
					}
					err = za0002.DecodeMsg(dc)
					if err != nil {
						err = msgp.WrapError(err, "Words", za0001)
						return
					}
				}
				z.Words[za0001] = za0002
			}
		case "Names":
			var zb0003 uint32
			zb0003, err = dc.ReadArrayHeader()
			if err != nil {
				err = msgp.WrapError(err, "Names")
				return
			}
			if cap(z.Names) >= int(zb0003) {
				z.Names = (z.Names)[:zb0003]
			} else {
				z.Names = make([]string, zb0003)
			}
			for za0003 := range z.Names {
				z.Names[za0003], err = dc.ReadString()
				if err != nil {
					err = msgp.WrapError(err, "Names", za0003)
					return
				}
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *Index) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 2
	// write "Words"
	err = en.Append(0x82, 0xa5, 0x57, 0x6f, 0x72, 0x64, 0x73)
	if err != nil {
		return
	}
	err = en.WriteMapHeader(uint32(len(z.Words)))
	if err != nil {
		err = msgp.WrapError(err, "Words")
		return
	}
	for za0001, za0002 := range z.Words {
		err = en.WriteString(za0001)
		if err != nil {
			err = msgp.WrapError(err, "Words")
			return
		}
		if za0002 == nil {
			err = en.WriteNil()
			if err != nil {
				return
			}
		} else {
			err = za0002.EncodeMsg(en)
			if err != nil {
				err = msgp.WrapError(err, "Words", za0001)
				return
			}
		}
	}
	// write "Names"
	err = en.Append(0xa5, 0x4e, 0x61, 0x6d, 0x65, 0x73)
	if err != nil {
		return
	}
	err = en.WriteArrayHeader(uint32(len(z.Names)))
	if err != nil {
		err = msgp.WrapError(err, "Names")
		return
	}
	for za0003 := range z.Names {
		err = en.WriteString(z.Names[za0003])
		if err != nil {
			err = msgp.WrapError(err, "Names", za0003)
			return
		}
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *Index) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 2
	// string "Words"
	o = append(o, 0x82, 0xa5, 0x57, 0x6f, 0x72, 0x64, 0x73)
	o = msgp.AppendMapHeader(o, uint32(len(z.Words)))
	for za0001, za0002 := range z.Words {
		o = msgp.AppendString(o, za0001)
		if za0002 == nil {
			o = msgp.AppendNil(o)
		} else {
			o, err = za0002.MarshalMsg(o)
			if err != nil {
				err = msgp.WrapError(err, "Words", za0001)
				return
			}
		}
	}
	// string "Names"
	o = append(o, 0xa5, 0x4e, 0x61, 0x6d, 0x65, 0x73)
	o = msgp.AppendArrayHeader(o, uint32(len(z.Names)))
	for za0003 := range z.Names {
		o = msgp.AppendString(o, z.Names[za0003])
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *Index) 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 "Words":
			var zb0002 uint32
			zb0002, bts, err = msgp.ReadMapHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Words")
				return
			}
			if z.Words == nil {
				z.Words = make(map[string]*WordColumn, zb0002)
			} else if len(z.Words) > 0 {
				for key := range z.Words {
					delete(z.Words, key)
				}
			}
			for zb0002 > 0 {
				var za0001 string
				var za0002 *WordColumn
				zb0002--
				za0001, bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "Words")
					return
				}
				if msgp.IsNil(bts) {
					bts, err = msgp.ReadNilBytes(bts)
					if err != nil {
						return
					}
					za0002 = nil
				} else {
					if za0002 == nil {
						za0002 = new(WordColumn)
					}
					bts, err = za0002.UnmarshalMsg(bts)
					if err != nil {
						err = msgp.WrapError(err, "Words", za0001)
						return
					}
				}
				z.Words[za0001] = za0002
			}
		case "Names":
			var zb0003 uint32
			zb0003, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Names")
				return
			}
			if cap(z.Names) >= int(zb0003) {
				z.Names = (z.Names)[:zb0003]
			} else {
				z.Names = make([]string, zb0003)
			}
			for za0003 := range z.Names {
				z.Names[za0003], bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "Names", za0003)
					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 *Index) Msgsize() (s int) {
	s = 1 + 6 + msgp.MapHeaderSize
	if z.Words != nil {
		for za0001, za0002 := range z.Words {
			_ = za0002
			s += msgp.StringPrefixSize + len(za0001)
			if za0002 == nil {
				s += msgp.NilSize
			} else {
				s += za0002.Msgsize()
			}
		}
	}
	s += 6 + msgp.ArrayHeaderSize
	for za0003 := range z.Names {
		s += msgp.StringPrefixSize + len(z.Names[za0003])
	}
	return
}

// DecodeMsg implements msgp.Decodable
func (z *Score) 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 "Document":
			z.Document, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Document")
				return
			}
		case "Rank":
			z.Rank, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "Rank")
				return
			}
		case "NameDistance":
			z.NameDistance, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "NameDistance")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z Score) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 3
	// write "Document"
	err = en.Append(0x83, 0xa8, 0x44, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74)
	if err != nil {
		return
	}
	err = en.WriteString(z.Document)
	if err != nil {
		err = msgp.WrapError(err, "Document")
		return
	}
	// write "Rank"
	err = en.Append(0xa4, 0x52, 0x61, 0x6e, 0x6b)
	if err != nil {
		return
	}
	err = en.WriteInt(z.Rank)
	if err != nil {
		err = msgp.WrapError(err, "Rank")
		return
	}
	// write "NameDistance"
	err = en.Append(0xac, 0x4e, 0x61, 0x6d, 0x65, 0x44, 0x69, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65)
	if err != nil {
		return
	}
	err = en.WriteInt(z.NameDistance)
	if err != nil {
		err = msgp.WrapError(err, "NameDistance")
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z Score) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 3
	// string "Document"
	o = append(o, 0x83, 0xa8, 0x44, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74)
	o = msgp.AppendString(o, z.Document)
	// string "Rank"
	o = append(o, 0xa4, 0x52, 0x61, 0x6e, 0x6b)
	o = msgp.AppendInt(o, z.Rank)
	// string "NameDistance"
	o = append(o, 0xac, 0x4e, 0x61, 0x6d, 0x65, 0x44, 0x69, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65)
	o = msgp.AppendInt(o, z.NameDistance)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *Score) 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 "Document":
			z.Document, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Document")
				return
			}
		case "Rank":
			z.Rank, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Rank")
				return
			}
		case "NameDistance":
			z.NameDistance, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "NameDistance")
				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 Score) Msgsize() (s int) {
	s = 1 + 9 + msgp.StringPrefixSize + len(z.Document) + 5 + msgp.IntSize + 13 + msgp.IntSize
	return
}

// DecodeMsg implements msgp.Decodable
func (z *ScoreList) 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(ScoreList, 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 "Document":
				(*z)[zb0001].Document, err = dc.ReadString()
				if err != nil {
					err = msgp.WrapError(err, zb0001, "Document")
					return
				}
			case "Rank":
				(*z)[zb0001].Rank, err = dc.ReadInt()
				if err != nil {
					err = msgp.WrapError(err, zb0001, "Rank")
					return
				}
			case "NameDistance":
				(*z)[zb0001].NameDistance, err = dc.ReadInt()
				if err != nil {
					err = msgp.WrapError(err, zb0001, "NameDistance")
					return
				}
			default:
				err = dc.Skip()
				if err != nil {
					err = msgp.WrapError(err, zb0001)
					return
				}
			}
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z ScoreList) 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 "Document"
		err = en.Append(0x83, 0xa8, 0x44, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74)
		if err != nil {
			return
		}
		err = en.WriteString(z[zb0004].Document)
		if err != nil {
			err = msgp.WrapError(err, zb0004, "Document")
			return
		}
		// write "Rank"
		err = en.Append(0xa4, 0x52, 0x61, 0x6e, 0x6b)
		if err != nil {
			return
		}
		err = en.WriteInt(z[zb0004].Rank)
		if err != nil {
			err = msgp.WrapError(err, zb0004, "Rank")
			return
		}
		// write "NameDistance"
		err = en.Append(0xac, 0x4e, 0x61, 0x6d, 0x65, 0x44, 0x69, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65)
		if err != nil {
			return
		}
		err = en.WriteInt(z[zb0004].NameDistance)
		if err != nil {
			err = msgp.WrapError(err, zb0004, "NameDistance")
			return
		}
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z ScoreList) 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 "Document"
		o = append(o, 0x83, 0xa8, 0x44, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74)
		o = msgp.AppendString(o, z[zb0004].Document)
		// string "Rank"
		o = append(o, 0xa4, 0x52, 0x61, 0x6e, 0x6b)
		o = msgp.AppendInt(o, z[zb0004].Rank)
		// string "NameDistance"
		o = append(o, 0xac, 0x4e, 0x61, 0x6d, 0x65, 0x44, 0x69, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65)
		o = msgp.AppendInt(o, z[zb0004].NameDistance)
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *ScoreList) 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(ScoreList, 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 "Document":
				(*z)[zb0001].Document, bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, zb0001, "Document")
					return
				}
			case "Rank":
				(*z)[zb0001].Rank, bts, err = msgp.ReadIntBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, zb0001, "Rank")
					return
				}
			case "NameDistance":
				(*z)[zb0001].NameDistance, bts, err = msgp.ReadIntBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, zb0001, "NameDistance")
					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 ScoreList) Msgsize() (s int) {
	s = msgp.ArrayHeaderSize
	for zb0004 := range z {
		s += 1 + 9 + msgp.StringPrefixSize + len(z[zb0004].Document) + 5 + msgp.IntSize + 13 + msgp.IntSize
	}
	return
}

// DecodeMsg implements msgp.Decodable
func (z *Scores) DecodeMsg(dc *msgp.Reader) (err error) {
	var zb0003 uint32
	zb0003, err = dc.ReadMapHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if (*z) == nil {
		(*z) = make(Scores, zb0003)
	} else if len((*z)) > 0 {
		for key := range *z {
			delete((*z), key)
		}
	}
	for zb0003 > 0 {
		zb0003--
		var zb0001 string
		var zb0002 int
		zb0001, err = dc.ReadString()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		zb0002, err = dc.ReadInt()
		if err != nil {
			err = msgp.WrapError(err, zb0001)
			return
		}
		(*z)[zb0001] = zb0002
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z Scores) EncodeMsg(en *msgp.Writer) (err error) {
	err = en.WriteMapHeader(uint32(len(z)))
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0004, zb0005 := range z {
		err = en.WriteString(zb0004)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		err = en.WriteInt(zb0005)
		if err != nil {
			err = msgp.WrapError(err, zb0004)
			return
		}
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z Scores) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	o = msgp.AppendMapHeader(o, uint32(len(z)))
	for zb0004, zb0005 := range z {
		o = msgp.AppendString(o, zb0004)
		o = msgp.AppendInt(o, zb0005)
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *Scores) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var zb0003 uint32
	zb0003, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if (*z) == nil {
		(*z) = make(Scores, zb0003)
	} else if len((*z)) > 0 {
		for key := range *z {
			delete((*z), key)
		}
	}
	for zb0003 > 0 {
		var zb0001 string
		var zb0002 int
		zb0003--
		zb0001, bts, err = msgp.ReadStringBytes(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		zb0002, bts, err = msgp.ReadIntBytes(bts)
		if err != nil {
			err = msgp.WrapError(err, zb0001)
			return
		}
		(*z)[zb0001] = zb0002
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z Scores) Msgsize() (s int) {
	s = msgp.MapHeaderSize
	if z != nil {
		for zb0004, zb0005 := range z {
			_ = zb0005
			s += msgp.StringPrefixSize + len(zb0004) + msgp.IntSize
		}
	}
	return
}

// DecodeMsg implements msgp.Decodable
func (z *StrSet) DecodeMsg(dc *msgp.Reader) (err error) {
	var zb0003 uint32
	zb0003, err = dc.ReadMapHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if (*z) == nil {
		(*z) = make(StrSet, zb0003)
	} else if len((*z)) > 0 {
		for key := range *z {
			delete((*z), key)
		}
	}
	for zb0003 > 0 {
		zb0003--
		var zb0001 string
		var zb0002 bool
		zb0001, err = dc.ReadString()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		zb0002, err = dc.ReadBool()
		if err != nil {
			err = msgp.WrapError(err, zb0001)
			return
		}
		(*z)[zb0001] = zb0002
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z StrSet) EncodeMsg(en *msgp.Writer) (err error) {
	err = en.WriteMapHeader(uint32(len(z)))
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0004, zb0005 := range z {
		err = en.WriteString(zb0004)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		err = en.WriteBool(zb0005)
		if err != nil {
			err = msgp.WrapError(err, zb0004)
			return
		}
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z StrSet) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	o = msgp.AppendMapHeader(o, uint32(len(z)))
	for zb0004, zb0005 := range z {
		o = msgp.AppendString(o, zb0004)
		o = msgp.AppendBool(o, zb0005)
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *StrSet) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var zb0003 uint32
	zb0003, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	if (*z) == nil {
		(*z) = make(StrSet, zb0003)
	} else if len((*z)) > 0 {
		for key := range *z {
			delete((*z), key)
		}
	}
	for zb0003 > 0 {
		var zb0001 string
		var zb0002 bool
		zb0003--
		zb0001, bts, err = msgp.ReadStringBytes(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		zb0002, bts, err = msgp.ReadBoolBytes(bts)
		if err != nil {
			err = msgp.WrapError(err, zb0001)
			return
		}
		(*z)[zb0001] = zb0002
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z StrSet) Msgsize() (s int) {
	s = msgp.MapHeaderSize
	if z != nil {
		for zb0004, zb0005 := range z {
			_ = zb0005
			s += msgp.StringPrefixSize + len(zb0004) + msgp.BoolSize
		}
	}
	return
}

// DecodeMsg implements msgp.Decodable
func (z *WordColumn) 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 "Docs":
			var zb0002 uint32
			zb0002, err = dc.ReadArrayHeader()
			if err != nil {
				err = msgp.WrapError(err, "Docs")
				return
			}
			if cap(z.Docs) >= int(zb0002) {
				z.Docs = (z.Docs)[:zb0002]
			} else {
				z.Docs = make([][2]int, zb0002)
			}
			for za0001 := range z.Docs {
				var zb0003 uint32
				zb0003, err = dc.ReadArrayHeader()
				if err != nil {
					err = msgp.WrapError(err, "Docs", za0001)
					return
				}
				if zb0003 != uint32(2) {
					err = msgp.ArrayError{Wanted: uint32(2), Got: zb0003}
					return
				}
				for za0002 := range z.Docs[za0001] {
					z.Docs[za0001][za0002], err = dc.ReadInt()
					if err != nil {
						err = msgp.WrapError(err, "Docs", za0001, za0002)
						return
					}
				}
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *WordColumn) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 2
	// write "Name"
	err = en.Append(0x82, 0xa4, 0x4e, 0x61, 0x6d, 0x65)
	if err != nil {
		return
	}
	err = en.WriteString(z.Name)
	if err != nil {
		err = msgp.WrapError(err, "Name")
		return
	}
	// write "Docs"
	err = en.Append(0xa4, 0x44, 0x6f, 0x63, 0x73)
	if err != nil {
		return
	}
	err = en.WriteArrayHeader(uint32(len(z.Docs)))
	if err != nil {
		err = msgp.WrapError(err, "Docs")
		return
	}
	for za0001 := range z.Docs {
		err = en.WriteArrayHeader(uint32(2))
		if err != nil {
			err = msgp.WrapError(err, "Docs", za0001)
			return
		}
		for za0002 := range z.Docs[za0001] {
			err = en.WriteInt(z.Docs[za0001][za0002])
			if err != nil {
				err = msgp.WrapError(err, "Docs", za0001, za0002)
				return
			}
		}
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *WordColumn) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 2
	// string "Name"
	o = append(o, 0x82, 0xa4, 0x4e, 0x61, 0x6d, 0x65)
	o = msgp.AppendString(o, z.Name)
	// string "Docs"
	o = append(o, 0xa4, 0x44, 0x6f, 0x63, 0x73)
	o = msgp.AppendArrayHeader(o, uint32(len(z.Docs)))
	for za0001 := range z.Docs {
		o = msgp.AppendArrayHeader(o, uint32(2))
		for za0002 := range z.Docs[za0001] {
			o = msgp.AppendInt(o, z.Docs[za0001][za0002])
		}
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *WordColumn) 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 "Docs":
			var zb0002 uint32
			zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Docs")
				return
			}
			if cap(z.Docs) >= int(zb0002) {
				z.Docs = (z.Docs)[:zb0002]
			} else {
				z.Docs = make([][2]int, zb0002)
			}
			for za0001 := range z.Docs {
				var zb0003 uint32
				zb0003, bts, err = msgp.ReadArrayHeaderBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "Docs", za0001)
					return
				}
				if zb0003 != uint32(2) {
					err = msgp.ArrayError{Wanted: uint32(2), Got: zb0003}
					return
				}
				for za0002 := range z.Docs[za0001] {
					z.Docs[za0001][za0002], bts, err = msgp.ReadIntBytes(bts)
					if err != nil {
						err = msgp.WrapError(err, "Docs", za0001, za0002)
						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 *WordColumn) Msgsize() (s int) {
	s = 1 + 5 + msgp.StringPrefixSize + len(z.Name) + 5 + msgp.ArrayHeaderSize + (len(z.Docs) * (2 * (msgp.IntSize)))
	return
}

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

// EncodeMsg implements msgp.Encodable
func (z WordDist) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 2
	// write "Word"
	err = en.Append(0x82, 0xa4, 0x57, 0x6f, 0x72, 0x64)
	if err != nil {
		return
	}
	err = en.WriteString(z.Word)
	if err != nil {
		err = msgp.WrapError(err, "Word")
		return
	}
	// write "Distance"
	err = en.Append(0xa8, 0x44, 0x69, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65)
	if err != nil {
		return
	}
	err = en.WriteInt(z.Distance)
	if err != nil {
		err = msgp.WrapError(err, "Distance")
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z WordDist) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 2
	// string "Word"
	o = append(o, 0x82, 0xa4, 0x57, 0x6f, 0x72, 0x64)
	o = msgp.AppendString(o, z.Word)
	// string "Distance"
	o = append(o, 0xa8, 0x44, 0x69, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65)
	o = msgp.AppendInt(o, z.Distance)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *WordDist) 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 "Word":
			z.Word, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Word")
				return
			}
		case "Distance":
			z.Distance, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Distance")
				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 WordDist) Msgsize() (s int) {
	s = 1 + 5 + msgp.StringPrefixSize + len(z.Word) + 9 + msgp.IntSize
	return
}

// DecodeMsg implements msgp.Decodable
func (z *Words) 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(Words, 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 "Word":
				(*z)[zb0001].Word, err = dc.ReadString()
				if err != nil {
					err = msgp.WrapError(err, zb0001, "Word")
					return
				}
			case "Distance":
				(*z)[zb0001].Distance, err = dc.ReadInt()
				if err != nil {
					err = msgp.WrapError(err, zb0001, "Distance")
					return
				}
			default:
				err = dc.Skip()
				if err != nil {
					err = msgp.WrapError(err, zb0001)
					return
				}
			}
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z Words) 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 2
		// write "Word"
		err = en.Append(0x82, 0xa4, 0x57, 0x6f, 0x72, 0x64)
		if err != nil {
			return
		}
		err = en.WriteString(z[zb0004].Word)
		if err != nil {
			err = msgp.WrapError(err, zb0004, "Word")
			return
		}
		// write "Distance"
		err = en.Append(0xa8, 0x44, 0x69, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65)
		if err != nil {
			return
		}
		err = en.WriteInt(z[zb0004].Distance)
		if err != nil {
			err = msgp.WrapError(err, zb0004, "Distance")
			return
		}
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z Words) 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 2
		// string "Word"
		o = append(o, 0x82, 0xa4, 0x57, 0x6f, 0x72, 0x64)
		o = msgp.AppendString(o, z[zb0004].Word)
		// string "Distance"
		o = append(o, 0xa8, 0x44, 0x69, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65)
		o = msgp.AppendInt(o, z[zb0004].Distance)
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *Words) 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(Words, 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 "Word":
				(*z)[zb0001].Word, bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, zb0001, "Word")
					return
				}
			case "Distance":
				(*z)[zb0001].Distance, bts, err = msgp.ReadIntBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, zb0001, "Distance")
					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 Words) Msgsize() (s int) {
	s = msgp.ArrayHeaderSize
	for zb0004 := range z {
		s += 1 + 5 + msgp.StringPrefixSize + len(z[zb0004].Word) + 9 + msgp.IntSize
	}
	return
}