codies/internal/protocol/protocol_easyjson.go

// Code generated by easyjson for marshaling/unmarshaling. DO NOT EDIT.

package protocol

import (
	json "encoding/json"
	easyjson "github.com/mailru/easyjson"
	jlexer "github.com/mailru/easyjson/jlexer"
	jwriter "github.com/mailru/easyjson/jwriter"
	game "github.com/zikaeroh/codies/internal/game"
)

// suppress unused package warning
var (
	_ *json.RawMessage
	_ *jlexer.Lexer
	_ *jwriter.Writer
	_ easyjson.Marshaler
)

func easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol(in *jlexer.Lexer, out *TimeResponse) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "time":
			if data := in.Raw(); in.Ok() {
				in.AddError((out.Time).UnmarshalJSON(data))
			}
		default:
			in.AddError(&jlexer.LexerError{
				Offset: in.GetPos(),
				Reason: "unknown field",
				Data:   key,
			})
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol(out *jwriter.Writer, in TimeResponse) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"time\":"
		out.RawString(prefix[1:])
		out.Raw((in.Time).MarshalJSON())
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v TimeResponse) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v TimeResponse) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *TimeResponse) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *TimeResponse) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol(l, v)
}
func easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol1(in *jlexer.Lexer, out *StatsResponse) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "rooms":
			out.Rooms = int(in.Int())
		case "clients":
			out.Clients = int(in.Int())
		default:
			in.AddError(&jlexer.LexerError{
				Offset: in.GetPos(),
				Reason: "unknown field",
				Data:   key,
			})
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol1(out *jwriter.Writer, in StatsResponse) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"rooms\":"
		out.RawString(prefix[1:])
		out.Int(int(in.Rooms))
	}
	{
		const prefix string = ",\"clients\":"
		out.RawString(prefix)
		out.Int(int(in.Clients))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v StatsResponse) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol1(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v StatsResponse) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol1(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *StatsResponse) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol1(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *StatsResponse) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol1(l, v)
}
func easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol2(in *jlexer.Lexer, out *StateWordList) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "name":
			out.Name = string(in.String())
		case "count":
			out.Count = int(in.Int())
		case "custom":
			out.Custom = bool(in.Bool())
		case "enabled":
			out.Enabled = bool(in.Bool())
		default:
			in.AddError(&jlexer.LexerError{
				Offset: in.GetPos(),
				Reason: "unknown field",
				Data:   key,
			})
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol2(out *jwriter.Writer, in StateWordList) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"name\":"
		out.RawString(prefix[1:])
		out.String(string(in.Name))
	}
	{
		const prefix string = ",\"count\":"
		out.RawString(prefix)
		out.Int(int(in.Count))
	}
	{
		const prefix string = ",\"custom\":"
		out.RawString(prefix)
		out.Bool(bool(in.Custom))
	}
	{
		const prefix string = ",\"enabled\":"
		out.RawString(prefix)
		out.Bool(bool(in.Enabled))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v StateWordList) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol2(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v StateWordList) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol2(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *StateWordList) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol2(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *StateWordList) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol2(l, v)
}
func easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol3(in *jlexer.Lexer, out *StateView) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "team":
			out.Team = game.Team(in.Int())
		case "neutral":
			out.Neutral = bool(in.Bool())
		case "bomb":
			out.Bomb = bool(in.Bool())
		default:
			in.AddError(&jlexer.LexerError{
				Offset: in.GetPos(),
				Reason: "unknown field",
				Data:   key,
			})
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol3(out *jwriter.Writer, in StateView) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"team\":"
		out.RawString(prefix[1:])
		out.Int(int(in.Team))
	}
	{
		const prefix string = ",\"neutral\":"
		out.RawString(prefix)
		out.Bool(bool(in.Neutral))
	}
	{
		const prefix string = ",\"bomb\":"
		out.RawString(prefix)
		out.Bool(bool(in.Bomb))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v StateView) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol3(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v StateView) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol3(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *StateView) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol3(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *StateView) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol3(l, v)
}
func easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol4(in *jlexer.Lexer, out *StateTimer) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "turnTime":
			out.TurnTime = int(in.Int())
		case "turnEnd":
			if data := in.Raw(); in.Ok() {
				in.AddError((out.TurnEnd).UnmarshalJSON(data))
			}
		default:
			in.AddError(&jlexer.LexerError{
				Offset: in.GetPos(),
				Reason: "unknown field",
				Data:   key,
			})
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol4(out *jwriter.Writer, in StateTimer) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"turnTime\":"
		out.RawString(prefix[1:])
		out.Int(int(in.TurnTime))
	}
	{
		const prefix string = ",\"turnEnd\":"
		out.RawString(prefix)
		out.Raw((in.TurnEnd).MarshalJSON())
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v StateTimer) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol4(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v StateTimer) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol4(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *StateTimer) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol4(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *StateTimer) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol4(l, v)
}
func easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol5(in *jlexer.Lexer, out *StateTile) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "word":
			out.Word = string(in.String())
		case "revealed":
			out.Revealed = bool(in.Bool())
		case "view":
			if in.IsNull() {
				in.Skip()
				out.View = nil
			} else {
				if out.View == nil {
					out.View = new(StateView)
				}
				(*out.View).UnmarshalEasyJSON(in)
			}
		default:
			in.AddError(&jlexer.LexerError{
				Offset: in.GetPos(),
				Reason: "unknown field",
				Data:   key,
			})
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol5(out *jwriter.Writer, in StateTile) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"word\":"
		out.RawString(prefix[1:])
		out.String(string(in.Word))
	}
	{
		const prefix string = ",\"revealed\":"
		out.RawString(prefix)
		out.Bool(bool(in.Revealed))
	}
	{
		const prefix string = ",\"view\":"
		out.RawString(prefix)
		if in.View == nil {
			out.RawString("null")
		} else {
			(*in.View).MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v StateTile) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol5(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v StateTile) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol5(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *StateTile) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol5(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *StateTile) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol5(l, v)
}
func easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol6(in *jlexer.Lexer, out *StatePlayer) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "playerID":
			if data := in.UnsafeBytes(); in.Ok() {
				in.AddError((out.PlayerID).UnmarshalText(data))
			}
		case "nickname":
			out.Nickname = string(in.String())
		case "spymaster":
			out.Spymaster = bool(in.Bool())
		default:
			in.AddError(&jlexer.LexerError{
				Offset: in.GetPos(),
				Reason: "unknown field",
				Data:   key,
			})
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol6(out *jwriter.Writer, in StatePlayer) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"playerID\":"
		out.RawString(prefix[1:])
		out.RawText((in.PlayerID).MarshalText())
	}
	{
		const prefix string = ",\"nickname\":"
		out.RawString(prefix)
		out.String(string(in.Nickname))
	}
	{
		const prefix string = ",\"spymaster\":"
		out.RawString(prefix)
		out.Bool(bool(in.Spymaster))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v StatePlayer) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol6(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v StatePlayer) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol6(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *StatePlayer) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol6(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *StatePlayer) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol6(l, v)
}
func easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol7(in *jlexer.Lexer, out *State) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "version":
			out.Version = int(in.Int())
		case "teams":
			if in.IsNull() {
				in.Skip()
				out.Teams = nil
			} else {
				in.Delim('[')
				if out.Teams == nil {
					if !in.IsDelim(']') {
						out.Teams = make([][]*StatePlayer, 0, 2)
					} else {
						out.Teams = [][]*StatePlayer{}
					}
				} else {
					out.Teams = (out.Teams)[:0]
				}
				for !in.IsDelim(']') {
					var v1 []*StatePlayer
					if in.IsNull() {
						in.Skip()
						v1 = nil
					} else {
						in.Delim('[')
						if v1 == nil {
							if !in.IsDelim(']') {
								v1 = make([]*StatePlayer, 0, 8)
							} else {
								v1 = []*StatePlayer{}
							}
						} else {
							v1 = (v1)[:0]
						}
						for !in.IsDelim(']') {
							var v2 *StatePlayer
							if in.IsNull() {
								in.Skip()
								v2 = nil
							} else {
								if v2 == nil {
									v2 = new(StatePlayer)
								}
								(*v2).UnmarshalEasyJSON(in)
							}
							v1 = append(v1, v2)
							in.WantComma()
						}
						in.Delim(']')
					}
					out.Teams = append(out.Teams, v1)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "turn":
			out.Turn = game.Team(in.Int())
		case "winner":
			if in.IsNull() {
				in.Skip()
				out.Winner = nil
			} else {
				if out.Winner == nil {
					out.Winner = new(game.Team)
				}
				*out.Winner = game.Team(in.Int())
			}
		case "board":
			if in.IsNull() {
				in.Skip()
				out.Board = nil
			} else {
				in.Delim('[')
				if out.Board == nil {
					if !in.IsDelim(']') {
						out.Board = make([][]*StateTile, 0, 2)
					} else {
						out.Board = [][]*StateTile{}
					}
				} else {
					out.Board = (out.Board)[:0]
				}
				for !in.IsDelim(']') {
					var v3 []*StateTile
					if in.IsNull() {
						in.Skip()
						v3 = nil
					} else {
						in.Delim('[')
						if v3 == nil {
							if !in.IsDelim(']') {
								v3 = make([]*StateTile, 0, 8)
							} else {
								v3 = []*StateTile{}
							}
						} else {
							v3 = (v3)[:0]
						}
						for !in.IsDelim(']') {
							var v4 *StateTile
							if in.IsNull() {
								in.Skip()
								v4 = nil
							} else {
								if v4 == nil {
									v4 = new(StateTile)
								}
								(*v4).UnmarshalEasyJSON(in)
							}
							v3 = append(v3, v4)
							in.WantComma()
						}
						in.Delim(']')
					}
					out.Board = append(out.Board, v3)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "wordsLeft":
			if in.IsNull() {
				in.Skip()
				out.WordsLeft = nil
			} else {
				in.Delim('[')
				if out.WordsLeft == nil {
					if !in.IsDelim(']') {
						out.WordsLeft = make([]int, 0, 8)
					} else {
						out.WordsLeft = []int{}
					}
				} else {
					out.WordsLeft = (out.WordsLeft)[:0]
				}
				for !in.IsDelim(']') {
					var v5 int
					v5 = int(in.Int())
					out.WordsLeft = append(out.WordsLeft, v5)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "lists":
			if in.IsNull() {
				in.Skip()
				out.Lists = nil
			} else {
				in.Delim('[')
				if out.Lists == nil {
					if !in.IsDelim(']') {
						out.Lists = make([]*StateWordList, 0, 8)
					} else {
						out.Lists = []*StateWordList{}
					}
				} else {
					out.Lists = (out.Lists)[:0]
				}
				for !in.IsDelim(']') {
					var v6 *StateWordList
					if in.IsNull() {
						in.Skip()
						v6 = nil
					} else {
						if v6 == nil {
							v6 = new(StateWordList)
						}
						(*v6).UnmarshalEasyJSON(in)
					}
					out.Lists = append(out.Lists, v6)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "timer":
			if in.IsNull() {
				in.Skip()
				out.Timer = nil
			} else {
				if out.Timer == nil {
					out.Timer = new(StateTimer)
				}
				(*out.Timer).UnmarshalEasyJSON(in)
			}
		case "hideBomb":
			out.HideBomb = bool(in.Bool())
		default:
			in.AddError(&jlexer.LexerError{
				Offset: in.GetPos(),
				Reason: "unknown field",
				Data:   key,
			})
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol7(out *jwriter.Writer, in State) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"version\":"
		out.RawString(prefix[1:])
		out.Int(int(in.Version))
	}
	{
		const prefix string = ",\"teams\":"
		out.RawString(prefix)
		if in.Teams == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v7, v8 := range in.Teams {
				if v7 > 0 {
					out.RawByte(',')
				}
				if v8 == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
					out.RawString("null")
				} else {
					out.RawByte('[')
					for v9, v10 := range v8 {
						if v9 > 0 {
							out.RawByte(',')
						}
						if v10 == nil {
							out.RawString("null")
						} else {
							(*v10).MarshalEasyJSON(out)
						}
					}
					out.RawByte(']')
				}
			}
			out.RawByte(']')
		}
	}
	{
		const prefix string = ",\"turn\":"
		out.RawString(prefix)
		out.Int(int(in.Turn))
	}
	{
		const prefix string = ",\"winner\":"
		out.RawString(prefix)
		if in.Winner == nil {
			out.RawString("null")
		} else {
			out.Int(int(*in.Winner))
		}
	}
	{
		const prefix string = ",\"board\":"
		out.RawString(prefix)
		if in.Board == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v11, v12 := range in.Board {
				if v11 > 0 {
					out.RawByte(',')
				}
				if v12 == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
					out.RawString("null")
				} else {
					out.RawByte('[')
					for v13, v14 := range v12 {
						if v13 > 0 {
							out.RawByte(',')
						}
						if v14 == nil {
							out.RawString("null")
						} else {
							(*v14).MarshalEasyJSON(out)
						}
					}
					out.RawByte(']')
				}
			}
			out.RawByte(']')
		}
	}
	{
		const prefix string = ",\"wordsLeft\":"
		out.RawString(prefix)
		if in.WordsLeft == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v15, v16 := range in.WordsLeft {
				if v15 > 0 {
					out.RawByte(',')
				}
				out.Int(int(v16))
			}
			out.RawByte(']')
		}
	}
	{
		const prefix string = ",\"lists\":"
		out.RawString(prefix)
		if in.Lists == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v17, v18 := range in.Lists {
				if v17 > 0 {
					out.RawByte(',')
				}
				if v18 == nil {
					out.RawString("null")
				} else {
					(*v18).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	{
		const prefix string = ",\"timer\":"
		out.RawString(prefix)
		if in.Timer == nil {
			out.RawString("null")
		} else {
			(*in.Timer).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"hideBomb\":"
		out.RawString(prefix)
		out.Bool(bool(in.HideBomb))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v State) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol7(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v State) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol7(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *State) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol7(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *State) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol7(l, v)
}
func easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol8(in *jlexer.Lexer, out *ServerNote) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "method":
			out.Method = ServerMethod(in.String())
		case "params":
			if m, ok := out.Params.(easyjson.Unmarshaler); ok {
				m.UnmarshalEasyJSON(in)
			} else if m, ok := out.Params.(json.Unmarshaler); ok {
				_ = m.UnmarshalJSON(in.Raw())
			} else {
				out.Params = in.Interface()
			}
		default:
			in.AddError(&jlexer.LexerError{
				Offset: in.GetPos(),
				Reason: "unknown field",
				Data:   key,
			})
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol8(out *jwriter.Writer, in ServerNote) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"method\":"
		out.RawString(prefix[1:])
		out.String(string(in.Method))
	}
	{
		const prefix string = ",\"params\":"
		out.RawString(prefix)
		if m, ok := in.Params.(easyjson.Marshaler); ok {
			m.MarshalEasyJSON(out)
		} else if m, ok := in.Params.(json.Marshaler); ok {
			out.Raw(m.MarshalJSON())
		} else {
			out.Raw(json.Marshal(in.Params))
		}
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v ServerNote) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol8(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v ServerNote) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol8(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *ServerNote) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol8(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *ServerNote) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol8(l, v)
}
func easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol9(in *jlexer.Lexer, out *RoomResponse) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "id":
			if in.IsNull() {
				in.Skip()
				out.ID = nil
			} else {
				if out.ID == nil {
					out.ID = new(string)
				}
				*out.ID = string(in.String())
			}
		case "error":
			if in.IsNull() {
				in.Skip()
				out.Error = nil
			} else {
				if out.Error == nil {
					out.Error = new(string)
				}
				*out.Error = string(in.String())
			}
		default:
			in.AddError(&jlexer.LexerError{
				Offset: in.GetPos(),
				Reason: "unknown field",
				Data:   key,
			})
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol9(out *jwriter.Writer, in RoomResponse) {
	out.RawByte('{')
	first := true
	_ = first
	if in.ID != nil {
		const prefix string = ",\"id\":"
		first = false
		out.RawString(prefix[1:])
		out.String(string(*in.ID))
	}
	if in.Error != nil {
		const prefix string = ",\"error\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.String(string(*in.Error))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v RoomResponse) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol9(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v RoomResponse) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol9(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *RoomResponse) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol9(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *RoomResponse) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol9(l, v)
}
func easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol10(in *jlexer.Lexer, out *RoomRequest) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "roomName":
			out.RoomName = string(in.String())
		case "roomPass":
			out.RoomPass = string(in.String())
		case "create":
			out.Create = bool(in.Bool())
		default:
			in.AddError(&jlexer.LexerError{
				Offset: in.GetPos(),
				Reason: "unknown field",
				Data:   key,
			})
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol10(out *jwriter.Writer, in RoomRequest) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"roomName\":"
		out.RawString(prefix[1:])
		out.String(string(in.RoomName))
	}
	{
		const prefix string = ",\"roomPass\":"
		out.RawString(prefix)
		out.String(string(in.RoomPass))
	}
	{
		const prefix string = ",\"create\":"
		out.RawString(prefix)
		out.Bool(bool(in.Create))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v RoomRequest) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol10(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v RoomRequest) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol10(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *RoomRequest) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol10(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *RoomRequest) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol10(l, v)
}
func easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol11(in *jlexer.Lexer, out *RevealParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "row":
			out.Row = int(in.Int())
		case "col":
			out.Col = int(in.Int())
		default:
			in.AddError(&jlexer.LexerError{
				Offset: in.GetPos(),
				Reason: "unknown field",
				Data:   key,
			})
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol11(out *jwriter.Writer, in RevealParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"row\":"
		out.RawString(prefix[1:])
		out.Int(int(in.Row))
	}
	{
		const prefix string = ",\"col\":"
		out.RawString(prefix)
		out.Int(int(in.Col))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v RevealParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol11(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v RevealParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol11(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *RevealParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol11(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *RevealParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol11(l, v)
}
func easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol12(in *jlexer.Lexer, out *RemovePackParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "num":
			out.Num = int(in.Int())
		default:
			in.AddError(&jlexer.LexerError{
				Offset: in.GetPos(),
				Reason: "unknown field",
				Data:   key,
			})
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol12(out *jwriter.Writer, in RemovePackParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"num\":"
		out.RawString(prefix[1:])
		out.Int(int(in.Num))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v RemovePackParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol12(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v RemovePackParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol12(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *RemovePackParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol12(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *RemovePackParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol12(l, v)
}
func easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol13(in *jlexer.Lexer, out *RandomizeTeamsParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		default:
			in.AddError(&jlexer.LexerError{
				Offset: in.GetPos(),
				Reason: "unknown field",
				Data:   key,
			})
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol13(out *jwriter.Writer, in RandomizeTeamsParams) {
	out.RawByte('{')
	first := true
	_ = first
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v RandomizeTeamsParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol13(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v RandomizeTeamsParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol13(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *RandomizeTeamsParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol13(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *RandomizeTeamsParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol13(l, v)
}
func easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol14(in *jlexer.Lexer, out *NewGameParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		default:
			in.AddError(&jlexer.LexerError{
				Offset: in.GetPos(),
				Reason: "unknown field",
				Data:   key,
			})
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol14(out *jwriter.Writer, in NewGameParams) {
	out.RawByte('{')
	first := true
	_ = first
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v NewGameParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol14(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v NewGameParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol14(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *NewGameParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol14(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *NewGameParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol14(l, v)
}
func easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol15(in *jlexer.Lexer, out *EndTurnParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		default:
			in.AddError(&jlexer.LexerError{
				Offset: in.GetPos(),
				Reason: "unknown field",
				Data:   key,
			})
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol15(out *jwriter.Writer, in EndTurnParams) {
	out.RawByte('{')
	first := true
	_ = first
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v EndTurnParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol15(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v EndTurnParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol15(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *EndTurnParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol15(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EndTurnParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol15(l, v)
}
func easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol16(in *jlexer.Lexer, out *ClientNote) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "method":
			out.Method = ClientMethod(in.String())
		case "version":
			out.Version = int(in.Int())
		case "params":
			(out.Params).UnmarshalEasyJSON(in)
		default:
			in.AddError(&jlexer.LexerError{
				Offset: in.GetPos(),
				Reason: "unknown field",
				Data:   key,
			})
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol16(out *jwriter.Writer, in ClientNote) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"method\":"
		out.RawString(prefix[1:])
		out.String(string(in.Method))
	}
	{
		const prefix string = ",\"version\":"
		out.RawString(prefix)
		out.Int(int(in.Version))
	}
	{
		const prefix string = ",\"params\":"
		out.RawString(prefix)
		(in.Params).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v ClientNote) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol16(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v ClientNote) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol16(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *ClientNote) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol16(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *ClientNote) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol16(l, v)
}
func easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol17(in *jlexer.Lexer, out *ChangeTurnTimeParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "seconds":
			out.Seconds = int(in.Int())
		default:
			in.AddError(&jlexer.LexerError{
				Offset: in.GetPos(),
				Reason: "unknown field",
				Data:   key,
			})
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol17(out *jwriter.Writer, in ChangeTurnTimeParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"seconds\":"
		out.RawString(prefix[1:])
		out.Int(int(in.Seconds))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v ChangeTurnTimeParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol17(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v ChangeTurnTimeParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol17(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *ChangeTurnTimeParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol17(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *ChangeTurnTimeParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol17(l, v)
}
func easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol18(in *jlexer.Lexer, out *ChangeTurnModeParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "timed":
			out.Timed = bool(in.Bool())
		default:
			in.AddError(&jlexer.LexerError{
				Offset: in.GetPos(),
				Reason: "unknown field",
				Data:   key,
			})
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol18(out *jwriter.Writer, in ChangeTurnModeParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"timed\":"
		out.RawString(prefix[1:])
		out.Bool(bool(in.Timed))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v ChangeTurnModeParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol18(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v ChangeTurnModeParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol18(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *ChangeTurnModeParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol18(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *ChangeTurnModeParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol18(l, v)
}
func easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol19(in *jlexer.Lexer, out *ChangeTeamParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "team":
			out.Team = game.Team(in.Int())
		default:
			in.AddError(&jlexer.LexerError{
				Offset: in.GetPos(),
				Reason: "unknown field",
				Data:   key,
			})
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol19(out *jwriter.Writer, in ChangeTeamParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"team\":"
		out.RawString(prefix[1:])
		out.Int(int(in.Team))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v ChangeTeamParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol19(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v ChangeTeamParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol19(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *ChangeTeamParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol19(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *ChangeTeamParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol19(l, v)
}
func easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol20(in *jlexer.Lexer, out *ChangeRoleParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "spymaster":
			out.Spymaster = bool(in.Bool())
		default:
			in.AddError(&jlexer.LexerError{
				Offset: in.GetPos(),
				Reason: "unknown field",
				Data:   key,
			})
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol20(out *jwriter.Writer, in ChangeRoleParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"spymaster\":"
		out.RawString(prefix[1:])
		out.Bool(bool(in.Spymaster))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v ChangeRoleParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol20(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v ChangeRoleParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol20(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *ChangeRoleParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol20(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *ChangeRoleParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol20(l, v)
}
func easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol21(in *jlexer.Lexer, out *ChangePackParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "num":
			out.Num = int(in.Int())
		case "enable":
			out.Enable = bool(in.Bool())
		default:
			in.AddError(&jlexer.LexerError{
				Offset: in.GetPos(),
				Reason: "unknown field",
				Data:   key,
			})
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol21(out *jwriter.Writer, in ChangePackParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"num\":"
		out.RawString(prefix[1:])
		out.Int(int(in.Num))
	}
	{
		const prefix string = ",\"enable\":"
		out.RawString(prefix)
		out.Bool(bool(in.Enable))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v ChangePackParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol21(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v ChangePackParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol21(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *ChangePackParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol21(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *ChangePackParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol21(l, v)
}
func easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol22(in *jlexer.Lexer, out *ChangeNicknameParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "nickname":
			out.Nickname = string(in.String())
		default:
			in.AddError(&jlexer.LexerError{
				Offset: in.GetPos(),
				Reason: "unknown field",
				Data:   key,
			})
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol22(out *jwriter.Writer, in ChangeNicknameParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"nickname\":"
		out.RawString(prefix[1:])
		out.String(string(in.Nickname))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v ChangeNicknameParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol22(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v ChangeNicknameParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol22(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *ChangeNicknameParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol22(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *ChangeNicknameParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol22(l, v)
}
func easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol23(in *jlexer.Lexer, out *ChangeHideBombParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "hideBomb":
			out.HideBomb = bool(in.Bool())
		default:
			in.AddError(&jlexer.LexerError{
				Offset: in.GetPos(),
				Reason: "unknown field",
				Data:   key,
			})
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol23(out *jwriter.Writer, in ChangeHideBombParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"hideBomb\":"
		out.RawString(prefix[1:])
		out.Bool(bool(in.HideBomb))
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v ChangeHideBombParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol23(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v ChangeHideBombParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol23(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *ChangeHideBombParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol23(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *ChangeHideBombParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol23(l, v)
}
func easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol24(in *jlexer.Lexer, out *AddPacksParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "packs":
			if in.IsNull() {
				in.Skip()
				out.Packs = nil
			} else {
				in.Delim('[')
				if out.Packs == nil {
					if !in.IsDelim(']') {
						out.Packs = make([]struct {
							Name  string   `json:"name"`
							Words []string `json:"words"`
						}, 0, 1)
					} else {
						out.Packs = []struct {
							Name  string   `json:"name"`
							Words []string `json:"words"`
						}{}
					}
				} else {
					out.Packs = (out.Packs)[:0]
				}
				for !in.IsDelim(']') {
					var v19 struct {
						Name  string   `json:"name"`
						Words []string `json:"words"`
					}
					easyjsonE4425964Decode(in, &v19)
					out.Packs = append(out.Packs, v19)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.AddError(&jlexer.LexerError{
				Offset: in.GetPos(),
				Reason: "unknown field",
				Data:   key,
			})
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol24(out *jwriter.Writer, in AddPacksParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"packs\":"
		out.RawString(prefix[1:])
		if in.Packs == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v20, v21 := range in.Packs {
				if v20 > 0 {
					out.RawByte(',')
				}
				easyjsonE4425964Encode(out, v21)
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

// MarshalJSON supports json.Marshaler interface
func (v AddPacksParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol24(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

// MarshalEasyJSON supports easyjson.Marshaler interface
func (v AddPacksParams) MarshalEasyJSON(w *jwriter.Writer) {
	easyjsonE4425964EncodeGithubComZikaerohCodiesInternalProtocol24(w, v)
}

// UnmarshalJSON supports json.Unmarshaler interface
func (v *AddPacksParams) UnmarshalJSON(data []byte) error {
	r := jlexer.Lexer{Data: data}
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol24(&r, v)
	return r.Error()
}

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *AddPacksParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonE4425964DecodeGithubComZikaerohCodiesInternalProtocol24(l, v)
}
func easyjsonE4425964Decode(in *jlexer.Lexer, out *struct {
	Name  string   `json:"name"`
	Words []string `json:"words"`
}) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeString()
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "name":
			out.Name = string(in.String())
		case "words":
			if in.IsNull() {
				in.Skip()
				out.Words = nil
			} else {
				in.Delim('[')
				if out.Words == nil {
					if !in.IsDelim(']') {
						out.Words = make([]string, 0, 4)
					} else {
						out.Words = []string{}
					}
				} else {
					out.Words = (out.Words)[:0]
				}
				for !in.IsDelim(']') {
					var v22 string
					v22 = string(in.String())
					out.Words = append(out.Words, v22)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.AddError(&jlexer.LexerError{
				Offset: in.GetPos(),
				Reason: "unknown field",
				Data:   key,
			})
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonE4425964Encode(out *jwriter.Writer, in struct {
	Name  string   `json:"name"`
	Words []string `json:"words"`
}) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"name\":"
		out.RawString(prefix[1:])
		out.String(string(in.Name))
	}
	{
		const prefix string = ",\"words\":"
		out.RawString(prefix)
		if in.Words == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v23, v24 := range in.Words {
				if v23 > 0 {
					out.RawByte(',')
				}
				out.String(string(v24))
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}