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

package debugger

import (
	json "encoding/json"
	runtime "github.com/chromedp/cdproto/runtime"
	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 easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger(in *jlexer.Lexer, out *WasmDisassemblyChunk) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "lines":
			if in.IsNull() {
				in.Skip()
				out.Lines = nil
			} else {
				in.Delim('[')
				if out.Lines == nil {
					if !in.IsDelim(']') {
						out.Lines = make([]string, 0, 4)
					} else {
						out.Lines = []string{}
					}
				} else {
					out.Lines = (out.Lines)[:0]
				}
				for !in.IsDelim(']') {
					var v1 string
					v1 = string(in.String())
					out.Lines = append(out.Lines, v1)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "bytecodeOffsets":
			if in.IsNull() {
				in.Skip()
				out.BytecodeOffsets = nil
			} else {
				in.Delim('[')
				if out.BytecodeOffsets == nil {
					if !in.IsDelim(']') {
						out.BytecodeOffsets = make([]int64, 0, 8)
					} else {
						out.BytecodeOffsets = []int64{}
					}
				} else {
					out.BytecodeOffsets = (out.BytecodeOffsets)[:0]
				}
				for !in.IsDelim(']') {
					var v2 int64
					v2 = int64(in.Int64())
					out.BytecodeOffsets = append(out.BytecodeOffsets, v2)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger(out *jwriter.Writer, in WasmDisassemblyChunk) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"lines\":"
		out.RawString(prefix[1:])
		if in.Lines == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v3, v4 := range in.Lines {
				if v3 > 0 {
					out.RawByte(',')
				}
				out.String(string(v4))
			}
			out.RawByte(']')
		}
	}
	{
		const prefix string = ",\"bytecodeOffsets\":"
		out.RawString(prefix)
		if in.BytecodeOffsets == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v5, v6 := range in.BytecodeOffsets {
				if v5 > 0 {
					out.RawByte(',')
				}
				out.Int64(int64(v6))
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *WasmDisassemblyChunk) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger1(in *jlexer.Lexer, out *StepOverParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "skipList":
			if in.IsNull() {
				in.Skip()
				out.SkipList = nil
			} else {
				in.Delim('[')
				if out.SkipList == nil {
					if !in.IsDelim(']') {
						out.SkipList = make([]*LocationRange, 0, 8)
					} else {
						out.SkipList = []*LocationRange{}
					}
				} else {
					out.SkipList = (out.SkipList)[:0]
				}
				for !in.IsDelim(']') {
					var v7 *LocationRange
					if in.IsNull() {
						in.Skip()
						v7 = nil
					} else {
						if v7 == nil {
							v7 = new(LocationRange)
						}
						(*v7).UnmarshalEasyJSON(in)
					}
					out.SkipList = append(out.SkipList, v7)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger1(out *jwriter.Writer, in StepOverParams) {
	out.RawByte('{')
	first := true
	_ = first
	if len(in.SkipList) != 0 {
		const prefix string = ",\"skipList\":"
		first = false
		out.RawString(prefix[1:])
		{
			out.RawByte('[')
			for v8, v9 := range in.SkipList {
				if v8 > 0 {
					out.RawByte(',')
				}
				if v9 == nil {
					out.RawString("null")
				} else {
					(*v9).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *StepOverParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger1(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger2(in *jlexer.Lexer, out *StepOutParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger2(out *jwriter.Writer, in StepOutParams) {
	out.RawByte('{')
	first := true
	_ = first
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *StepOutParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger2(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger3(in *jlexer.Lexer, out *StepIntoParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "breakOnAsyncCall":
			out.BreakOnAsyncCall = bool(in.Bool())
		case "skipList":
			if in.IsNull() {
				in.Skip()
				out.SkipList = nil
			} else {
				in.Delim('[')
				if out.SkipList == nil {
					if !in.IsDelim(']') {
						out.SkipList = make([]*LocationRange, 0, 8)
					} else {
						out.SkipList = []*LocationRange{}
					}
				} else {
					out.SkipList = (out.SkipList)[:0]
				}
				for !in.IsDelim(']') {
					var v10 *LocationRange
					if in.IsNull() {
						in.Skip()
						v10 = nil
					} else {
						if v10 == nil {
							v10 = new(LocationRange)
						}
						(*v10).UnmarshalEasyJSON(in)
					}
					out.SkipList = append(out.SkipList, v10)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger3(out *jwriter.Writer, in StepIntoParams) {
	out.RawByte('{')
	first := true
	_ = first
	if in.BreakOnAsyncCall {
		const prefix string = ",\"breakOnAsyncCall\":"
		first = false
		out.RawString(prefix[1:])
		out.Bool(bool(in.BreakOnAsyncCall))
	}
	if len(in.SkipList) != 0 {
		const prefix string = ",\"skipList\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		{
			out.RawByte('[')
			for v11, v12 := range in.SkipList {
				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 StepIntoParams) MarshalJSON() ([]byte, error) {
	w := jwriter.Writer{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger3(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *StepIntoParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger3(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger4(in *jlexer.Lexer, out *SetVariableValueParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "scopeNumber":
			out.ScopeNumber = int64(in.Int64())
		case "variableName":
			out.VariableName = string(in.String())
		case "newValue":
			if in.IsNull() {
				in.Skip()
				out.NewValue = nil
			} else {
				if out.NewValue == nil {
					out.NewValue = new(runtime.CallArgument)
				}
				(*out.NewValue).UnmarshalEasyJSON(in)
			}
		case "callFrameId":
			out.CallFrameID = CallFrameID(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger4(out *jwriter.Writer, in SetVariableValueParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"scopeNumber\":"
		out.RawString(prefix[1:])
		out.Int64(int64(in.ScopeNumber))
	}
	{
		const prefix string = ",\"variableName\":"
		out.RawString(prefix)
		out.String(string(in.VariableName))
	}
	{
		const prefix string = ",\"newValue\":"
		out.RawString(prefix)
		if in.NewValue == nil {
			out.RawString("null")
		} else {
			(*in.NewValue).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"callFrameId\":"
		out.RawString(prefix)
		out.String(string(in.CallFrameID))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetVariableValueParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger4(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger5(in *jlexer.Lexer, out *SetSkipAllPausesParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "skip":
			out.Skip = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger5(out *jwriter.Writer, in SetSkipAllPausesParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"skip\":"
		out.RawString(prefix[1:])
		out.Bool(bool(in.Skip))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetSkipAllPausesParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger5(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger6(in *jlexer.Lexer, out *SetScriptSourceReturns) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "status":
			(out.Status).UnmarshalEasyJSON(in)
		case "exceptionDetails":
			if in.IsNull() {
				in.Skip()
				out.ExceptionDetails = nil
			} else {
				if out.ExceptionDetails == nil {
					out.ExceptionDetails = new(runtime.ExceptionDetails)
				}
				(*out.ExceptionDetails).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger6(out *jwriter.Writer, in SetScriptSourceReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if in.Status != "" {
		const prefix string = ",\"status\":"
		first = false
		out.RawString(prefix[1:])
		(in.Status).MarshalEasyJSON(out)
	}
	if in.ExceptionDetails != nil {
		const prefix string = ",\"exceptionDetails\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.ExceptionDetails).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetScriptSourceReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger6(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger7(in *jlexer.Lexer, out *SetScriptSourceParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "scriptId":
			out.ScriptID = runtime.ScriptID(in.String())
		case "scriptSource":
			out.ScriptSource = string(in.String())
		case "dryRun":
			out.DryRun = bool(in.Bool())
		case "allowTopFrameEditing":
			out.AllowTopFrameEditing = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger7(out *jwriter.Writer, in SetScriptSourceParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"scriptId\":"
		out.RawString(prefix[1:])
		out.String(string(in.ScriptID))
	}
	{
		const prefix string = ",\"scriptSource\":"
		out.RawString(prefix)
		out.String(string(in.ScriptSource))
	}
	if in.DryRun {
		const prefix string = ",\"dryRun\":"
		out.RawString(prefix)
		out.Bool(bool(in.DryRun))
	}
	if in.AllowTopFrameEditing {
		const prefix string = ",\"allowTopFrameEditing\":"
		out.RawString(prefix)
		out.Bool(bool(in.AllowTopFrameEditing))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetScriptSourceParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger7(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger8(in *jlexer.Lexer, out *SetReturnValueParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "newValue":
			if in.IsNull() {
				in.Skip()
				out.NewValue = nil
			} else {
				if out.NewValue == nil {
					out.NewValue = new(runtime.CallArgument)
				}
				(*out.NewValue).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger8(out *jwriter.Writer, in SetReturnValueParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"newValue\":"
		out.RawString(prefix[1:])
		if in.NewValue == nil {
			out.RawString("null")
		} else {
			(*in.NewValue).MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetReturnValueParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger8(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger9(in *jlexer.Lexer, out *SetPauseOnExceptionsParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "state":
			(out.State).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger9(out *jwriter.Writer, in SetPauseOnExceptionsParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"state\":"
		out.RawString(prefix[1:])
		(in.State).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetPauseOnExceptionsParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger9(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger10(in *jlexer.Lexer, out *SetInstrumentationBreakpointReturns) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "breakpointId":
			out.BreakpointID = BreakpointID(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger10(out *jwriter.Writer, in SetInstrumentationBreakpointReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if in.BreakpointID != "" {
		const prefix string = ",\"breakpointId\":"
		first = false
		out.RawString(prefix[1:])
		out.String(string(in.BreakpointID))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetInstrumentationBreakpointReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger10(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger11(in *jlexer.Lexer, out *SetInstrumentationBreakpointParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "instrumentation":
			(out.Instrumentation).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger11(out *jwriter.Writer, in SetInstrumentationBreakpointParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"instrumentation\":"
		out.RawString(prefix[1:])
		(in.Instrumentation).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetInstrumentationBreakpointParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger11(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger12(in *jlexer.Lexer, out *SetBreakpointsActiveParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "active":
			out.Active = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger12(out *jwriter.Writer, in SetBreakpointsActiveParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"active\":"
		out.RawString(prefix[1:])
		out.Bool(bool(in.Active))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetBreakpointsActiveParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger12(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger13(in *jlexer.Lexer, out *SetBreakpointReturns) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "breakpointId":
			out.BreakpointID = BreakpointID(in.String())
		case "actualLocation":
			if in.IsNull() {
				in.Skip()
				out.ActualLocation = nil
			} else {
				if out.ActualLocation == nil {
					out.ActualLocation = new(Location)
				}
				(*out.ActualLocation).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger13(out *jwriter.Writer, in SetBreakpointReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if in.BreakpointID != "" {
		const prefix string = ",\"breakpointId\":"
		first = false
		out.RawString(prefix[1:])
		out.String(string(in.BreakpointID))
	}
	if in.ActualLocation != nil {
		const prefix string = ",\"actualLocation\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.ActualLocation).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetBreakpointReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger13(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger14(in *jlexer.Lexer, out *SetBreakpointParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "location":
			if in.IsNull() {
				in.Skip()
				out.Location = nil
			} else {
				if out.Location == nil {
					out.Location = new(Location)
				}
				(*out.Location).UnmarshalEasyJSON(in)
			}
		case "condition":
			out.Condition = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger14(out *jwriter.Writer, in SetBreakpointParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"location\":"
		out.RawString(prefix[1:])
		if in.Location == nil {
			out.RawString("null")
		} else {
			(*in.Location).MarshalEasyJSON(out)
		}
	}
	if in.Condition != "" {
		const prefix string = ",\"condition\":"
		out.RawString(prefix)
		out.String(string(in.Condition))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetBreakpointParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger14(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger15(in *jlexer.Lexer, out *SetBreakpointOnFunctionCallReturns) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "breakpointId":
			out.BreakpointID = BreakpointID(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger15(out *jwriter.Writer, in SetBreakpointOnFunctionCallReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if in.BreakpointID != "" {
		const prefix string = ",\"breakpointId\":"
		first = false
		out.RawString(prefix[1:])
		out.String(string(in.BreakpointID))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetBreakpointOnFunctionCallReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger15(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger16(in *jlexer.Lexer, out *SetBreakpointOnFunctionCallParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "objectId":
			out.ObjectID = runtime.RemoteObjectID(in.String())
		case "condition":
			out.Condition = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger16(out *jwriter.Writer, in SetBreakpointOnFunctionCallParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"objectId\":"
		out.RawString(prefix[1:])
		out.String(string(in.ObjectID))
	}
	if in.Condition != "" {
		const prefix string = ",\"condition\":"
		out.RawString(prefix)
		out.String(string(in.Condition))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetBreakpointOnFunctionCallParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger16(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger17(in *jlexer.Lexer, out *SetBreakpointByURLReturns) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "breakpointId":
			out.BreakpointID = BreakpointID(in.String())
		case "locations":
			if in.IsNull() {
				in.Skip()
				out.Locations = nil
			} else {
				in.Delim('[')
				if out.Locations == nil {
					if !in.IsDelim(']') {
						out.Locations = make([]*Location, 0, 8)
					} else {
						out.Locations = []*Location{}
					}
				} else {
					out.Locations = (out.Locations)[:0]
				}
				for !in.IsDelim(']') {
					var v13 *Location
					if in.IsNull() {
						in.Skip()
						v13 = nil
					} else {
						if v13 == nil {
							v13 = new(Location)
						}
						(*v13).UnmarshalEasyJSON(in)
					}
					out.Locations = append(out.Locations, v13)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger17(out *jwriter.Writer, in SetBreakpointByURLReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if in.BreakpointID != "" {
		const prefix string = ",\"breakpointId\":"
		first = false
		out.RawString(prefix[1:])
		out.String(string(in.BreakpointID))
	}
	if len(in.Locations) != 0 {
		const prefix string = ",\"locations\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		{
			out.RawByte('[')
			for v14, v15 := range in.Locations {
				if v14 > 0 {
					out.RawByte(',')
				}
				if v15 == nil {
					out.RawString("null")
				} else {
					(*v15).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetBreakpointByURLReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger17(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger18(in *jlexer.Lexer, out *SetBreakpointByURLParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "lineNumber":
			out.LineNumber = int64(in.Int64())
		case "url":
			out.URL = string(in.String())
		case "urlRegex":
			out.URLRegex = string(in.String())
		case "scriptHash":
			out.ScriptHash = string(in.String())
		case "columnNumber":
			out.ColumnNumber = int64(in.Int64())
		case "condition":
			out.Condition = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger18(out *jwriter.Writer, in SetBreakpointByURLParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"lineNumber\":"
		out.RawString(prefix[1:])
		out.Int64(int64(in.LineNumber))
	}
	if in.URL != "" {
		const prefix string = ",\"url\":"
		out.RawString(prefix)
		out.String(string(in.URL))
	}
	if in.URLRegex != "" {
		const prefix string = ",\"urlRegex\":"
		out.RawString(prefix)
		out.String(string(in.URLRegex))
	}
	if in.ScriptHash != "" {
		const prefix string = ",\"scriptHash\":"
		out.RawString(prefix)
		out.String(string(in.ScriptHash))
	}
	if in.ColumnNumber != 0 {
		const prefix string = ",\"columnNumber\":"
		out.RawString(prefix)
		out.Int64(int64(in.ColumnNumber))
	}
	if in.Condition != "" {
		const prefix string = ",\"condition\":"
		out.RawString(prefix)
		out.String(string(in.Condition))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetBreakpointByURLParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger18(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger19(in *jlexer.Lexer, out *SetBlackboxedRangesParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "scriptId":
			out.ScriptID = runtime.ScriptID(in.String())
		case "positions":
			if in.IsNull() {
				in.Skip()
				out.Positions = nil
			} else {
				in.Delim('[')
				if out.Positions == nil {
					if !in.IsDelim(']') {
						out.Positions = make([]*ScriptPosition, 0, 8)
					} else {
						out.Positions = []*ScriptPosition{}
					}
				} else {
					out.Positions = (out.Positions)[:0]
				}
				for !in.IsDelim(']') {
					var v16 *ScriptPosition
					if in.IsNull() {
						in.Skip()
						v16 = nil
					} else {
						if v16 == nil {
							v16 = new(ScriptPosition)
						}
						(*v16).UnmarshalEasyJSON(in)
					}
					out.Positions = append(out.Positions, v16)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger19(out *jwriter.Writer, in SetBlackboxedRangesParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"scriptId\":"
		out.RawString(prefix[1:])
		out.String(string(in.ScriptID))
	}
	{
		const prefix string = ",\"positions\":"
		out.RawString(prefix)
		if in.Positions == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v17, v18 := range in.Positions {
				if v17 > 0 {
					out.RawByte(',')
				}
				if v18 == nil {
					out.RawString("null")
				} else {
					(*v18).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetBlackboxedRangesParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger19(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger20(in *jlexer.Lexer, out *SetBlackboxPatternsParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "patterns":
			if in.IsNull() {
				in.Skip()
				out.Patterns = nil
			} else {
				in.Delim('[')
				if out.Patterns == nil {
					if !in.IsDelim(']') {
						out.Patterns = make([]string, 0, 4)
					} else {
						out.Patterns = []string{}
					}
				} else {
					out.Patterns = (out.Patterns)[:0]
				}
				for !in.IsDelim(']') {
					var v19 string
					v19 = string(in.String())
					out.Patterns = append(out.Patterns, v19)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger20(out *jwriter.Writer, in SetBlackboxPatternsParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"patterns\":"
		out.RawString(prefix[1:])
		if in.Patterns == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v20, v21 := range in.Patterns {
				if v20 > 0 {
					out.RawByte(',')
				}
				out.String(string(v21))
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetBlackboxPatternsParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger20(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger21(in *jlexer.Lexer, out *SetAsyncCallStackDepthParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "maxDepth":
			out.MaxDepth = int64(in.Int64())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger21(out *jwriter.Writer, in SetAsyncCallStackDepthParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"maxDepth\":"
		out.RawString(prefix[1:])
		out.Int64(int64(in.MaxDepth))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SetAsyncCallStackDepthParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger21(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger22(in *jlexer.Lexer, out *SearchMatch) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "lineNumber":
			out.LineNumber = float64(in.Float64())
		case "lineContent":
			out.LineContent = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger22(out *jwriter.Writer, in SearchMatch) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"lineNumber\":"
		out.RawString(prefix[1:])
		out.Float64(float64(in.LineNumber))
	}
	{
		const prefix string = ",\"lineContent\":"
		out.RawString(prefix)
		out.String(string(in.LineContent))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SearchMatch) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger22(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger23(in *jlexer.Lexer, out *SearchInContentReturns) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "result":
			if in.IsNull() {
				in.Skip()
				out.Result = nil
			} else {
				in.Delim('[')
				if out.Result == nil {
					if !in.IsDelim(']') {
						out.Result = make([]*SearchMatch, 0, 8)
					} else {
						out.Result = []*SearchMatch{}
					}
				} else {
					out.Result = (out.Result)[:0]
				}
				for !in.IsDelim(']') {
					var v22 *SearchMatch
					if in.IsNull() {
						in.Skip()
						v22 = nil
					} else {
						if v22 == nil {
							v22 = new(SearchMatch)
						}
						(*v22).UnmarshalEasyJSON(in)
					}
					out.Result = append(out.Result, v22)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger23(out *jwriter.Writer, in SearchInContentReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if len(in.Result) != 0 {
		const prefix string = ",\"result\":"
		first = false
		out.RawString(prefix[1:])
		{
			out.RawByte('[')
			for v23, v24 := range in.Result {
				if v23 > 0 {
					out.RawByte(',')
				}
				if v24 == nil {
					out.RawString("null")
				} else {
					(*v24).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SearchInContentReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger23(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger24(in *jlexer.Lexer, out *SearchInContentParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "scriptId":
			out.ScriptID = runtime.ScriptID(in.String())
		case "query":
			out.Query = string(in.String())
		case "caseSensitive":
			out.CaseSensitive = bool(in.Bool())
		case "isRegex":
			out.IsRegex = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger24(out *jwriter.Writer, in SearchInContentParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"scriptId\":"
		out.RawString(prefix[1:])
		out.String(string(in.ScriptID))
	}
	{
		const prefix string = ",\"query\":"
		out.RawString(prefix)
		out.String(string(in.Query))
	}
	if in.CaseSensitive {
		const prefix string = ",\"caseSensitive\":"
		out.RawString(prefix)
		out.Bool(bool(in.CaseSensitive))
	}
	if in.IsRegex {
		const prefix string = ",\"isRegex\":"
		out.RawString(prefix)
		out.Bool(bool(in.IsRegex))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *SearchInContentParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger24(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger25(in *jlexer.Lexer, out *ScriptPosition) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "lineNumber":
			out.LineNumber = int64(in.Int64())
		case "columnNumber":
			out.ColumnNumber = int64(in.Int64())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger25(out *jwriter.Writer, in ScriptPosition) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"lineNumber\":"
		out.RawString(prefix[1:])
		out.Int64(int64(in.LineNumber))
	}
	{
		const prefix string = ",\"columnNumber\":"
		out.RawString(prefix)
		out.Int64(int64(in.ColumnNumber))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *ScriptPosition) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger25(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger26(in *jlexer.Lexer, out *Scope) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "type":
			(out.Type).UnmarshalEasyJSON(in)
		case "object":
			if in.IsNull() {
				in.Skip()
				out.Object = nil
			} else {
				if out.Object == nil {
					out.Object = new(runtime.RemoteObject)
				}
				(*out.Object).UnmarshalEasyJSON(in)
			}
		case "name":
			out.Name = string(in.String())
		case "startLocation":
			if in.IsNull() {
				in.Skip()
				out.StartLocation = nil
			} else {
				if out.StartLocation == nil {
					out.StartLocation = new(Location)
				}
				(*out.StartLocation).UnmarshalEasyJSON(in)
			}
		case "endLocation":
			if in.IsNull() {
				in.Skip()
				out.EndLocation = nil
			} else {
				if out.EndLocation == nil {
					out.EndLocation = new(Location)
				}
				(*out.EndLocation).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger26(out *jwriter.Writer, in Scope) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"type\":"
		out.RawString(prefix[1:])
		(in.Type).MarshalEasyJSON(out)
	}
	{
		const prefix string = ",\"object\":"
		out.RawString(prefix)
		if in.Object == nil {
			out.RawString("null")
		} else {
			(*in.Object).MarshalEasyJSON(out)
		}
	}
	if in.Name != "" {
		const prefix string = ",\"name\":"
		out.RawString(prefix)
		out.String(string(in.Name))
	}
	if in.StartLocation != nil {
		const prefix string = ",\"startLocation\":"
		out.RawString(prefix)
		(*in.StartLocation).MarshalEasyJSON(out)
	}
	if in.EndLocation != nil {
		const prefix string = ",\"endLocation\":"
		out.RawString(prefix)
		(*in.EndLocation).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *Scope) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger26(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger27(in *jlexer.Lexer, out *ResumeParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "terminateOnResume":
			out.TerminateOnResume = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger27(out *jwriter.Writer, in ResumeParams) {
	out.RawByte('{')
	first := true
	_ = first
	if in.TerminateOnResume {
		const prefix string = ",\"terminateOnResume\":"
		first = false
		out.RawString(prefix[1:])
		out.Bool(bool(in.TerminateOnResume))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *ResumeParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger27(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger28(in *jlexer.Lexer, out *RestartFrameParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "callFrameId":
			out.CallFrameID = CallFrameID(in.String())
		case "mode":
			(out.Mode).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger28(out *jwriter.Writer, in RestartFrameParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"callFrameId\":"
		out.RawString(prefix[1:])
		out.String(string(in.CallFrameID))
	}
	if in.Mode != "" {
		const prefix string = ",\"mode\":"
		out.RawString(prefix)
		(in.Mode).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *RestartFrameParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger28(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger29(in *jlexer.Lexer, out *RemoveBreakpointParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "breakpointId":
			out.BreakpointID = BreakpointID(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger29(out *jwriter.Writer, in RemoveBreakpointParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"breakpointId\":"
		out.RawString(prefix[1:])
		out.String(string(in.BreakpointID))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *RemoveBreakpointParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger29(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger30(in *jlexer.Lexer, out *PauseParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger30(out *jwriter.Writer, in PauseParams) {
	out.RawByte('{')
	first := true
	_ = first
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *PauseParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger30(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger31(in *jlexer.Lexer, out *NextWasmDisassemblyChunkReturns) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "chunk":
			if in.IsNull() {
				in.Skip()
				out.Chunk = nil
			} else {
				if out.Chunk == nil {
					out.Chunk = new(WasmDisassemblyChunk)
				}
				(*out.Chunk).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger31(out *jwriter.Writer, in NextWasmDisassemblyChunkReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if in.Chunk != nil {
		const prefix string = ",\"chunk\":"
		first = false
		out.RawString(prefix[1:])
		(*in.Chunk).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *NextWasmDisassemblyChunkReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger31(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger32(in *jlexer.Lexer, out *NextWasmDisassemblyChunkParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "streamId":
			out.StreamID = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger32(out *jwriter.Writer, in NextWasmDisassemblyChunkParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"streamId\":"
		out.RawString(prefix[1:])
		out.String(string(in.StreamID))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *NextWasmDisassemblyChunkParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger32(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger33(in *jlexer.Lexer, out *LocationRange) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "scriptId":
			out.ScriptID = runtime.ScriptID(in.String())
		case "start":
			if in.IsNull() {
				in.Skip()
				out.Start = nil
			} else {
				if out.Start == nil {
					out.Start = new(ScriptPosition)
				}
				(*out.Start).UnmarshalEasyJSON(in)
			}
		case "end":
			if in.IsNull() {
				in.Skip()
				out.End = nil
			} else {
				if out.End == nil {
					out.End = new(ScriptPosition)
				}
				(*out.End).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger33(out *jwriter.Writer, in LocationRange) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"scriptId\":"
		out.RawString(prefix[1:])
		out.String(string(in.ScriptID))
	}
	{
		const prefix string = ",\"start\":"
		out.RawString(prefix)
		if in.Start == nil {
			out.RawString("null")
		} else {
			(*in.Start).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"end\":"
		out.RawString(prefix)
		if in.End == nil {
			out.RawString("null")
		} else {
			(*in.End).MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *LocationRange) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger33(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger34(in *jlexer.Lexer, out *Location) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "scriptId":
			out.ScriptID = runtime.ScriptID(in.String())
		case "lineNumber":
			out.LineNumber = int64(in.Int64())
		case "columnNumber":
			out.ColumnNumber = int64(in.Int64())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger34(out *jwriter.Writer, in Location) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"scriptId\":"
		out.RawString(prefix[1:])
		out.String(string(in.ScriptID))
	}
	{
		const prefix string = ",\"lineNumber\":"
		out.RawString(prefix)
		out.Int64(int64(in.LineNumber))
	}
	if in.ColumnNumber != 0 {
		const prefix string = ",\"columnNumber\":"
		out.RawString(prefix)
		out.Int64(int64(in.ColumnNumber))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *Location) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger34(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger35(in *jlexer.Lexer, out *GetStackTraceReturns) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "stackTrace":
			if in.IsNull() {
				in.Skip()
				out.StackTrace = nil
			} else {
				if out.StackTrace == nil {
					out.StackTrace = new(runtime.StackTrace)
				}
				(*out.StackTrace).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger35(out *jwriter.Writer, in GetStackTraceReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if in.StackTrace != nil {
		const prefix string = ",\"stackTrace\":"
		first = false
		out.RawString(prefix[1:])
		(*in.StackTrace).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetStackTraceReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger35(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger36(in *jlexer.Lexer, out *GetStackTraceParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "stackTraceId":
			if in.IsNull() {
				in.Skip()
				out.StackTraceID = nil
			} else {
				if out.StackTraceID == nil {
					out.StackTraceID = new(runtime.StackTraceID)
				}
				(*out.StackTraceID).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger36(out *jwriter.Writer, in GetStackTraceParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"stackTraceId\":"
		out.RawString(prefix[1:])
		if in.StackTraceID == nil {
			out.RawString("null")
		} else {
			(*in.StackTraceID).MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetStackTraceParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger36(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger37(in *jlexer.Lexer, out *GetScriptSourceReturns) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "scriptSource":
			out.ScriptSource = string(in.String())
		case "bytecode":
			out.Bytecode = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger37(out *jwriter.Writer, in GetScriptSourceReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if in.ScriptSource != "" {
		const prefix string = ",\"scriptSource\":"
		first = false
		out.RawString(prefix[1:])
		out.String(string(in.ScriptSource))
	}
	if in.Bytecode != "" {
		const prefix string = ",\"bytecode\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.String(string(in.Bytecode))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetScriptSourceReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger37(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger38(in *jlexer.Lexer, out *GetScriptSourceParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "scriptId":
			out.ScriptID = runtime.ScriptID(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger38(out *jwriter.Writer, in GetScriptSourceParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"scriptId\":"
		out.RawString(prefix[1:])
		out.String(string(in.ScriptID))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetScriptSourceParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger38(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger39(in *jlexer.Lexer, out *GetPossibleBreakpointsReturns) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "locations":
			if in.IsNull() {
				in.Skip()
				out.Locations = nil
			} else {
				in.Delim('[')
				if out.Locations == nil {
					if !in.IsDelim(']') {
						out.Locations = make([]*BreakLocation, 0, 8)
					} else {
						out.Locations = []*BreakLocation{}
					}
				} else {
					out.Locations = (out.Locations)[:0]
				}
				for !in.IsDelim(']') {
					var v25 *BreakLocation
					if in.IsNull() {
						in.Skip()
						v25 = nil
					} else {
						if v25 == nil {
							v25 = new(BreakLocation)
						}
						(*v25).UnmarshalEasyJSON(in)
					}
					out.Locations = append(out.Locations, v25)
					in.WantComma()
				}
				in.Delim(']')
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger39(out *jwriter.Writer, in GetPossibleBreakpointsReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if len(in.Locations) != 0 {
		const prefix string = ",\"locations\":"
		first = false
		out.RawString(prefix[1:])
		{
			out.RawByte('[')
			for v26, v27 := range in.Locations {
				if v26 > 0 {
					out.RawByte(',')
				}
				if v27 == nil {
					out.RawString("null")
				} else {
					(*v27).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetPossibleBreakpointsReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger39(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger40(in *jlexer.Lexer, out *GetPossibleBreakpointsParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "start":
			if in.IsNull() {
				in.Skip()
				out.Start = nil
			} else {
				if out.Start == nil {
					out.Start = new(Location)
				}
				(*out.Start).UnmarshalEasyJSON(in)
			}
		case "end":
			if in.IsNull() {
				in.Skip()
				out.End = nil
			} else {
				if out.End == nil {
					out.End = new(Location)
				}
				(*out.End).UnmarshalEasyJSON(in)
			}
		case "restrictToFunction":
			out.RestrictToFunction = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger40(out *jwriter.Writer, in GetPossibleBreakpointsParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"start\":"
		out.RawString(prefix[1:])
		if in.Start == nil {
			out.RawString("null")
		} else {
			(*in.Start).MarshalEasyJSON(out)
		}
	}
	if in.End != nil {
		const prefix string = ",\"end\":"
		out.RawString(prefix)
		(*in.End).MarshalEasyJSON(out)
	}
	if in.RestrictToFunction {
		const prefix string = ",\"restrictToFunction\":"
		out.RawString(prefix)
		out.Bool(bool(in.RestrictToFunction))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *GetPossibleBreakpointsParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger40(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger41(in *jlexer.Lexer, out *EventScriptParsed) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "scriptId":
			out.ScriptID = runtime.ScriptID(in.String())
		case "url":
			out.URL = string(in.String())
		case "startLine":
			out.StartLine = int64(in.Int64())
		case "startColumn":
			out.StartColumn = int64(in.Int64())
		case "endLine":
			out.EndLine = int64(in.Int64())
		case "endColumn":
			out.EndColumn = int64(in.Int64())
		case "executionContextId":
			out.ExecutionContextID = runtime.ExecutionContextID(in.Int64())
		case "hash":
			out.Hash = string(in.String())
		case "executionContextAuxData":
			(out.ExecutionContextAuxData).UnmarshalEasyJSON(in)
		case "isLiveEdit":
			out.IsLiveEdit = bool(in.Bool())
		case "sourceMapURL":
			out.SourceMapURL = string(in.String())
		case "hasSourceURL":
			out.HasSourceURL = bool(in.Bool())
		case "isModule":
			out.IsModule = bool(in.Bool())
		case "length":
			out.Length = int64(in.Int64())
		case "stackTrace":
			if in.IsNull() {
				in.Skip()
				out.StackTrace = nil
			} else {
				if out.StackTrace == nil {
					out.StackTrace = new(runtime.StackTrace)
				}
				(*out.StackTrace).UnmarshalEasyJSON(in)
			}
		case "codeOffset":
			out.CodeOffset = int64(in.Int64())
		case "scriptLanguage":
			(out.ScriptLanguage).UnmarshalEasyJSON(in)
		case "debugSymbols":
			if in.IsNull() {
				in.Skip()
				out.DebugSymbols = nil
			} else {
				if out.DebugSymbols == nil {
					out.DebugSymbols = new(DebugSymbols)
				}
				(*out.DebugSymbols).UnmarshalEasyJSON(in)
			}
		case "embedderName":
			out.EmbedderName = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger41(out *jwriter.Writer, in EventScriptParsed) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"scriptId\":"
		out.RawString(prefix[1:])
		out.String(string(in.ScriptID))
	}
	{
		const prefix string = ",\"url\":"
		out.RawString(prefix)
		out.String(string(in.URL))
	}
	{
		const prefix string = ",\"startLine\":"
		out.RawString(prefix)
		out.Int64(int64(in.StartLine))
	}
	{
		const prefix string = ",\"startColumn\":"
		out.RawString(prefix)
		out.Int64(int64(in.StartColumn))
	}
	{
		const prefix string = ",\"endLine\":"
		out.RawString(prefix)
		out.Int64(int64(in.EndLine))
	}
	{
		const prefix string = ",\"endColumn\":"
		out.RawString(prefix)
		out.Int64(int64(in.EndColumn))
	}
	{
		const prefix string = ",\"executionContextId\":"
		out.RawString(prefix)
		out.Int64(int64(in.ExecutionContextID))
	}
	{
		const prefix string = ",\"hash\":"
		out.RawString(prefix)
		out.String(string(in.Hash))
	}
	if (in.ExecutionContextAuxData).IsDefined() {
		const prefix string = ",\"executionContextAuxData\":"
		out.RawString(prefix)
		(in.ExecutionContextAuxData).MarshalEasyJSON(out)
	}
	if in.IsLiveEdit {
		const prefix string = ",\"isLiveEdit\":"
		out.RawString(prefix)
		out.Bool(bool(in.IsLiveEdit))
	}
	if in.SourceMapURL != "" {
		const prefix string = ",\"sourceMapURL\":"
		out.RawString(prefix)
		out.String(string(in.SourceMapURL))
	}
	if in.HasSourceURL {
		const prefix string = ",\"hasSourceURL\":"
		out.RawString(prefix)
		out.Bool(bool(in.HasSourceURL))
	}
	if in.IsModule {
		const prefix string = ",\"isModule\":"
		out.RawString(prefix)
		out.Bool(bool(in.IsModule))
	}
	if in.Length != 0 {
		const prefix string = ",\"length\":"
		out.RawString(prefix)
		out.Int64(int64(in.Length))
	}
	if in.StackTrace != nil {
		const prefix string = ",\"stackTrace\":"
		out.RawString(prefix)
		(*in.StackTrace).MarshalEasyJSON(out)
	}
	if in.CodeOffset != 0 {
		const prefix string = ",\"codeOffset\":"
		out.RawString(prefix)
		out.Int64(int64(in.CodeOffset))
	}
	if in.ScriptLanguage != "" {
		const prefix string = ",\"scriptLanguage\":"
		out.RawString(prefix)
		(in.ScriptLanguage).MarshalEasyJSON(out)
	}
	if in.DebugSymbols != nil {
		const prefix string = ",\"debugSymbols\":"
		out.RawString(prefix)
		(*in.DebugSymbols).MarshalEasyJSON(out)
	}
	if in.EmbedderName != "" {
		const prefix string = ",\"embedderName\":"
		out.RawString(prefix)
		out.String(string(in.EmbedderName))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventScriptParsed) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger41(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger42(in *jlexer.Lexer, out *EventScriptFailedToParse) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "scriptId":
			out.ScriptID = runtime.ScriptID(in.String())
		case "url":
			out.URL = string(in.String())
		case "startLine":
			out.StartLine = int64(in.Int64())
		case "startColumn":
			out.StartColumn = int64(in.Int64())
		case "endLine":
			out.EndLine = int64(in.Int64())
		case "endColumn":
			out.EndColumn = int64(in.Int64())
		case "executionContextId":
			out.ExecutionContextID = runtime.ExecutionContextID(in.Int64())
		case "hash":
			out.Hash = string(in.String())
		case "executionContextAuxData":
			(out.ExecutionContextAuxData).UnmarshalEasyJSON(in)
		case "sourceMapURL":
			out.SourceMapURL = string(in.String())
		case "hasSourceURL":
			out.HasSourceURL = bool(in.Bool())
		case "isModule":
			out.IsModule = bool(in.Bool())
		case "length":
			out.Length = int64(in.Int64())
		case "stackTrace":
			if in.IsNull() {
				in.Skip()
				out.StackTrace = nil
			} else {
				if out.StackTrace == nil {
					out.StackTrace = new(runtime.StackTrace)
				}
				(*out.StackTrace).UnmarshalEasyJSON(in)
			}
		case "codeOffset":
			out.CodeOffset = int64(in.Int64())
		case "scriptLanguage":
			(out.ScriptLanguage).UnmarshalEasyJSON(in)
		case "embedderName":
			out.EmbedderName = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger42(out *jwriter.Writer, in EventScriptFailedToParse) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"scriptId\":"
		out.RawString(prefix[1:])
		out.String(string(in.ScriptID))
	}
	{
		const prefix string = ",\"url\":"
		out.RawString(prefix)
		out.String(string(in.URL))
	}
	{
		const prefix string = ",\"startLine\":"
		out.RawString(prefix)
		out.Int64(int64(in.StartLine))
	}
	{
		const prefix string = ",\"startColumn\":"
		out.RawString(prefix)
		out.Int64(int64(in.StartColumn))
	}
	{
		const prefix string = ",\"endLine\":"
		out.RawString(prefix)
		out.Int64(int64(in.EndLine))
	}
	{
		const prefix string = ",\"endColumn\":"
		out.RawString(prefix)
		out.Int64(int64(in.EndColumn))
	}
	{
		const prefix string = ",\"executionContextId\":"
		out.RawString(prefix)
		out.Int64(int64(in.ExecutionContextID))
	}
	{
		const prefix string = ",\"hash\":"
		out.RawString(prefix)
		out.String(string(in.Hash))
	}
	if (in.ExecutionContextAuxData).IsDefined() {
		const prefix string = ",\"executionContextAuxData\":"
		out.RawString(prefix)
		(in.ExecutionContextAuxData).MarshalEasyJSON(out)
	}
	if in.SourceMapURL != "" {
		const prefix string = ",\"sourceMapURL\":"
		out.RawString(prefix)
		out.String(string(in.SourceMapURL))
	}
	if in.HasSourceURL {
		const prefix string = ",\"hasSourceURL\":"
		out.RawString(prefix)
		out.Bool(bool(in.HasSourceURL))
	}
	if in.IsModule {
		const prefix string = ",\"isModule\":"
		out.RawString(prefix)
		out.Bool(bool(in.IsModule))
	}
	if in.Length != 0 {
		const prefix string = ",\"length\":"
		out.RawString(prefix)
		out.Int64(int64(in.Length))
	}
	if in.StackTrace != nil {
		const prefix string = ",\"stackTrace\":"
		out.RawString(prefix)
		(*in.StackTrace).MarshalEasyJSON(out)
	}
	if in.CodeOffset != 0 {
		const prefix string = ",\"codeOffset\":"
		out.RawString(prefix)
		out.Int64(int64(in.CodeOffset))
	}
	if in.ScriptLanguage != "" {
		const prefix string = ",\"scriptLanguage\":"
		out.RawString(prefix)
		(in.ScriptLanguage).MarshalEasyJSON(out)
	}
	if in.EmbedderName != "" {
		const prefix string = ",\"embedderName\":"
		out.RawString(prefix)
		out.String(string(in.EmbedderName))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventScriptFailedToParse) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger42(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger43(in *jlexer.Lexer, out *EventResumed) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger43(out *jwriter.Writer, in EventResumed) {
	out.RawByte('{')
	first := true
	_ = first
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventResumed) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger43(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger44(in *jlexer.Lexer, out *EventPaused) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "callFrames":
			if in.IsNull() {
				in.Skip()
				out.CallFrames = nil
			} else {
				in.Delim('[')
				if out.CallFrames == nil {
					if !in.IsDelim(']') {
						out.CallFrames = make([]*CallFrame, 0, 8)
					} else {
						out.CallFrames = []*CallFrame{}
					}
				} else {
					out.CallFrames = (out.CallFrames)[:0]
				}
				for !in.IsDelim(']') {
					var v28 *CallFrame
					if in.IsNull() {
						in.Skip()
						v28 = nil
					} else {
						if v28 == nil {
							v28 = new(CallFrame)
						}
						(*v28).UnmarshalEasyJSON(in)
					}
					out.CallFrames = append(out.CallFrames, v28)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "reason":
			(out.Reason).UnmarshalEasyJSON(in)
		case "data":
			(out.Data).UnmarshalEasyJSON(in)
		case "hitBreakpoints":
			if in.IsNull() {
				in.Skip()
				out.HitBreakpoints = nil
			} else {
				in.Delim('[')
				if out.HitBreakpoints == nil {
					if !in.IsDelim(']') {
						out.HitBreakpoints = make([]string, 0, 4)
					} else {
						out.HitBreakpoints = []string{}
					}
				} else {
					out.HitBreakpoints = (out.HitBreakpoints)[:0]
				}
				for !in.IsDelim(']') {
					var v29 string
					v29 = string(in.String())
					out.HitBreakpoints = append(out.HitBreakpoints, v29)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "asyncStackTrace":
			if in.IsNull() {
				in.Skip()
				out.AsyncStackTrace = nil
			} else {
				if out.AsyncStackTrace == nil {
					out.AsyncStackTrace = new(runtime.StackTrace)
				}
				(*out.AsyncStackTrace).UnmarshalEasyJSON(in)
			}
		case "asyncStackTraceId":
			if in.IsNull() {
				in.Skip()
				out.AsyncStackTraceID = nil
			} else {
				if out.AsyncStackTraceID == nil {
					out.AsyncStackTraceID = new(runtime.StackTraceID)
				}
				(*out.AsyncStackTraceID).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger44(out *jwriter.Writer, in EventPaused) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"callFrames\":"
		out.RawString(prefix[1:])
		if in.CallFrames == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v30, v31 := range in.CallFrames {
				if v30 > 0 {
					out.RawByte(',')
				}
				if v31 == nil {
					out.RawString("null")
				} else {
					(*v31).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	{
		const prefix string = ",\"reason\":"
		out.RawString(prefix)
		(in.Reason).MarshalEasyJSON(out)
	}
	if (in.Data).IsDefined() {
		const prefix string = ",\"data\":"
		out.RawString(prefix)
		(in.Data).MarshalEasyJSON(out)
	}
	if len(in.HitBreakpoints) != 0 {
		const prefix string = ",\"hitBreakpoints\":"
		out.RawString(prefix)
		{
			out.RawByte('[')
			for v32, v33 := range in.HitBreakpoints {
				if v32 > 0 {
					out.RawByte(',')
				}
				out.String(string(v33))
			}
			out.RawByte(']')
		}
	}
	if in.AsyncStackTrace != nil {
		const prefix string = ",\"asyncStackTrace\":"
		out.RawString(prefix)
		(*in.AsyncStackTrace).MarshalEasyJSON(out)
	}
	if in.AsyncStackTraceID != nil {
		const prefix string = ",\"asyncStackTraceId\":"
		out.RawString(prefix)
		(*in.AsyncStackTraceID).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventPaused) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger44(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger45(in *jlexer.Lexer, out *EventBreakpointResolved) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "breakpointId":
			out.BreakpointID = BreakpointID(in.String())
		case "location":
			if in.IsNull() {
				in.Skip()
				out.Location = nil
			} else {
				if out.Location == nil {
					out.Location = new(Location)
				}
				(*out.Location).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger45(out *jwriter.Writer, in EventBreakpointResolved) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"breakpointId\":"
		out.RawString(prefix[1:])
		out.String(string(in.BreakpointID))
	}
	{
		const prefix string = ",\"location\":"
		out.RawString(prefix)
		if in.Location == nil {
			out.RawString("null")
		} else {
			(*in.Location).MarshalEasyJSON(out)
		}
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EventBreakpointResolved) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger45(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger46(in *jlexer.Lexer, out *EvaluateOnCallFrameReturns) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "result":
			if in.IsNull() {
				in.Skip()
				out.Result = nil
			} else {
				if out.Result == nil {
					out.Result = new(runtime.RemoteObject)
				}
				(*out.Result).UnmarshalEasyJSON(in)
			}
		case "exceptionDetails":
			if in.IsNull() {
				in.Skip()
				out.ExceptionDetails = nil
			} else {
				if out.ExceptionDetails == nil {
					out.ExceptionDetails = new(runtime.ExceptionDetails)
				}
				(*out.ExceptionDetails).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger46(out *jwriter.Writer, in EvaluateOnCallFrameReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if in.Result != nil {
		const prefix string = ",\"result\":"
		first = false
		out.RawString(prefix[1:])
		(*in.Result).MarshalEasyJSON(out)
	}
	if in.ExceptionDetails != nil {
		const prefix string = ",\"exceptionDetails\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.ExceptionDetails).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EvaluateOnCallFrameReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger46(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger47(in *jlexer.Lexer, out *EvaluateOnCallFrameParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "callFrameId":
			out.CallFrameID = CallFrameID(in.String())
		case "expression":
			out.Expression = string(in.String())
		case "objectGroup":
			out.ObjectGroup = string(in.String())
		case "includeCommandLineAPI":
			out.IncludeCommandLineAPI = bool(in.Bool())
		case "silent":
			out.Silent = bool(in.Bool())
		case "returnByValue":
			out.ReturnByValue = bool(in.Bool())
		case "generatePreview":
			out.GeneratePreview = bool(in.Bool())
		case "throwOnSideEffect":
			out.ThrowOnSideEffect = bool(in.Bool())
		case "timeout":
			out.Timeout = runtime.TimeDelta(in.Float64())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger47(out *jwriter.Writer, in EvaluateOnCallFrameParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"callFrameId\":"
		out.RawString(prefix[1:])
		out.String(string(in.CallFrameID))
	}
	{
		const prefix string = ",\"expression\":"
		out.RawString(prefix)
		out.String(string(in.Expression))
	}
	if in.ObjectGroup != "" {
		const prefix string = ",\"objectGroup\":"
		out.RawString(prefix)
		out.String(string(in.ObjectGroup))
	}
	if in.IncludeCommandLineAPI {
		const prefix string = ",\"includeCommandLineAPI\":"
		out.RawString(prefix)
		out.Bool(bool(in.IncludeCommandLineAPI))
	}
	if in.Silent {
		const prefix string = ",\"silent\":"
		out.RawString(prefix)
		out.Bool(bool(in.Silent))
	}
	if in.ReturnByValue {
		const prefix string = ",\"returnByValue\":"
		out.RawString(prefix)
		out.Bool(bool(in.ReturnByValue))
	}
	if in.GeneratePreview {
		const prefix string = ",\"generatePreview\":"
		out.RawString(prefix)
		out.Bool(bool(in.GeneratePreview))
	}
	if in.ThrowOnSideEffect {
		const prefix string = ",\"throwOnSideEffect\":"
		out.RawString(prefix)
		out.Bool(bool(in.ThrowOnSideEffect))
	}
	if in.Timeout != 0 {
		const prefix string = ",\"timeout\":"
		out.RawString(prefix)
		out.Float64(float64(in.Timeout))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EvaluateOnCallFrameParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger47(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger48(in *jlexer.Lexer, out *EnableReturns) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "debuggerId":
			out.DebuggerID = runtime.UniqueDebuggerID(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger48(out *jwriter.Writer, in EnableReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if in.DebuggerID != "" {
		const prefix string = ",\"debuggerId\":"
		first = false
		out.RawString(prefix[1:])
		out.String(string(in.DebuggerID))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EnableReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger48(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger49(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.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "maxScriptsCacheSize":
			out.MaxScriptsCacheSize = float64(in.Float64())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger49(out *jwriter.Writer, in EnableParams) {
	out.RawByte('{')
	first := true
	_ = first
	if in.MaxScriptsCacheSize != 0 {
		const prefix string = ",\"maxScriptsCacheSize\":"
		first = false
		out.RawString(prefix[1:])
		out.Float64(float64(in.MaxScriptsCacheSize))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *EnableParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger49(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger50(in *jlexer.Lexer, out *DisassembleWasmModuleReturns) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "streamId":
			out.StreamID = string(in.String())
		case "totalNumberOfLines":
			out.TotalNumberOfLines = int64(in.Int64())
		case "functionBodyOffsets":
			if in.IsNull() {
				in.Skip()
				out.FunctionBodyOffsets = nil
			} else {
				in.Delim('[')
				if out.FunctionBodyOffsets == nil {
					if !in.IsDelim(']') {
						out.FunctionBodyOffsets = make([]int64, 0, 8)
					} else {
						out.FunctionBodyOffsets = []int64{}
					}
				} else {
					out.FunctionBodyOffsets = (out.FunctionBodyOffsets)[:0]
				}
				for !in.IsDelim(']') {
					var v34 int64
					v34 = int64(in.Int64())
					out.FunctionBodyOffsets = append(out.FunctionBodyOffsets, v34)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "chunk":
			if in.IsNull() {
				in.Skip()
				out.Chunk = nil
			} else {
				if out.Chunk == nil {
					out.Chunk = new(WasmDisassemblyChunk)
				}
				(*out.Chunk).UnmarshalEasyJSON(in)
			}
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger50(out *jwriter.Writer, in DisassembleWasmModuleReturns) {
	out.RawByte('{')
	first := true
	_ = first
	if in.StreamID != "" {
		const prefix string = ",\"streamId\":"
		first = false
		out.RawString(prefix[1:])
		out.String(string(in.StreamID))
	}
	if in.TotalNumberOfLines != 0 {
		const prefix string = ",\"totalNumberOfLines\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		out.Int64(int64(in.TotalNumberOfLines))
	}
	if len(in.FunctionBodyOffsets) != 0 {
		const prefix string = ",\"functionBodyOffsets\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		{
			out.RawByte('[')
			for v35, v36 := range in.FunctionBodyOffsets {
				if v35 > 0 {
					out.RawByte(',')
				}
				out.Int64(int64(v36))
			}
			out.RawByte(']')
		}
	}
	if in.Chunk != nil {
		const prefix string = ",\"chunk\":"
		if first {
			first = false
			out.RawString(prefix[1:])
		} else {
			out.RawString(prefix)
		}
		(*in.Chunk).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *DisassembleWasmModuleReturns) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger50(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger51(in *jlexer.Lexer, out *DisassembleWasmModuleParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "scriptId":
			out.ScriptID = runtime.ScriptID(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger51(out *jwriter.Writer, in DisassembleWasmModuleParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"scriptId\":"
		out.RawString(prefix[1:])
		out.String(string(in.ScriptID))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *DisassembleWasmModuleParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger51(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger52(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.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger52(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{}
	easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger52(&w, v)
	return w.Buffer.BuildBytes(), w.Error
}

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *DisableParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger52(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger53(in *jlexer.Lexer, out *DebugSymbols) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "type":
			(out.Type).UnmarshalEasyJSON(in)
		case "externalURL":
			out.ExternalURL = string(in.String())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger53(out *jwriter.Writer, in DebugSymbols) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"type\":"
		out.RawString(prefix[1:])
		(in.Type).MarshalEasyJSON(out)
	}
	if in.ExternalURL != "" {
		const prefix string = ",\"externalURL\":"
		out.RawString(prefix)
		out.String(string(in.ExternalURL))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *DebugSymbols) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger53(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger54(in *jlexer.Lexer, out *ContinueToLocationParams) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "location":
			if in.IsNull() {
				in.Skip()
				out.Location = nil
			} else {
				if out.Location == nil {
					out.Location = new(Location)
				}
				(*out.Location).UnmarshalEasyJSON(in)
			}
		case "targetCallFrames":
			(out.TargetCallFrames).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger54(out *jwriter.Writer, in ContinueToLocationParams) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"location\":"
		out.RawString(prefix[1:])
		if in.Location == nil {
			out.RawString("null")
		} else {
			(*in.Location).MarshalEasyJSON(out)
		}
	}
	if in.TargetCallFrames != "" {
		const prefix string = ",\"targetCallFrames\":"
		out.RawString(prefix)
		(in.TargetCallFrames).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *ContinueToLocationParams) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger54(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger55(in *jlexer.Lexer, out *CallFrame) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "callFrameId":
			out.CallFrameID = CallFrameID(in.String())
		case "functionName":
			out.FunctionName = string(in.String())
		case "functionLocation":
			if in.IsNull() {
				in.Skip()
				out.FunctionLocation = nil
			} else {
				if out.FunctionLocation == nil {
					out.FunctionLocation = new(Location)
				}
				(*out.FunctionLocation).UnmarshalEasyJSON(in)
			}
		case "location":
			if in.IsNull() {
				in.Skip()
				out.Location = nil
			} else {
				if out.Location == nil {
					out.Location = new(Location)
				}
				(*out.Location).UnmarshalEasyJSON(in)
			}
		case "scopeChain":
			if in.IsNull() {
				in.Skip()
				out.ScopeChain = nil
			} else {
				in.Delim('[')
				if out.ScopeChain == nil {
					if !in.IsDelim(']') {
						out.ScopeChain = make([]*Scope, 0, 8)
					} else {
						out.ScopeChain = []*Scope{}
					}
				} else {
					out.ScopeChain = (out.ScopeChain)[:0]
				}
				for !in.IsDelim(']') {
					var v37 *Scope
					if in.IsNull() {
						in.Skip()
						v37 = nil
					} else {
						if v37 == nil {
							v37 = new(Scope)
						}
						(*v37).UnmarshalEasyJSON(in)
					}
					out.ScopeChain = append(out.ScopeChain, v37)
					in.WantComma()
				}
				in.Delim(']')
			}
		case "this":
			if in.IsNull() {
				in.Skip()
				out.This = nil
			} else {
				if out.This == nil {
					out.This = new(runtime.RemoteObject)
				}
				(*out.This).UnmarshalEasyJSON(in)
			}
		case "returnValue":
			if in.IsNull() {
				in.Skip()
				out.ReturnValue = nil
			} else {
				if out.ReturnValue == nil {
					out.ReturnValue = new(runtime.RemoteObject)
				}
				(*out.ReturnValue).UnmarshalEasyJSON(in)
			}
		case "canBeRestarted":
			out.CanBeRestarted = bool(in.Bool())
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger55(out *jwriter.Writer, in CallFrame) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"callFrameId\":"
		out.RawString(prefix[1:])
		out.String(string(in.CallFrameID))
	}
	{
		const prefix string = ",\"functionName\":"
		out.RawString(prefix)
		out.String(string(in.FunctionName))
	}
	if in.FunctionLocation != nil {
		const prefix string = ",\"functionLocation\":"
		out.RawString(prefix)
		(*in.FunctionLocation).MarshalEasyJSON(out)
	}
	{
		const prefix string = ",\"location\":"
		out.RawString(prefix)
		if in.Location == nil {
			out.RawString("null")
		} else {
			(*in.Location).MarshalEasyJSON(out)
		}
	}
	{
		const prefix string = ",\"scopeChain\":"
		out.RawString(prefix)
		if in.ScopeChain == nil && (out.Flags&jwriter.NilSliceAsEmpty) == 0 {
			out.RawString("null")
		} else {
			out.RawByte('[')
			for v38, v39 := range in.ScopeChain {
				if v38 > 0 {
					out.RawByte(',')
				}
				if v39 == nil {
					out.RawString("null")
				} else {
					(*v39).MarshalEasyJSON(out)
				}
			}
			out.RawByte(']')
		}
	}
	{
		const prefix string = ",\"this\":"
		out.RawString(prefix)
		if in.This == nil {
			out.RawString("null")
		} else {
			(*in.This).MarshalEasyJSON(out)
		}
	}
	if in.ReturnValue != nil {
		const prefix string = ",\"returnValue\":"
		out.RawString(prefix)
		(*in.ReturnValue).MarshalEasyJSON(out)
	}
	if in.CanBeRestarted {
		const prefix string = ",\"canBeRestarted\":"
		out.RawString(prefix)
		out.Bool(bool(in.CanBeRestarted))
	}
	out.RawByte('}')
}

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

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

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

// UnmarshalEasyJSON supports easyjson.Unmarshaler interface
func (v *CallFrame) UnmarshalEasyJSON(l *jlexer.Lexer) {
	easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger55(l, v)
}
func easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger56(in *jlexer.Lexer, out *BreakLocation) {
	isTopLevel := in.IsStart()
	if in.IsNull() {
		if isTopLevel {
			in.Consumed()
		}
		in.Skip()
		return
	}
	in.Delim('{')
	for !in.IsDelim('}') {
		key := in.UnsafeFieldName(false)
		in.WantColon()
		if in.IsNull() {
			in.Skip()
			in.WantComma()
			continue
		}
		switch key {
		case "scriptId":
			out.ScriptID = runtime.ScriptID(in.String())
		case "lineNumber":
			out.LineNumber = int64(in.Int64())
		case "columnNumber":
			out.ColumnNumber = int64(in.Int64())
		case "type":
			(out.Type).UnmarshalEasyJSON(in)
		default:
			in.SkipRecursive()
		}
		in.WantComma()
	}
	in.Delim('}')
	if isTopLevel {
		in.Consumed()
	}
}
func easyjsonC5a4559bEncodeGithubComChromedpCdprotoDebugger56(out *jwriter.Writer, in BreakLocation) {
	out.RawByte('{')
	first := true
	_ = first
	{
		const prefix string = ",\"scriptId\":"
		out.RawString(prefix[1:])
		out.String(string(in.ScriptID))
	}
	{
		const prefix string = ",\"lineNumber\":"
		out.RawString(prefix)
		out.Int64(int64(in.LineNumber))
	}
	if in.ColumnNumber != 0 {
		const prefix string = ",\"columnNumber\":"
		out.RawString(prefix)
		out.Int64(int64(in.ColumnNumber))
	}
	if in.Type != "" {
		const prefix string = ",\"type\":"
		out.RawString(prefix)
		(in.Type).MarshalEasyJSON(out)
	}
	out.RawByte('}')
}

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

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

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

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