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

package layertree

import (
	json "encoding/json"
	dom "github.com/chromedp/cdproto/dom"
	easyjson "github.com/mailru/easyjson"
	jlexer "github.com/mailru/easyjson/jlexer"
	jwriter "github.com/mailru/easyjson/jwriter"
)

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

func easyjsonC5a4559bDecodeGithubComChromedpCdprotoLayertree(in *jlexer.Lexer, out *StickyPositionConstraint) {
	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 "stickyBoxRect":
			if in.IsNull() {
				in.Skip()
				out.StickyBoxRect = nil
			} else {
				if out.StickyBoxRect == nil {
					out.StickyBoxRect = new(dom.Rect)
				}
				(*out.StickyBoxRect).UnmarshalEasyJSON(in)
			}
		case "containingBlockRect":
			if in.IsNull() {
				in.Skip()
				out.ContainingBlockRect = nil
			} else {
				if out.ContainingBlockRect == nil {
					out.ContainingBlockRect = new(dom.Rect)
				}
				(*out.ContainingBlockRect).UnmarshalEasyJSON(in)
			}
		case "nearestLayerShiftingStickyBox":
			out.NearestLayerShiftingStickyBox = LayerID(in.String())
		case "nearestLayerShiftingContainingBlock":
			out.NearestLayerShiftingContainingBlock = LayerID(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoLayertree(out *jwriter.Writer, in StickyPositionConstraint) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"stickyBoxRect\":"
		out.RawString(prefix[1:])
		if in.StickyBoxRect == nil {
			out.RawString("null")
		} else {
			(*in.StickyBoxRect).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"containingBlockRect\":"
		out.RawString(prefix)
		if in.ContainingBlockRect == nil {
			out.RawString("null")
		} else {
			(*in.ContainingBlockRect).MarshalEasyJSON(out)
		}
	}
	if in.NearestLayerShiftingStickyBox != "" {
		const prefix string = ",\"nearestLayerShiftingStickyBox\":"
		out.RawString(prefix)
		out.String(string(in.NearestLayerShiftingStickyBox))
	}
	if in.NearestLayerShiftingContainingBlock != "" {
		const prefix string = ",\"nearestLayerShiftingContainingBlock\":"
		out.RawString(prefix)
		out.String(string(in.NearestLayerShiftingContainingBlock))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *StickyPositionConstraint) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoLayertree(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoLayertree1(in *jlexer.Lexer, out *SnapshotCommandLogReturns) {
	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 "commandLog":
			if in.IsNull() {
				in.Skip()
				out.CommandLog = nil
			} else {
				in.Delim('[')
				if out.CommandLog == nil {
					if !in.IsDelim(']') {
						out.CommandLog = make([]easyjson.RawMessage, 0, 2)
					} else {
						out.CommandLog = []easyjson.RawMessage{}
					}
				} else {
					out.CommandLog = (out.CommandLog)[:0]
				}
				for !in.IsDelim(']') {
					var v1 easyjson.RawMessage
					(v1).UnmarshalEasyJSON(in)
					out.CommandLog = append(out.CommandLog, v1)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoLayertree1(out *jwriter.Writer, in SnapshotCommandLogReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if len(in.CommandLog) != 0 {
		const prefix string = ",\"commandLog\":"
		first = false
		out.RawString(prefix[1:])
		{
			out.RawByte('[')
			for v2, v3 := range in.CommandLog {
				if v2 > 0 {
					out.RawByte(',')
				}
				(v3).MarshalEasyJSON(out)
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SnapshotCommandLogReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoLayertree1(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoLayertree2(in *jlexer.Lexer, out *SnapshotCommandLogParams) {
	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 "snapshotId":
			out.SnapshotID = SnapshotID(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoLayertree2(out *jwriter.Writer, in SnapshotCommandLogParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"snapshotId\":"
		out.RawString(prefix[1:])
		out.String(string(in.SnapshotID))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SnapshotCommandLogParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoLayertree2(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoLayertree3(in *jlexer.Lexer, out *ScrollRect) {
	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 "rect":
			if in.IsNull() {
				in.Skip()
				out.Rect = nil
			} else {
				if out.Rect == nil {
					out.Rect = new(dom.Rect)
				}
				(*out.Rect).UnmarshalEasyJSON(in)
			}
		case "type":
			(out.Type).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoLayertree3(out *jwriter.Writer, in ScrollRect) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"rect\":"
		out.RawString(prefix[1:])
		if in.Rect == nil {
			out.RawString("null")
		} else {
			(*in.Rect).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"type\":"
		out.RawString(prefix)
		(in.Type).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *ScrollRect) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoLayertree3(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoLayertree4(in *jlexer.Lexer, out *ReplaySnapshotReturns) {
	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 "dataURL":
			out.DataURL = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoLayertree4(out *jwriter.Writer, in ReplaySnapshotReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if in.DataURL != "" {
		const prefix string = ",\"dataURL\":"
		first = false
		out.RawString(prefix[1:])
		out.String(string(in.DataURL))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *ReplaySnapshotReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoLayertree4(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoLayertree5(in *jlexer.Lexer, out *ReplaySnapshotParams) {
	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 "snapshotId":
			out.SnapshotID = SnapshotID(in.String())
		case "fromStep":
			out.FromStep = int64(in.Int64())
		case "toStep":
			out.ToStep = int64(in.Int64())
		case "scale":
			out.Scale = float64(in.Float64())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoLayertree5(out *jwriter.Writer, in ReplaySnapshotParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"snapshotId\":"
		out.RawString(prefix[1:])
		out.String(string(in.SnapshotID))
	}
	if in.FromStep != 0 {
		const prefix string = ",\"fromStep\":"
		out.RawString(prefix)
		out.Int64(int64(in.FromStep))
	}
	if in.ToStep != 0 {
		const prefix string = ",\"toStep\":"
		out.RawString(prefix)
		out.Int64(int64(in.ToStep))
	}
	if in.Scale != 0 {
		const prefix string = ",\"scale\":"
		out.RawString(prefix)
		out.Float64(float64(in.Scale))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *ReplaySnapshotParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoLayertree5(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoLayertree6(in *jlexer.Lexer, out *ReleaseSnapshotParams) {
	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 "snapshotId":
			out.SnapshotID = SnapshotID(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoLayertree6(out *jwriter.Writer, in ReleaseSnapshotParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"snapshotId\":"
		out.RawString(prefix[1:])
		out.String(string(in.SnapshotID))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *ReleaseSnapshotParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoLayertree6(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoLayertree7(in *jlexer.Lexer, out *ProfileSnapshotReturns) {
	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 "timings":
			if in.IsNull() {
				in.Skip()
				out.Timings = nil
			} else {
				in.Delim('[')
				if out.Timings == nil {
					if !in.IsDelim(']') {
						out.Timings = make([]PaintProfile, 0, 2)
					} else {
						out.Timings = []PaintProfile{}
					}
				} else {
					out.Timings = (out.Timings)[:0]
				}
				for !in.IsDelim(']') {
					var v4 PaintProfile
					if in.IsNull() {
						in.Skip()
						v4 = nil
					} else {
						in.Delim('[')
						if v4 == nil {
							if !in.IsDelim(']') {
								v4 = make(PaintProfile, 0, 8)
							} else {
								v4 = PaintProfile{}
							}
						} else {
							v4 = (v4)[:0]
						}
						for !in.IsDelim(']') {
							var v5 float64
							v5 = float64(in.Float64())
							v4 = append(v4, v5)
							in.WantComma()
						}
						in.Delim(']')
					}
					out.Timings = append(out.Timings, v4)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoLayertree7(out *jwriter.Writer, in ProfileSnapshotReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if len(in.Timings) != 0 {
		const prefix string = ",\"timings\":"
		first = false
		out.RawString(prefix[1:])
		{
			out.RawByte('[')
			for v6, v7 := range in.Timings {
				if v6 > 0 {
					out.RawByte(',')
				}
				if v7 == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
					out.RawString("null")
				} else {
					out.RawByte('[')
					for v8, v9 := range v7 {
						if v8 > 0 {
							out.RawByte(',')
						}
						out.Float64(float64(v9))
					}
					out.RawByte(']')
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *ProfileSnapshotReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoLayertree7(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoLayertree8(in *jlexer.Lexer, out *ProfileSnapshotParams) {
	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 "snapshotId":
			out.SnapshotID = SnapshotID(in.String())
		case "minRepeatCount":
			out.MinRepeatCount = int64(in.Int64())
		case "minDuration":
			out.MinDuration = float64(in.Float64())
		case "clipRect":
			if in.IsNull() {
				in.Skip()
				out.ClipRect = nil
			} else {
				if out.ClipRect == nil {
					out.ClipRect = new(dom.Rect)
				}
				(*out.ClipRect).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoLayertree8(out *jwriter.Writer, in ProfileSnapshotParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"snapshotId\":"
		out.RawString(prefix[1:])
		out.String(string(in.SnapshotID))
	}
	if in.MinRepeatCount != 0 {
		const prefix string = ",\"minRepeatCount\":"
		out.RawString(prefix)
		out.Int64(int64(in.MinRepeatCount))
	}
	if in.MinDuration != 0 {
		const prefix string = ",\"minDuration\":"
		out.RawString(prefix)
		out.Float64(float64(in.MinDuration))
	}
	if in.ClipRect != nil {
		const prefix string = ",\"clipRect\":"
		out.RawString(prefix)
		(*in.ClipRect).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *ProfileSnapshotParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoLayertree8(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoLayertree9(in *jlexer.Lexer, out *PictureTile) {
	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 "x":
			out.X = float64(in.Float64())
		case "y":
			out.Y = float64(in.Float64())
		case "picture":
			out.Picture = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoLayertree9(out *jwriter.Writer, in PictureTile) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"x\":"
		out.RawString(prefix[1:])
		out.Float64(float64(in.X))
	}
	{
		const prefix string = ",\"y\":"
		out.RawString(prefix)
		out.Float64(float64(in.Y))
	}
	{
		const prefix string = ",\"picture\":"
		out.RawString(prefix)
		out.String(string(in.Picture))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *PictureTile) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoLayertree9(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoLayertree10(in *jlexer.Lexer, out *MakeSnapshotReturns) {
	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 "snapshotId":
			out.SnapshotID = SnapshotID(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoLayertree10(out *jwriter.Writer, in MakeSnapshotReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if in.SnapshotID != "" {
		const prefix string = ",\"snapshotId\":"
		first = false
		out.RawString(prefix[1:])
		out.String(string(in.SnapshotID))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *MakeSnapshotReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoLayertree10(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoLayertree11(in *jlexer.Lexer, out *MakeSnapshotParams) {
	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 "layerId":
			out.LayerID = LayerID(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoLayertree11(out *jwriter.Writer, in MakeSnapshotParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"layerId\":"
		out.RawString(prefix[1:])
		out.String(string(in.LayerID))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *MakeSnapshotParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoLayertree11(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoLayertree12(in *jlexer.Lexer, out *LoadSnapshotReturns) {
	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 "snapshotId":
			out.SnapshotID = SnapshotID(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoLayertree12(out *jwriter.Writer, in LoadSnapshotReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if in.SnapshotID != "" {
		const prefix string = ",\"snapshotId\":"
		first = false
		out.RawString(prefix[1:])
		out.String(string(in.SnapshotID))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *LoadSnapshotReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoLayertree12(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoLayertree13(in *jlexer.Lexer, out *LoadSnapshotParams) {
	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 "tiles":
			if in.IsNull() {
				in.Skip()
				out.Tiles = nil
			} else {
				in.Delim('[')
				if out.Tiles == nil {
					if !in.IsDelim(']') {
						out.Tiles = make([]*PictureTile, 0, 8)
					} else {
						out.Tiles = []*PictureTile{}
					}
				} else {
					out.Tiles = (out.Tiles)[:0]
				}
				for !in.IsDelim(']') {
					var v10 *PictureTile
					if in.IsNull() {
						in.Skip()
						v10 = nil
					} else {
						if v10 == nil {
							v10 = new(PictureTile)
						}
						(*v10).UnmarshalEasyJSON(in)
					}
					out.Tiles = append(out.Tiles, v10)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoLayertree13(out *jwriter.Writer, in LoadSnapshotParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"tiles\":"
		out.RawString(prefix[1:])
		if in.Tiles == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v11, v12 := range in.Tiles {
				if v11 > 0 {
					out.RawByte(',')
				}
				if v12 == nil {
					out.RawString("null")
				} else {
					(*v12).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *LoadSnapshotParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoLayertree13(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoLayertree14(in *jlexer.Lexer, out *Layer) {
	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 "layerId":
			out.LayerID = LayerID(in.String())
		case "parentLayerId":
			out.ParentLayerID = LayerID(in.String())
		case "backendNodeId":
			(out.BackendNodeID).UnmarshalEasyJSON(in)
		case "offsetX":
			out.OffsetX = float64(in.Float64())
		case "offsetY":
			out.OffsetY = float64(in.Float64())
		case "width":
			out.Width = float64(in.Float64())
		case "height":
			out.Height = float64(in.Float64())
		case "transform":
			if in.IsNull() {
				in.Skip()
				out.Transform = nil
			} else {
				in.Delim('[')
				if out.Transform == nil {
					if !in.IsDelim(']') {
						out.Transform = make([]float64, 0, 8)
					} else {
						out.Transform = []float64{}
					}
				} else {
					out.Transform = (out.Transform)[:0]
				}
				for !in.IsDelim(']') {
					var v13 float64
					v13 = float64(in.Float64())
					out.Transform = append(out.Transform, v13)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "anchorX":
			out.AnchorX = float64(in.Float64())
		case "anchorY":
			out.AnchorY = float64(in.Float64())
		case "anchorZ":
			out.AnchorZ = float64(in.Float64())
		case "paintCount":
			out.PaintCount = int64(in.Int64())
		case "drawsContent":
			out.DrawsContent = bool(in.Bool())
		case "invisible":
			out.Invisible = bool(in.Bool())
		case "scrollRects":
			if in.IsNull() {
				in.Skip()
				out.ScrollRects = nil
			} else {
				in.Delim('[')
				if out.ScrollRects == nil {
					if !in.IsDelim(']') {
						out.ScrollRects = make([]*ScrollRect, 0, 8)
					} else {
						out.ScrollRects = []*ScrollRect{}
					}
				} else {
					out.ScrollRects = (out.ScrollRects)[:0]
				}
				for !in.IsDelim(']') {
					var v14 *ScrollRect
					if in.IsNull() {
						in.Skip()
						v14 = nil
					} else {
						if v14 == nil {
							v14 = new(ScrollRect)
						}
						(*v14).UnmarshalEasyJSON(in)
					}
					out.ScrollRects = append(out.ScrollRects, v14)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "stickyPositionConstraint":
			if in.IsNull() {
				in.Skip()
				out.StickyPositionConstraint = nil
			} else {
				if out.StickyPositionConstraint == nil {
					out.StickyPositionConstraint = new(StickyPositionConstraint)
				}
				(*out.StickyPositionConstraint).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoLayertree14(out *jwriter.Writer, in Layer) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"layerId\":"
		out.RawString(prefix[1:])
		out.String(string(in.LayerID))
	}
	if in.ParentLayerID != "" {
		const prefix string = ",\"parentLayerId\":"
		out.RawString(prefix)
		out.String(string(in.ParentLayerID))
	}
	if in.BackendNodeID != 0 {
		const prefix string = ",\"backendNodeId\":"
		out.RawString(prefix)
		out.Int64(int64(in.BackendNodeID))
	}
	{
		const prefix string = ",\"offsetX\":"
		out.RawString(prefix)
		out.Float64(float64(in.OffsetX))
	}
	{
		const prefix string = ",\"offsetY\":"
		out.RawString(prefix)
		out.Float64(float64(in.OffsetY))
	}
	{
		const prefix string = ",\"width\":"
		out.RawString(prefix)
		out.Float64(float64(in.Width))
	}
	{
		const prefix string = ",\"height\":"
		out.RawString(prefix)
		out.Float64(float64(in.Height))
	}
	if len(in.Transform) != 0 {
		const prefix string = ",\"transform\":"
		out.RawString(prefix)
		{
			out.RawByte('[')
			for v15, v16 := range in.Transform {
				if v15 > 0 {
					out.RawByte(',')
				}
				out.Float64(float64(v16))
			}
			out.RawByte(']')
		}
	}
	if in.AnchorX != 0 {
		const prefix string = ",\"anchorX\":"
		out.RawString(prefix)
		out.Float64(float64(in.AnchorX))
	}
	if in.AnchorY != 0 {
		const prefix string = ",\"anchorY\":"
		out.RawString(prefix)
		out.Float64(float64(in.AnchorY))
	}
	if in.AnchorZ != 0 {
		const prefix string = ",\"anchorZ\":"
		out.RawString(prefix)
		out.Float64(float64(in.AnchorZ))
	}
	{
		const prefix string = ",\"paintCount\":"
		out.RawString(prefix)
		out.Int64(int64(in.PaintCount))
	}
	{
		const prefix string = ",\"drawsContent\":"
		out.RawString(prefix)
		out.Bool(bool(in.DrawsContent))
	}
	if in.Invisible {
		const prefix string = ",\"invisible\":"
		out.RawString(prefix)
		out.Bool(bool(in.Invisible))
	}
	if len(in.ScrollRects) != 0 {
		const prefix string = ",\"scrollRects\":"
		out.RawString(prefix)
		{
			out.RawByte('[')
			for v17, v18 := range in.ScrollRects {
				if v17 > 0 {
					out.RawByte(',')
				}
				if v18 == nil {
					out.RawString("null")
				} else {
					(*v18).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	if in.StickyPositionConstraint != nil {
		const prefix string = ",\"stickyPositionConstraint\":"
		out.RawString(prefix)
		(*in.StickyPositionConstraint).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *Layer) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoLayertree14(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoLayertree15(in *jlexer.Lexer, out *EventLayerTreeDidChange) {
	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 "layers":
			if in.IsNull() {
				in.Skip()
				out.Layers = nil
			} else {
				in.Delim('[')
				if out.Layers == nil {
					if !in.IsDelim(']') {
						out.Layers = make([]*Layer, 0, 8)
					} else {
						out.Layers = []*Layer{}
					}
				} else {
					out.Layers = (out.Layers)[:0]
				}
				for !in.IsDelim(']') {
					var v19 *Layer
					if in.IsNull() {
						in.Skip()
						v19 = nil
					} else {
						if v19 == nil {
							v19 = new(Layer)
						}
						(*v19).UnmarshalEasyJSON(in)
					}
					out.Layers = append(out.Layers, v19)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoLayertree15(out *jwriter.Writer, in EventLayerTreeDidChange) {
	out.RawByte('{')
	first := true
	_ = first
	if len(in.Layers) != 0 {
		const prefix string = ",\"layers\":"
		first = false
		out.RawString(prefix[1:])
		{
			out.RawByte('[')
			for v20, v21 := range in.Layers {
				if v20 > 0 {
					out.RawByte(',')
				}
				if v21 == nil {
					out.RawString("null")
				} else {
					(*v21).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventLayerTreeDidChange) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoLayertree15(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoLayertree16(in *jlexer.Lexer, out *EventLayerPainted) {
	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 "layerId":
			out.LayerID = LayerID(in.String())
		case "clip":
			if in.IsNull() {
				in.Skip()
				out.Clip = nil
			} else {
				if out.Clip == nil {
					out.Clip = new(dom.Rect)
				}
				(*out.Clip).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoLayertree16(out *jwriter.Writer, in EventLayerPainted) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"layerId\":"
		out.RawString(prefix[1:])
		out.String(string(in.LayerID))
	}
	{
		const prefix string = ",\"clip\":"
		out.RawString(prefix)
		if in.Clip == nil {
			out.RawString("null")
		} else {
			(*in.Clip).MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventLayerPainted) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoLayertree16(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoLayertree17(in *jlexer.Lexer, out *EnableParams) {
	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.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoLayertree17(out *jwriter.Writer, in EnableParams) {
	out.RawByte('{')
	first := true
	_ = first
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EnableParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoLayertree17(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoLayertree18(in *jlexer.Lexer, out *DisableParams) {
	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.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoLayertree18(out *jwriter.Writer, in DisableParams) {
	out.RawByte('{')
	first := true
	_ = first
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *DisableParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoLayertree18(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoLayertree19(in *jlexer.Lexer, out *CompositingReasonsReturns) {
	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 "compositingReasonIds":
			if in.IsNull() {
				in.Skip()
				out.CompositingReasonIds = nil
			} else {
				in.Delim('[')
				if out.CompositingReasonIds == nil {
					if !in.IsDelim(']') {
						out.CompositingReasonIds = make([]string, 0, 4)
					} else {
						out.CompositingReasonIds = []string{}
					}
				} else {
					out.CompositingReasonIds = (out.CompositingReasonIds)[:0]
				}
				for !in.IsDelim(']') {
					var v22 string
					v22 = string(in.String())
					out.CompositingReasonIds = append(out.CompositingReasonIds, v22)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoLayertree19(out *jwriter.Writer, in CompositingReasonsReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if len(in.CompositingReasonIds) != 0 {
		const prefix string = ",\"compositingReasonIds\":"
		first = false
		out.RawString(prefix[1:])
		{
			out.RawByte('[')
			for v23, v24 := range in.CompositingReasonIds {
				if v23 > 0 {
					out.RawByte(',')
				}
				out.String(string(v24))
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *CompositingReasonsReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoLayertree19(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoLayertree20(in *jlexer.Lexer, out *CompositingReasonsParams) {
	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 "layerId":
			out.LayerID = LayerID(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoLayertree20(out *jwriter.Writer, in CompositingReasonsParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"layerId\":"
		out.RawString(prefix[1:])
		out.String(string(in.LayerID))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *CompositingReasonsParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoLayertree20(l, v)
}
