gapid/service/service_binary.go

////////////////////////////////////////////////////////////////////////////////
// Do not modify!
// Generated by codergen
////////////////////////////////////////////////////////////////////////////////

package service

import (
	"android.googlesource.com/platform/tools/gpu/framework/binary"
	"android.googlesource.com/platform/tools/gpu/framework/binary/registry"
	"android.googlesource.com/platform/tools/gpu/framework/binary/schema"
	"android.googlesource.com/platform/tools/gpu/framework/id"
	"android.googlesource.com/platform/tools/gpu/framework/log"
	"android.googlesource.com/platform/tools/gpu/framework/rpc"
	"android.googlesource.com/platform/tools/gpu/framework/stringtable"
	"android.googlesource.com/platform/tools/gpu/framework/stringtable/msg"
	"android.googlesource.com/platform/tools/gpu/gapid/atom"
	"android.googlesource.com/platform/tools/gpu/gapid/gfxapi"
	"android.googlesource.com/platform/tools/gpu/gapid/memory"
	"android.googlesource.com/platform/tools/gpu/gapid/service/path"
)

// Make sure schema init() runs first
import _ "android.googlesource.com/platform/tools/gpu/framework/binary/schema"

// force use the id package, because our imports handling is wrong
var _ id.ID

const (
	ixǁAtomRangeTimer = iota
	ixǁAtomTimer
	ixǁCapture
	ixǁContext
	ixǁContextList
	ixǁErrDataUnavailable
	ixǁErrInvalidArgument
	ixǁErrInvalidPath
	ixǁHierarchy
	ixǁHierarchyList
	ixǁMemoryInfo
	ixǁMsgRef
	ixǁRenderSettings
	ixǁReportItem
	ixǁReportGroup
	ixǁReport
	ixǁResourceInfo
	ixǁResourceBundle
	ixǁResourceBundles
	ixǁResources
	ixǁTimingInfo
	ixǁcallBeginCPUProfile
	ixǁcallEndCPUProfile
	ixǁcallFollow
	ixǁcallGet
	ixǁcallGetAvailableStringTables
	ixǁcallGetCaptures
	ixǁcallGetDevices
	ixǁcallGetFeatures
	ixǁcallGetFramebufferAttachment
	ixǁcallGetFramebufferColor
	ixǁcallGetFramebufferDepth
	ixǁcallGetMemProfileRate
	ixǁcallGetPerformanceCounters
	ixǁcallGetProfile
	ixǁcallGetSchema
	ixǁcallGetStringTable
	ixǁcallGetTimingInfo
	ixǁcallImportCapture
	ixǁcallLoadCapture
	ixǁcallRegisterAndroidDevice
	ixǁcallSet
	ixǁcallSetMemProfileRate
	ixǁresultBeginCPUProfile
	ixǁresultEndCPUProfile
	ixǁresultFollow
	ixǁresultGet
	ixǁresultGetAvailableStringTables
	ixǁresultGetCaptures
	ixǁresultGetDevices
	ixǁresultGetFeatures
	ixǁresultGetFramebufferAttachment
	ixǁresultGetFramebufferColor
	ixǁresultGetFramebufferDepth
	ixǁresultGetMemProfileRate
	ixǁresultGetPerformanceCounters
	ixǁresultGetProfile
	ixǁresultGetSchema
	ixǁresultGetStringTable
	ixǁresultGetTimingInfo
	ixǁresultImportCapture
	ixǁresultLoadCapture
	ixǁresultRegisterAndroidDevice
	ixǁresultSet
	ixǁresultSetMemProfileRate
)

var entities [65]binary.Entity

var Namespace = registry.NewNamespace()

func init() {
	registry.Global.AddFallbacks(Namespace)
	Namespace.AddClassOf((*AtomRangeTimer)(nil))
	Namespace.AddClassOf((*AtomTimer)(nil))
	Namespace.AddClassOf((*Capture)(nil))
	Namespace.AddClassOf((*Context)(nil))
	Namespace.AddClassOf((*ContextList)(nil))
	Namespace.AddClassOf((*ErrDataUnavailable)(nil))
	Namespace.AddClassOf((*ErrInvalidArgument)(nil))
	Namespace.AddClassOf((*ErrInvalidPath)(nil))
	Namespace.AddClassOf((*Hierarchy)(nil))
	Namespace.AddClassOf((*HierarchyList)(nil))
	Namespace.AddClassOf((*MemoryInfo)(nil))
	Namespace.AddClassOf((*MsgRef)(nil))
	Namespace.AddClassOf((*RenderSettings)(nil))
	Namespace.AddClassOf((*ReportItem)(nil))
	Namespace.AddClassOf((*ReportGroup)(nil))
	Namespace.AddClassOf((*Report)(nil))
	Namespace.AddClassOf((*ResourceInfo)(nil))
	Namespace.AddClassOf((*ResourceBundle)(nil))
	Namespace.AddClassOf((*ResourceBundles)(nil))
	Namespace.AddClassOf((*Resources)(nil))
	Namespace.AddClassOf((*TimingInfo)(nil))
	Namespace.AddClassOf((*callBeginCPUProfile)(nil))
	Namespace.AddClassOf((*callEndCPUProfile)(nil))
	Namespace.AddClassOf((*callFollow)(nil))
	Namespace.AddClassOf((*callGet)(nil))
	Namespace.AddClassOf((*callGetAvailableStringTables)(nil))
	Namespace.AddClassOf((*callGetCaptures)(nil))
	Namespace.AddClassOf((*callGetDevices)(nil))
	Namespace.AddClassOf((*callGetFeatures)(nil))
	Namespace.AddClassOf((*callGetFramebufferAttachment)(nil))
	Namespace.AddClassOf((*callGetFramebufferColor)(nil))
	Namespace.AddClassOf((*callGetFramebufferDepth)(nil))
	Namespace.AddClassOf((*callGetMemProfileRate)(nil))
	Namespace.AddClassOf((*callGetPerformanceCounters)(nil))
	Namespace.AddClassOf((*callGetProfile)(nil))
	Namespace.AddClassOf((*callGetSchema)(nil))
	Namespace.AddClassOf((*callGetStringTable)(nil))
	Namespace.AddClassOf((*callGetTimingInfo)(nil))
	Namespace.AddClassOf((*callImportCapture)(nil))
	Namespace.AddClassOf((*callLoadCapture)(nil))
	Namespace.AddClassOf((*callRegisterAndroidDevice)(nil))
	Namespace.AddClassOf((*callSet)(nil))
	Namespace.AddClassOf((*callSetMemProfileRate)(nil))
	Namespace.AddClassOf((*resultBeginCPUProfile)(nil))
	Namespace.AddClassOf((*resultEndCPUProfile)(nil))
	Namespace.AddClassOf((*resultFollow)(nil))
	Namespace.AddClassOf((*resultGet)(nil))
	Namespace.AddClassOf((*resultGetAvailableStringTables)(nil))
	Namespace.AddClassOf((*resultGetCaptures)(nil))
	Namespace.AddClassOf((*resultGetDevices)(nil))
	Namespace.AddClassOf((*resultGetFeatures)(nil))
	Namespace.AddClassOf((*resultGetFramebufferAttachment)(nil))
	Namespace.AddClassOf((*resultGetFramebufferColor)(nil))
	Namespace.AddClassOf((*resultGetFramebufferDepth)(nil))
	Namespace.AddClassOf((*resultGetMemProfileRate)(nil))
	Namespace.AddClassOf((*resultGetPerformanceCounters)(nil))
	Namespace.AddClassOf((*resultGetProfile)(nil))
	Namespace.AddClassOf((*resultGetSchema)(nil))
	Namespace.AddClassOf((*resultGetStringTable)(nil))
	Namespace.AddClassOf((*resultGetTimingInfo)(nil))
	Namespace.AddClassOf((*resultImportCapture)(nil))
	Namespace.AddClassOf((*resultLoadCapture)(nil))
	Namespace.AddClassOf((*resultRegisterAndroidDevice)(nil))
	Namespace.AddClassOf((*resultSet)(nil))
	Namespace.AddClassOf((*resultSetMemProfileRate)(nil))
}

type binaryClassAtomRangeTimer struct{}

func (*AtomRangeTimer) Class() binary.Class {
	return (*binaryClassAtomRangeTimer)(nil)
}
func doEncodeAtomRangeTimer(e binary.Writer, o *AtomRangeTimer) {
	e.Uint64(o.FromAtomIndex)
	e.Uint64(o.ToAtomIndex)
	e.Uint64(o.Nanoseconds)
}
func doDecodeAtomRangeTimer(d binary.Reader, o *AtomRangeTimer) {
	o.FromAtomIndex = uint64(d.Uint64())
	o.ToAtomIndex = uint64(d.Uint64())
	o.Nanoseconds = uint64(d.Uint64())
}
func doDecodeRawAtomRangeTimer(d binary.Reader, o *AtomRangeTimer) {
	o.FromAtomIndex = uint64(d.Uint64())
	o.ToAtomIndex = uint64(d.Uint64())
	o.Nanoseconds = uint64(d.Uint64())
}
func (*binaryClassAtomRangeTimer) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeAtomRangeTimer(e, obj.(*AtomRangeTimer))
}
func (*binaryClassAtomRangeTimer) New() binary.Object {
	return &AtomRangeTimer{}
}
func (*binaryClassAtomRangeTimer) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeAtomRangeTimer(d, obj.(*AtomRangeTimer))
}
func (o *AtomRangeTimer) WriteSimple(w binary.Writer) {
	doEncodeAtomRangeTimer(w, o)
}
func (o *AtomRangeTimer) ReadSimple(r binary.Reader) {
	doDecodeAtomRangeTimer(r, o)
}
func (c *binaryClassAtomRangeTimer) Schema() *binary.Entity {
	return &entities[ixǁAtomRangeTimer]
}

type binaryClassAtomTimer struct{}

func (*AtomTimer) Class() binary.Class {
	return (*binaryClassAtomTimer)(nil)
}
func doEncodeAtomTimer(e binary.Writer, o *AtomTimer) {
	e.Uint64(o.AtomIndex)
	e.Uint64(o.Nanoseconds)
}
func doDecodeAtomTimer(d binary.Reader, o *AtomTimer) {
	o.AtomIndex = uint64(d.Uint64())
	o.Nanoseconds = uint64(d.Uint64())
}
func doDecodeRawAtomTimer(d binary.Reader, o *AtomTimer) {
	o.AtomIndex = uint64(d.Uint64())
	o.Nanoseconds = uint64(d.Uint64())
}
func (*binaryClassAtomTimer) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeAtomTimer(e, obj.(*AtomTimer))
}
func (*binaryClassAtomTimer) New() binary.Object {
	return &AtomTimer{}
}
func (*binaryClassAtomTimer) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeAtomTimer(d, obj.(*AtomTimer))
}
func (o *AtomTimer) WriteSimple(w binary.Writer) {
	doEncodeAtomTimer(w, o)
}
func (o *AtomTimer) ReadSimple(r binary.Reader) {
	doDecodeAtomTimer(r, o)
}
func (c *binaryClassAtomTimer) Schema() *binary.Entity {
	return &entities[ixǁAtomTimer]
}

type binaryClassCapture struct{}

func (*Capture) Class() binary.Class {
	return (*binaryClassCapture)(nil)
}
func doEncodeCapture(e binary.Writer, o *Capture) {
	e.String(o.Name)
	e.Data(o.Atoms[:20])
	e.Uint32(uint32(len(o.Apis)))
	for i := range o.Apis {
		curr := &o.Apis[i]
		e.Data((*curr)[:20])
	}
}
func doDecodeCapture(d binary.Reader, o *Capture) {
	o.Name = string(d.String())
	d.Data(o.Atoms[:20])
	if count := d.Count(); count > 0 {
		o.Apis = make([]ApiID, count)
		for i := range o.Apis {
			curr := &o.Apis[i]
			d.Data((*curr)[:20])
		}
	}
}
func doDecodeRawCapture(d binary.Reader, o *Capture) {
	o.Name = string(d.String())
	d.Data(o.Atoms[:20])
	if count := d.Count(); count > 0 {
		o.Apis = make([]ApiID, count)
		for i := range o.Apis {
			curr := &o.Apis[i]
			d.Data((*curr)[:20])
		}
	}
}
func (*binaryClassCapture) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeCapture(e, obj.(*Capture))
}
func (*binaryClassCapture) New() binary.Object {
	return &Capture{}
}
func (*binaryClassCapture) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeCapture(d, obj.(*Capture))
}
func (o *Capture) WriteSimple(w binary.Writer) {
	doEncodeCapture(w, o)
}
func (o *Capture) ReadSimple(r binary.Reader) {
	doDecodeCapture(r, o)
}
func (c *binaryClassCapture) Schema() *binary.Entity {
	return &entities[ixǁCapture]
}

type binaryClassContext struct{}

func (*Context) Class() binary.Class {
	return (*binaryClassContext)(nil)
}
func doEncodeContext(e binary.Writer, o *Context) {
	e.Data(o.ID[:20])
	e.String(o.Name)
	e.Data(o.Api[:20])
	e.Uint32(uint32(len(o.Ranges)))
	for i := range o.Ranges {
		curr := &o.Ranges[i]
		e.Simple(&(*curr))
	}
}
func doDecodeContext(d binary.Reader, o *Context) {
	d.Data(o.ID[:20])
	o.Name = string(d.String())
	d.Data(o.Api[:20])
	if count := d.Count(); count > 0 {
		o.Ranges = make(atom.RangeList, count)
		for i := range o.Ranges {
			curr := &o.Ranges[i]
			d.Simple(&(*curr))
		}
	}
}
func doDecodeRawContext(d binary.Reader, o *Context) {
	d.Data(o.ID[:20])
	o.Name = string(d.String())
	d.Data(o.Api[:20])
	if count := d.Count(); count > 0 {
		o.Ranges = make(atom.RangeList, count)
		for i := range o.Ranges {
			curr := &o.Ranges[i]
			d.Simple(&(*curr))
		}
	}
}
func (*binaryClassContext) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeContext(e, obj.(*Context))
}
func (*binaryClassContext) New() binary.Object {
	return &Context{}
}
func (*binaryClassContext) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeContext(d, obj.(*Context))
}
func (o *Context) WriteSimple(w binary.Writer) {
	doEncodeContext(w, o)
}
func (o *Context) ReadSimple(r binary.Reader) {
	doDecodeContext(r, o)
}
func (c *binaryClassContext) Schema() *binary.Entity {
	return &entities[ixǁContext]
}

type binaryClassContextList struct{}

func (*ContextList) Class() binary.Class {
	return (*binaryClassContextList)(nil)
}
func doEncodeContextList(e binary.Encoder, o *ContextList) {
	e.Uint32(uint32(len(o.Contexts)))
	for i := range o.Contexts {
		curr := &o.Contexts[i]
		e.Simple(&(*curr))
	}
}
func doDecodeContextList(d binary.Decoder, o *ContextList) {
	if count := d.Count(); count > 0 {
		o.Contexts = make([]Context, count)
		for i := range o.Contexts {
			curr := &o.Contexts[i]
			d.Simple(&(*curr))
		}
	}
}
func doDecodeRawContextList(d binary.Decoder, o *ContextList) {
	if count := d.Count(); count > 0 {
		o.Contexts = make([]Context, count)
		for i := range o.Contexts {
			curr := &o.Contexts[i]
			d.Simple(&(*curr))
		}
	}
}
func (*binaryClassContextList) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeContextList(e, obj.(*ContextList))
}
func (*binaryClassContextList) New() binary.Object {
	return &ContextList{}
}
func (*binaryClassContextList) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeContextList(d, obj.(*ContextList))
}
func (c *binaryClassContextList) Schema() *binary.Entity {
	return &entities[ixǁContextList]
}

var _ rpc.Err = (*ErrDataUnavailable)(nil) // Interface compliance check.
type binaryClassErrDataUnavailable struct{}

func (*ErrDataUnavailable) Class() binary.Class {
	return (*binaryClassErrDataUnavailable)(nil)
}
func doEncodeErrDataUnavailable(e binary.Encoder, o *ErrDataUnavailable) {
	if o.Reason != nil {
		e.Object(o.Reason)
	} else {
		e.Object(nil)
	}
	e.Bool(o.Transient)
}
func doDecodeErrDataUnavailable(d binary.Decoder, o *ErrDataUnavailable) {
	if obj := d.Object(); obj != nil {
		o.Reason = obj.(*msg.Msg)
	} else {
		o.Reason = nil
	}
	o.Transient = bool(d.Bool())
}
func doDecodeRawErrDataUnavailable(d binary.Decoder, o *ErrDataUnavailable) {
	if obj := d.Object(); obj != nil {
		o.Reason = obj.(*msg.Msg)
	} else {
		o.Reason = nil
	}
	o.Transient = bool(d.Bool())
}
func (*binaryClassErrDataUnavailable) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeErrDataUnavailable(e, obj.(*ErrDataUnavailable))
}
func (*binaryClassErrDataUnavailable) New() binary.Object {
	return &ErrDataUnavailable{}
}
func (*binaryClassErrDataUnavailable) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeErrDataUnavailable(d, obj.(*ErrDataUnavailable))
}
func (c *binaryClassErrDataUnavailable) Schema() *binary.Entity {
	return &entities[ixǁErrDataUnavailable]
}

var _ rpc.Err = (*ErrInvalidArgument)(nil) // Interface compliance check.
type binaryClassErrInvalidArgument struct{}

func (*ErrInvalidArgument) Class() binary.Class {
	return (*binaryClassErrInvalidArgument)(nil)
}
func doEncodeErrInvalidArgument(e binary.Encoder, o *ErrInvalidArgument) {
	if o.Reason != nil {
		e.Object(o.Reason)
	} else {
		e.Object(nil)
	}
}
func doDecodeErrInvalidArgument(d binary.Decoder, o *ErrInvalidArgument) {
	if obj := d.Object(); obj != nil {
		o.Reason = obj.(*msg.Msg)
	} else {
		o.Reason = nil
	}
}
func doDecodeRawErrInvalidArgument(d binary.Decoder, o *ErrInvalidArgument) {
	if obj := d.Object(); obj != nil {
		o.Reason = obj.(*msg.Msg)
	} else {
		o.Reason = nil
	}
}
func (*binaryClassErrInvalidArgument) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeErrInvalidArgument(e, obj.(*ErrInvalidArgument))
}
func (*binaryClassErrInvalidArgument) New() binary.Object {
	return &ErrInvalidArgument{}
}
func (*binaryClassErrInvalidArgument) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeErrInvalidArgument(d, obj.(*ErrInvalidArgument))
}
func (c *binaryClassErrInvalidArgument) Schema() *binary.Entity {
	return &entities[ixǁErrInvalidArgument]
}

var _ rpc.Err = (*ErrInvalidPath)(nil) // Interface compliance check.
type binaryClassErrInvalidPath struct{}

func (*ErrInvalidPath) Class() binary.Class {
	return (*binaryClassErrInvalidPath)(nil)
}
func doEncodeErrInvalidPath(e binary.Encoder, o *ErrInvalidPath) {
	if o.Reason != nil {
		e.Object(o.Reason)
	} else {
		e.Object(nil)
	}
	e.Object(o.Path)
}
func doDecodeErrInvalidPath(d binary.Decoder, o *ErrInvalidPath) {
	if obj := d.Object(); obj != nil {
		o.Reason = obj.(*msg.Msg)
	} else {
		o.Reason = nil
	}
	o.Path = path.PathCast(d.Object())
}
func doDecodeRawErrInvalidPath(d binary.Decoder, o *ErrInvalidPath) {
	if obj := d.Object(); obj != nil {
		o.Reason = obj.(*msg.Msg)
	} else {
		o.Reason = nil
	}
	o.Path = path.PathCast(d.Object())
}
func (*binaryClassErrInvalidPath) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeErrInvalidPath(e, obj.(*ErrInvalidPath))
}
func (*binaryClassErrInvalidPath) New() binary.Object {
	return &ErrInvalidPath{}
}
func (*binaryClassErrInvalidPath) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeErrInvalidPath(d, obj.(*ErrInvalidPath))
}
func (c *binaryClassErrInvalidPath) Schema() *binary.Entity {
	return &entities[ixǁErrInvalidPath]
}

type binaryClassHierarchy struct{}

func (*Hierarchy) Class() binary.Class {
	return (*binaryClassHierarchy)(nil)
}
func doEncodeHierarchy(e binary.Encoder, o *Hierarchy) {
	e.String(o.Name)
	e.Data(o.Context[:20])
	e.Struct(&o.Root)
}
func doDecodeHierarchy(d binary.Decoder, o *Hierarchy) {
	o.Name = string(d.String())
	d.Data(o.Context[:20])
	d.Struct(&o.Root)
}
func doDecodeRawHierarchy(d binary.Decoder, o *Hierarchy) {
	o.Name = string(d.String())
	d.Data(o.Context[:20])
	d.Struct(&o.Root)
}
func (*binaryClassHierarchy) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeHierarchy(e, obj.(*Hierarchy))
}
func (*binaryClassHierarchy) New() binary.Object {
	return &Hierarchy{}
}
func (*binaryClassHierarchy) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeHierarchy(d, obj.(*Hierarchy))
}
func (c *binaryClassHierarchy) Schema() *binary.Entity {
	return &entities[ixǁHierarchy]
}

type binaryClassHierarchyList struct{}

func (*HierarchyList) Class() binary.Class {
	return (*binaryClassHierarchyList)(nil)
}
func doEncodeHierarchyList(e binary.Encoder, o *HierarchyList) {
	e.Uint32(uint32(len(o.Hierarchies)))
	for i := range o.Hierarchies {
		curr := &o.Hierarchies[i]
		e.Struct(&(*curr))
	}
}
func doDecodeHierarchyList(d binary.Decoder, o *HierarchyList) {
	if count := d.Count(); count > 0 {
		o.Hierarchies = make([]Hierarchy, count)
		for i := range o.Hierarchies {
			curr := &o.Hierarchies[i]
			d.Struct(&(*curr))
		}
	}
}
func doDecodeRawHierarchyList(d binary.Decoder, o *HierarchyList) {
	if count := d.Count(); count > 0 {
		o.Hierarchies = make([]Hierarchy, count)
		for i := range o.Hierarchies {
			curr := &o.Hierarchies[i]
			d.Struct(&(*curr))
		}
	}
}
func (*binaryClassHierarchyList) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeHierarchyList(e, obj.(*HierarchyList))
}
func (*binaryClassHierarchyList) New() binary.Object {
	return &HierarchyList{}
}
func (*binaryClassHierarchyList) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeHierarchyList(d, obj.(*HierarchyList))
}
func (c *binaryClassHierarchyList) Schema() *binary.Entity {
	return &entities[ixǁHierarchyList]
}

type binaryClassMemoryInfo struct{}

func (*MemoryInfo) Class() binary.Class {
	return (*binaryClassMemoryInfo)(nil)
}
func doEncodeMemoryInfo(e binary.Writer, o *MemoryInfo) {
	e.Uint32(uint32(len(o.Data)))
	e.Data(o.Data)
	e.Uint32(uint32(len(o.Reads)))
	for i := range o.Reads {
		curr := &o.Reads[i]
		e.Simple(&(*curr))
	}
	e.Uint32(uint32(len(o.Writes)))
	for i := range o.Writes {
		curr := &o.Writes[i]
		e.Simple(&(*curr))
	}
	e.Uint32(uint32(len(o.Observed)))
	for i := range o.Observed {
		curr := &o.Observed[i]
		e.Simple(&(*curr))
	}
}
func doDecodeMemoryInfo(d binary.Reader, o *MemoryInfo) {
	if count := d.Count(); count > 0 {
		o.Data = make([]uint8, count)
		d.Data(o.Data)
	}
	if count := d.Count(); count > 0 {
		o.Reads = make(memory.RangeList, count)
		for i := range o.Reads {
			curr := &o.Reads[i]
			d.Simple(&(*curr))
		}
	}
	if count := d.Count(); count > 0 {
		o.Writes = make(memory.RangeList, count)
		for i := range o.Writes {
			curr := &o.Writes[i]
			d.Simple(&(*curr))
		}
	}
	if count := d.Count(); count > 0 {
		o.Observed = make(memory.RangeList, count)
		for i := range o.Observed {
			curr := &o.Observed[i]
			d.Simple(&(*curr))
		}
	}
}
func doDecodeRawMemoryInfo(d binary.Reader, o *MemoryInfo) {
	if count := d.Count(); count > 0 {
		o.Data = make([]uint8, count)
		d.Data(o.Data)
	}
	if count := d.Count(); count > 0 {
		o.Reads = make(memory.RangeList, count)
		for i := range o.Reads {
			curr := &o.Reads[i]
			d.Simple(&(*curr))
		}
	}
	if count := d.Count(); count > 0 {
		o.Writes = make(memory.RangeList, count)
		for i := range o.Writes {
			curr := &o.Writes[i]
			d.Simple(&(*curr))
		}
	}
	if count := d.Count(); count > 0 {
		o.Observed = make(memory.RangeList, count)
		for i := range o.Observed {
			curr := &o.Observed[i]
			d.Simple(&(*curr))
		}
	}
}
func (*binaryClassMemoryInfo) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeMemoryInfo(e, obj.(*MemoryInfo))
}
func (*binaryClassMemoryInfo) New() binary.Object {
	return &MemoryInfo{}
}
func (*binaryClassMemoryInfo) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeMemoryInfo(d, obj.(*MemoryInfo))
}
func (o *MemoryInfo) WriteSimple(w binary.Writer) {
	doEncodeMemoryInfo(w, o)
}
func (o *MemoryInfo) ReadSimple(r binary.Reader) {
	doDecodeMemoryInfo(r, o)
}
func (c *binaryClassMemoryInfo) Schema() *binary.Entity {
	return &entities[ixǁMemoryInfo]
}

type binaryClassMsgRef struct{}

func (*MsgRef) Class() binary.Class {
	return (*binaryClassMsgRef)(nil)
}
func doEncodeMsgRef(e binary.Writer, o *MsgRef) {
	e.Uint32(o.Identifier)
	e.Uint32(uint32(len(o.Arguments)))
	for i := range o.Arguments {
		curr := &o.Arguments[i]
		e.Uint32(*curr)
	}
}
func doDecodeMsgRef(d binary.Reader, o *MsgRef) {
	o.Identifier = uint32(d.Uint32())
	if count := d.Count(); count > 0 {
		o.Arguments = make([]uint32, count)
		for i := range o.Arguments {
			curr := &o.Arguments[i]
			*curr = uint32(d.Uint32())
		}
	}
}
func doDecodeRawMsgRef(d binary.Reader, o *MsgRef) {
	o.Identifier = uint32(d.Uint32())
	if count := d.Count(); count > 0 {
		o.Arguments = make([]uint32, count)
		for i := range o.Arguments {
			curr := &o.Arguments[i]
			*curr = uint32(d.Uint32())
		}
	}
}
func (*binaryClassMsgRef) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeMsgRef(e, obj.(*MsgRef))
}
func (*binaryClassMsgRef) New() binary.Object {
	return &MsgRef{}
}
func (*binaryClassMsgRef) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeMsgRef(d, obj.(*MsgRef))
}
func (o *MsgRef) WriteSimple(w binary.Writer) {
	doEncodeMsgRef(w, o)
}
func (o *MsgRef) ReadSimple(r binary.Reader) {
	doDecodeMsgRef(r, o)
}
func (c *binaryClassMsgRef) Schema() *binary.Entity {
	return &entities[ixǁMsgRef]
}

type binaryClassRenderSettings struct{}

func (*RenderSettings) Class() binary.Class {
	return (*binaryClassRenderSettings)(nil)
}
func doEncodeRenderSettings(e binary.Writer, o *RenderSettings) {
	e.Uint32(o.MaxWidth)
	e.Uint32(o.MaxHeight)
	e.Int32(int32(o.WireframeMode))
}
func doDecodeRenderSettings(d binary.Reader, o *RenderSettings) {
	o.MaxWidth = uint32(d.Uint32())
	o.MaxHeight = uint32(d.Uint32())
	o.WireframeMode = WireframeMode(d.Int32())
}
func doDecodeRawRenderSettings(d binary.Reader, o *RenderSettings) {
	o.MaxWidth = uint32(d.Uint32())
	o.MaxHeight = uint32(d.Uint32())
	o.WireframeMode = WireframeMode(d.Int32())
}
func (*binaryClassRenderSettings) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeRenderSettings(e, obj.(*RenderSettings))
}
func (*binaryClassRenderSettings) New() binary.Object {
	return &RenderSettings{}
}
func (*binaryClassRenderSettings) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeRenderSettings(d, obj.(*RenderSettings))
}
func (o *RenderSettings) WriteSimple(w binary.Writer) {
	doEncodeRenderSettings(w, o)
}
func (o *RenderSettings) ReadSimple(r binary.Reader) {
	doDecodeRenderSettings(r, o)
}
func (c *binaryClassRenderSettings) Schema() *binary.Entity {
	return &entities[ixǁRenderSettings]
}

type binaryClassReportItem struct{}

func (*ReportItem) Class() binary.Class {
	return (*binaryClassReportItem)(nil)
}
func doEncodeReportItem(e binary.Encoder, o *ReportItem) {
	e.Int32(int32(o.Severity))
	if o.Message != nil {
		e.Object(o.Message)
	} else {
		e.Object(nil)
	}
	e.Uint64(o.Atom)
	e.Uint32(uint32(len(o.Tags)))
	for i := range o.Tags {
		curr := &o.Tags[i]
		e.Simple(&(*curr))
	}
}
func doDecodeReportItem(d binary.Decoder, o *ReportItem) {
	o.Severity = log.Severity(d.Int32())
	if obj := d.Object(); obj != nil {
		o.Message = obj.(*MsgRef)
	} else {
		o.Message = nil
	}
	o.Atom = uint64(d.Uint64())
	if count := d.Count(); count > 0 {
		o.Tags = make([]MsgRef, count)
		for i := range o.Tags {
			curr := &o.Tags[i]
			d.Simple(&(*curr))
		}
	}
}
func doDecodeRawReportItem(d binary.Decoder, o *ReportItem) {
	o.Severity = log.Severity(d.Int32())
	if obj := d.Object(); obj != nil {
		o.Message = obj.(*MsgRef)
	} else {
		o.Message = nil
	}
	o.Atom = uint64(d.Uint64())
	if count := d.Count(); count > 0 {
		o.Tags = make([]MsgRef, count)
		for i := range o.Tags {
			curr := &o.Tags[i]
			d.Simple(&(*curr))
		}
	}
}
func (*binaryClassReportItem) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeReportItem(e, obj.(*ReportItem))
}
func (*binaryClassReportItem) New() binary.Object {
	return &ReportItem{}
}
func (*binaryClassReportItem) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeReportItem(d, obj.(*ReportItem))
}
func (c *binaryClassReportItem) Schema() *binary.Entity {
	return &entities[ixǁReportItem]
}

type binaryClassReportGroup struct{}

func (*ReportGroup) Class() binary.Class {
	return (*binaryClassReportGroup)(nil)
}
func doEncodeReportGroup(e binary.Encoder, o *ReportGroup) {
	e.Simple(&o.Name)
	e.Uint32(uint32(len(o.Items)))
	for i := range o.Items {
		curr := &o.Items[i]
		e.Uint32(*curr)
	}
	e.Uint32(uint32(len(o.Tags)))
	for i := range o.Tags {
		curr := &o.Tags[i]
		e.Simple(&(*curr))
	}
}
func doDecodeReportGroup(d binary.Decoder, o *ReportGroup) {
	d.Simple(&o.Name)
	if count := d.Count(); count > 0 {
		o.Items = make([]uint32, count)
		for i := range o.Items {
			curr := &o.Items[i]
			*curr = uint32(d.Uint32())
		}
	}
	if count := d.Count(); count > 0 {
		o.Tags = make([]MsgRef, count)
		for i := range o.Tags {
			curr := &o.Tags[i]
			d.Simple(&(*curr))
		}
	}
}
func doDecodeRawReportGroup(d binary.Decoder, o *ReportGroup) {
	d.Simple(&o.Name)
	if count := d.Count(); count > 0 {
		o.Items = make([]uint32, count)
		for i := range o.Items {
			curr := &o.Items[i]
			*curr = uint32(d.Uint32())
		}
	}
	if count := d.Count(); count > 0 {
		o.Tags = make([]MsgRef, count)
		for i := range o.Tags {
			curr := &o.Tags[i]
			d.Simple(&(*curr))
		}
	}
}
func (*binaryClassReportGroup) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeReportGroup(e, obj.(*ReportGroup))
}
func (*binaryClassReportGroup) New() binary.Object {
	return &ReportGroup{}
}
func (*binaryClassReportGroup) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeReportGroup(d, obj.(*ReportGroup))
}
func (c *binaryClassReportGroup) Schema() *binary.Entity {
	return &entities[ixǁReportGroup]
}

type binaryClassReport struct{}

func (*Report) Class() binary.Class {
	return (*binaryClassReport)(nil)
}
func doEncodeReport(e binary.Encoder, o *Report) {
	e.Uint32(uint32(len(o.Items)))
	for i := range o.Items {
		curr := &o.Items[i]
		e.Struct(&(*curr))
	}
	e.Uint32(uint32(len(o.Groups)))
	for i := range o.Groups {
		curr := &o.Groups[i]
		e.Struct(&(*curr))
	}
	e.Uint32(uint32(len(o.MsgIdentifiers)))
	for i := range o.MsgIdentifiers {
		curr := &o.MsgIdentifiers[i]
		e.String(*curr)
	}
	e.Uint32(uint32(len(o.MsgArguments)))
	for i := range o.MsgArguments {
		curr := &o.MsgArguments[i]
		e.Struct(&(*curr))
	}
}
func doDecodeReport(d binary.Decoder, o *Report) {
	if count := d.Count(); count > 0 {
		o.Items = make([]ReportItem, count)
		for i := range o.Items {
			curr := &o.Items[i]
			d.Struct(&(*curr))
		}
	}
	if count := d.Count(); count > 0 {
		o.Groups = make([]ReportGroup, count)
		for i := range o.Groups {
			curr := &o.Groups[i]
			d.Struct(&(*curr))
		}
	}
	if count := d.Count(); count > 0 {
		o.MsgIdentifiers = make([]string, count)
		for i := range o.MsgIdentifiers {
			curr := &o.MsgIdentifiers[i]
			*curr = string(d.String())
		}
	}
	if count := d.Count(); count > 0 {
		o.MsgArguments = make([]msg.Arg, count)
		for i := range o.MsgArguments {
			curr := &o.MsgArguments[i]
			d.Struct(&(*curr))
		}
	}
}
func doDecodeRawReport(d binary.Decoder, o *Report) {
	if count := d.Count(); count > 0 {
		o.Items = make([]ReportItem, count)
		for i := range o.Items {
			curr := &o.Items[i]
			d.Struct(&(*curr))
		}
	}
	if count := d.Count(); count > 0 {
		o.Groups = make([]ReportGroup, count)
		for i := range o.Groups {
			curr := &o.Groups[i]
			d.Struct(&(*curr))
		}
	}
	if count := d.Count(); count > 0 {
		o.MsgIdentifiers = make([]string, count)
		for i := range o.MsgIdentifiers {
			curr := &o.MsgIdentifiers[i]
			*curr = string(d.String())
		}
	}
	if count := d.Count(); count > 0 {
		o.MsgArguments = make([]msg.Arg, count)
		for i := range o.MsgArguments {
			curr := &o.MsgArguments[i]
			d.Struct(&(*curr))
		}
	}
}
func (*binaryClassReport) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeReport(e, obj.(*Report))
}
func (*binaryClassReport) New() binary.Object {
	return &Report{}
}
func (*binaryClassReport) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeReport(d, obj.(*Report))
}
func (c *binaryClassReport) Schema() *binary.Entity {
	return &entities[ixǁReport]
}

type binaryClassResourceInfo struct{}

func (*ResourceInfo) Class() binary.Class {
	return (*binaryClassResourceInfo)(nil)
}
func doEncodeResourceInfo(e binary.Writer, o *ResourceInfo) {
	e.Data(o.ID[:20])
	e.String(o.Name)
	e.Uint32(uint32(len(o.Accesses)))
	for i := range o.Accesses {
		curr := &o.Accesses[i]
		e.Uint64(*curr)
	}
}
func doDecodeResourceInfo(d binary.Reader, o *ResourceInfo) {
	d.Data(o.ID[:20])
	o.Name = string(d.String())
	if count := d.Count(); count > 0 {
		o.Accesses = make([]uint64, count)
		for i := range o.Accesses {
			curr := &o.Accesses[i]
			*curr = uint64(d.Uint64())
		}
	}
}
func doDecodeRawResourceInfo(d binary.Reader, o *ResourceInfo) {
	d.Data(o.ID[:20])
	o.Name = string(d.String())
	if count := d.Count(); count > 0 {
		o.Accesses = make([]uint64, count)
		for i := range o.Accesses {
			curr := &o.Accesses[i]
			*curr = uint64(d.Uint64())
		}
	}
}
func (*binaryClassResourceInfo) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeResourceInfo(e, obj.(*ResourceInfo))
}
func (*binaryClassResourceInfo) New() binary.Object {
	return &ResourceInfo{}
}
func (*binaryClassResourceInfo) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeResourceInfo(d, obj.(*ResourceInfo))
}
func (o *ResourceInfo) WriteSimple(w binary.Writer) {
	doEncodeResourceInfo(w, o)
}
func (o *ResourceInfo) ReadSimple(r binary.Reader) {
	doDecodeResourceInfo(r, o)
}
func (c *binaryClassResourceInfo) Schema() *binary.Entity {
	return &entities[ixǁResourceInfo]
}

type binaryClassResourceBundle struct{}

func (*ResourceBundle) Class() binary.Class {
	return (*binaryClassResourceBundle)(nil)
}
func doEncodeResourceBundle(e binary.Encoder, o *ResourceBundle) {
	e.Int32(int32(o.Type))
	e.Uint32(uint32(len(o.Resources)))
	for i := range o.Resources {
		curr := &o.Resources[i]
		e.Simple(&(*curr))
	}
}
func doDecodeResourceBundle(d binary.Decoder, o *ResourceBundle) {
	o.Type = gfxapi.ResourceType(d.Int32())
	if count := d.Count(); count > 0 {
		o.Resources = make([]ResourceInfo, count)
		for i := range o.Resources {
			curr := &o.Resources[i]
			d.Simple(&(*curr))
		}
	}
}
func doDecodeRawResourceBundle(d binary.Decoder, o *ResourceBundle) {
	o.Type = gfxapi.ResourceType(d.Int32())
	if count := d.Count(); count > 0 {
		o.Resources = make([]ResourceInfo, count)
		for i := range o.Resources {
			curr := &o.Resources[i]
			d.Simple(&(*curr))
		}
	}
}
func (*binaryClassResourceBundle) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeResourceBundle(e, obj.(*ResourceBundle))
}
func (*binaryClassResourceBundle) New() binary.Object {
	return &ResourceBundle{}
}
func (*binaryClassResourceBundle) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeResourceBundle(d, obj.(*ResourceBundle))
}
func (c *binaryClassResourceBundle) Schema() *binary.Entity {
	return &entities[ixǁResourceBundle]
}

type binaryClassResourceBundles struct{}

func (*ResourceBundles) Class() binary.Class {
	return (*binaryClassResourceBundles)(nil)
}
func doEncodeResourceBundles(e binary.Encoder, o *ResourceBundles) {
	e.Uint32(uint32(len(o.Bundles)))
	for i := range o.Bundles {
		curr := &o.Bundles[i]
		e.Struct(&(*curr))
	}
}
func doDecodeResourceBundles(d binary.Decoder, o *ResourceBundles) {
	if count := d.Count(); count > 0 {
		o.Bundles = make([]ResourceBundle, count)
		for i := range o.Bundles {
			curr := &o.Bundles[i]
			d.Struct(&(*curr))
		}
	}
}
func doDecodeRawResourceBundles(d binary.Decoder, o *ResourceBundles) {
	if count := d.Count(); count > 0 {
		o.Bundles = make([]ResourceBundle, count)
		for i := range o.Bundles {
			curr := &o.Bundles[i]
			d.Struct(&(*curr))
		}
	}
}
func (*binaryClassResourceBundles) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeResourceBundles(e, obj.(*ResourceBundles))
}
func (*binaryClassResourceBundles) New() binary.Object {
	return &ResourceBundles{}
}
func (*binaryClassResourceBundles) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeResourceBundles(d, obj.(*ResourceBundles))
}
func (c *binaryClassResourceBundles) Schema() *binary.Entity {
	return &entities[ixǁResourceBundles]
}

type binaryClassResources struct{}

func (*Resources) Class() binary.Class {
	return (*binaryClassResources)(nil)
}
func doEncodeResources(e binary.Encoder, o *Resources) {
	e.Uint32(uint32(len(o.Textures1D)))
	for i := range o.Textures1D {
		curr := &o.Textures1D[i]
		e.Simple(&(*curr))
	}
	e.Uint32(uint32(len(o.Textures2D)))
	for i := range o.Textures2D {
		curr := &o.Textures2D[i]
		e.Simple(&(*curr))
	}
	e.Uint32(uint32(len(o.Textures3D)))
	for i := range o.Textures3D {
		curr := &o.Textures3D[i]
		e.Simple(&(*curr))
	}
	e.Uint32(uint32(len(o.Cubemaps)))
	for i := range o.Cubemaps {
		curr := &o.Cubemaps[i]
		e.Simple(&(*curr))
	}
}
func doDecodeResources(d binary.Decoder, o *Resources) {
	if count := d.Count(); count > 0 {
		o.Textures1D = make([]ResourceInfo, count)
		for i := range o.Textures1D {
			curr := &o.Textures1D[i]
			d.Simple(&(*curr))
		}
	}
	if count := d.Count(); count > 0 {
		o.Textures2D = make([]ResourceInfo, count)
		for i := range o.Textures2D {
			curr := &o.Textures2D[i]
			d.Simple(&(*curr))
		}
	}
	if count := d.Count(); count > 0 {
		o.Textures3D = make([]ResourceInfo, count)
		for i := range o.Textures3D {
			curr := &o.Textures3D[i]
			d.Simple(&(*curr))
		}
	}
	if count := d.Count(); count > 0 {
		o.Cubemaps = make([]ResourceInfo, count)
		for i := range o.Cubemaps {
			curr := &o.Cubemaps[i]
			d.Simple(&(*curr))
		}
	}
}
func doDecodeRawResources(d binary.Decoder, o *Resources) {
	if count := d.Count(); count > 0 {
		o.Textures1D = make([]ResourceInfo, count)
		for i := range o.Textures1D {
			curr := &o.Textures1D[i]
			d.Simple(&(*curr))
		}
	}
	if count := d.Count(); count > 0 {
		o.Textures2D = make([]ResourceInfo, count)
		for i := range o.Textures2D {
			curr := &o.Textures2D[i]
			d.Simple(&(*curr))
		}
	}
	if count := d.Count(); count > 0 {
		o.Textures3D = make([]ResourceInfo, count)
		for i := range o.Textures3D {
			curr := &o.Textures3D[i]
			d.Simple(&(*curr))
		}
	}
	if count := d.Count(); count > 0 {
		o.Cubemaps = make([]ResourceInfo, count)
		for i := range o.Cubemaps {
			curr := &o.Cubemaps[i]
			d.Simple(&(*curr))
		}
	}
}
func (*binaryClassResources) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeResources(e, obj.(*Resources))
}
func (*binaryClassResources) New() binary.Object {
	return &Resources{}
}
func (*binaryClassResources) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeResources(d, obj.(*Resources))
}
func (c *binaryClassResources) Schema() *binary.Entity {
	return &entities[ixǁResources]
}

type binaryClassTimingInfo struct{}

func (*TimingInfo) Class() binary.Class {
	return (*binaryClassTimingInfo)(nil)
}
func doEncodeTimingInfo(e binary.Writer, o *TimingInfo) {
	e.Uint32(uint32(len(o.PerCommand)))
	for i := range o.PerCommand {
		curr := &o.PerCommand[i]
		e.Simple(&(*curr))
	}
	e.Uint32(uint32(len(o.PerDrawCall)))
	for i := range o.PerDrawCall {
		curr := &o.PerDrawCall[i]
		e.Simple(&(*curr))
	}
	e.Uint32(uint32(len(o.PerFrame)))
	for i := range o.PerFrame {
		curr := &o.PerFrame[i]
		e.Simple(&(*curr))
	}
}
func doDecodeTimingInfo(d binary.Reader, o *TimingInfo) {
	if count := d.Count(); count > 0 {
		o.PerCommand = make([]AtomTimer, count)
		for i := range o.PerCommand {
			curr := &o.PerCommand[i]
			d.Simple(&(*curr))
		}
	}
	if count := d.Count(); count > 0 {
		o.PerDrawCall = make([]AtomRangeTimer, count)
		for i := range o.PerDrawCall {
			curr := &o.PerDrawCall[i]
			d.Simple(&(*curr))
		}
	}
	if count := d.Count(); count > 0 {
		o.PerFrame = make([]AtomRangeTimer, count)
		for i := range o.PerFrame {
			curr := &o.PerFrame[i]
			d.Simple(&(*curr))
		}
	}
}
func doDecodeRawTimingInfo(d binary.Reader, o *TimingInfo) {
	if count := d.Count(); count > 0 {
		o.PerCommand = make([]AtomTimer, count)
		for i := range o.PerCommand {
			curr := &o.PerCommand[i]
			d.Simple(&(*curr))
		}
	}
	if count := d.Count(); count > 0 {
		o.PerDrawCall = make([]AtomRangeTimer, count)
		for i := range o.PerDrawCall {
			curr := &o.PerDrawCall[i]
			d.Simple(&(*curr))
		}
	}
	if count := d.Count(); count > 0 {
		o.PerFrame = make([]AtomRangeTimer, count)
		for i := range o.PerFrame {
			curr := &o.PerFrame[i]
			d.Simple(&(*curr))
		}
	}
}
func (*binaryClassTimingInfo) Encode(e binary.Encoder, obj binary.Object) {
	doEncodeTimingInfo(e, obj.(*TimingInfo))
}
func (*binaryClassTimingInfo) New() binary.Object {
	return &TimingInfo{}
}
func (*binaryClassTimingInfo) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodeTimingInfo(d, obj.(*TimingInfo))
}
func (o *TimingInfo) WriteSimple(w binary.Writer) {
	doEncodeTimingInfo(w, o)
}
func (o *TimingInfo) ReadSimple(r binary.Reader) {
	doDecodeTimingInfo(r, o)
}
func (c *binaryClassTimingInfo) Schema() *binary.Entity {
	return &entities[ixǁTimingInfo]
}

type binaryClasscallBeginCPUProfile struct{}

func (*callBeginCPUProfile) Class() binary.Class {
	return (*binaryClasscallBeginCPUProfile)(nil)
}
func doEncodecallBeginCPUProfile(e binary.Writer, o *callBeginCPUProfile) {
}
func doDecodecallBeginCPUProfile(d binary.Reader, o *callBeginCPUProfile) {
}
func doDecodeRawcallBeginCPUProfile(d binary.Reader, o *callBeginCPUProfile) {
}
func (*binaryClasscallBeginCPUProfile) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallBeginCPUProfile(e, obj.(*callBeginCPUProfile))
}
func (*binaryClasscallBeginCPUProfile) New() binary.Object {
	return &callBeginCPUProfile{}
}
func (*binaryClasscallBeginCPUProfile) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallBeginCPUProfile(d, obj.(*callBeginCPUProfile))
}
func (o *callBeginCPUProfile) WriteSimple(w binary.Writer) {
	doEncodecallBeginCPUProfile(w, o)
}
func (o *callBeginCPUProfile) ReadSimple(r binary.Reader) {
	doDecodecallBeginCPUProfile(r, o)
}
func (c *binaryClasscallBeginCPUProfile) Schema() *binary.Entity {
	return &entities[ixǁcallBeginCPUProfile]
}

type binaryClasscallEndCPUProfile struct{}

func (*callEndCPUProfile) Class() binary.Class {
	return (*binaryClasscallEndCPUProfile)(nil)
}
func doEncodecallEndCPUProfile(e binary.Writer, o *callEndCPUProfile) {
}
func doDecodecallEndCPUProfile(d binary.Reader, o *callEndCPUProfile) {
}
func doDecodeRawcallEndCPUProfile(d binary.Reader, o *callEndCPUProfile) {
}
func (*binaryClasscallEndCPUProfile) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallEndCPUProfile(e, obj.(*callEndCPUProfile))
}
func (*binaryClasscallEndCPUProfile) New() binary.Object {
	return &callEndCPUProfile{}
}
func (*binaryClasscallEndCPUProfile) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallEndCPUProfile(d, obj.(*callEndCPUProfile))
}
func (o *callEndCPUProfile) WriteSimple(w binary.Writer) {
	doEncodecallEndCPUProfile(w, o)
}
func (o *callEndCPUProfile) ReadSimple(r binary.Reader) {
	doDecodecallEndCPUProfile(r, o)
}
func (c *binaryClasscallEndCPUProfile) Schema() *binary.Entity {
	return &entities[ixǁcallEndCPUProfile]
}

type binaryClasscallFollow struct{}

func (*callFollow) Class() binary.Class {
	return (*binaryClasscallFollow)(nil)
}
func doEncodecallFollow(e binary.Encoder, o *callFollow) {
	e.Object(o.p)
}
func doDecodecallFollow(d binary.Decoder, o *callFollow) {
	o.p = path.PathCast(d.Object())
}
func doDecodeRawcallFollow(d binary.Decoder, o *callFollow) {
	o.p = path.PathCast(d.Object())
}
func (*binaryClasscallFollow) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallFollow(e, obj.(*callFollow))
}
func (*binaryClasscallFollow) New() binary.Object {
	return &callFollow{}
}
func (*binaryClasscallFollow) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallFollow(d, obj.(*callFollow))
}
func (c *binaryClasscallFollow) Schema() *binary.Entity {
	return &entities[ixǁcallFollow]
}

type binaryClasscallGet struct{}

func (*callGet) Class() binary.Class {
	return (*binaryClasscallGet)(nil)
}
func doEncodecallGet(e binary.Encoder, o *callGet) {
	e.Object(o.p)
}
func doDecodecallGet(d binary.Decoder, o *callGet) {
	o.p = path.PathCast(d.Object())
}
func doDecodeRawcallGet(d binary.Decoder, o *callGet) {
	o.p = path.PathCast(d.Object())
}
func (*binaryClasscallGet) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallGet(e, obj.(*callGet))
}
func (*binaryClasscallGet) New() binary.Object {
	return &callGet{}
}
func (*binaryClasscallGet) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallGet(d, obj.(*callGet))
}
func (c *binaryClasscallGet) Schema() *binary.Entity {
	return &entities[ixǁcallGet]
}

type binaryClasscallGetAvailableStringTables struct{}

func (*callGetAvailableStringTables) Class() binary.Class {
	return (*binaryClasscallGetAvailableStringTables)(nil)
}
func doEncodecallGetAvailableStringTables(e binary.Writer, o *callGetAvailableStringTables) {
}
func doDecodecallGetAvailableStringTables(d binary.Reader, o *callGetAvailableStringTables) {
}
func doDecodeRawcallGetAvailableStringTables(d binary.Reader, o *callGetAvailableStringTables) {
}
func (*binaryClasscallGetAvailableStringTables) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallGetAvailableStringTables(e, obj.(*callGetAvailableStringTables))
}
func (*binaryClasscallGetAvailableStringTables) New() binary.Object {
	return &callGetAvailableStringTables{}
}
func (*binaryClasscallGetAvailableStringTables) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallGetAvailableStringTables(d, obj.(*callGetAvailableStringTables))
}
func (o *callGetAvailableStringTables) WriteSimple(w binary.Writer) {
	doEncodecallGetAvailableStringTables(w, o)
}
func (o *callGetAvailableStringTables) ReadSimple(r binary.Reader) {
	doDecodecallGetAvailableStringTables(r, o)
}
func (c *binaryClasscallGetAvailableStringTables) Schema() *binary.Entity {
	return &entities[ixǁcallGetAvailableStringTables]
}

type binaryClasscallGetCaptures struct{}

func (*callGetCaptures) Class() binary.Class {
	return (*binaryClasscallGetCaptures)(nil)
}
func doEncodecallGetCaptures(e binary.Writer, o *callGetCaptures) {
}
func doDecodecallGetCaptures(d binary.Reader, o *callGetCaptures) {
}
func doDecodeRawcallGetCaptures(d binary.Reader, o *callGetCaptures) {
}
func (*binaryClasscallGetCaptures) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallGetCaptures(e, obj.(*callGetCaptures))
}
func (*binaryClasscallGetCaptures) New() binary.Object {
	return &callGetCaptures{}
}
func (*binaryClasscallGetCaptures) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallGetCaptures(d, obj.(*callGetCaptures))
}
func (o *callGetCaptures) WriteSimple(w binary.Writer) {
	doEncodecallGetCaptures(w, o)
}
func (o *callGetCaptures) ReadSimple(r binary.Reader) {
	doDecodecallGetCaptures(r, o)
}
func (c *binaryClasscallGetCaptures) Schema() *binary.Entity {
	return &entities[ixǁcallGetCaptures]
}

type binaryClasscallGetDevices struct{}

func (*callGetDevices) Class() binary.Class {
	return (*binaryClasscallGetDevices)(nil)
}
func doEncodecallGetDevices(e binary.Writer, o *callGetDevices) {
}
func doDecodecallGetDevices(d binary.Reader, o *callGetDevices) {
}
func doDecodeRawcallGetDevices(d binary.Reader, o *callGetDevices) {
}
func (*binaryClasscallGetDevices) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallGetDevices(e, obj.(*callGetDevices))
}
func (*binaryClasscallGetDevices) New() binary.Object {
	return &callGetDevices{}
}
func (*binaryClasscallGetDevices) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallGetDevices(d, obj.(*callGetDevices))
}
func (o *callGetDevices) WriteSimple(w binary.Writer) {
	doEncodecallGetDevices(w, o)
}
func (o *callGetDevices) ReadSimple(r binary.Reader) {
	doDecodecallGetDevices(r, o)
}
func (c *binaryClasscallGetDevices) Schema() *binary.Entity {
	return &entities[ixǁcallGetDevices]
}

type binaryClasscallGetFeatures struct{}

func (*callGetFeatures) Class() binary.Class {
	return (*binaryClasscallGetFeatures)(nil)
}
func doEncodecallGetFeatures(e binary.Writer, o *callGetFeatures) {
}
func doDecodecallGetFeatures(d binary.Reader, o *callGetFeatures) {
}
func doDecodeRawcallGetFeatures(d binary.Reader, o *callGetFeatures) {
}
func (*binaryClasscallGetFeatures) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallGetFeatures(e, obj.(*callGetFeatures))
}
func (*binaryClasscallGetFeatures) New() binary.Object {
	return &callGetFeatures{}
}
func (*binaryClasscallGetFeatures) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallGetFeatures(d, obj.(*callGetFeatures))
}
func (o *callGetFeatures) WriteSimple(w binary.Writer) {
	doEncodecallGetFeatures(w, o)
}
func (o *callGetFeatures) ReadSimple(r binary.Reader) {
	doDecodecallGetFeatures(r, o)
}
func (c *binaryClasscallGetFeatures) Schema() *binary.Entity {
	return &entities[ixǁcallGetFeatures]
}

type binaryClasscallGetFramebufferAttachment struct{}

func (*callGetFramebufferAttachment) Class() binary.Class {
	return (*binaryClasscallGetFramebufferAttachment)(nil)
}
func doEncodecallGetFramebufferAttachment(e binary.Encoder, o *callGetFramebufferAttachment) {
	if o.device != nil {
		e.Object(o.device)
	} else {
		e.Object(nil)
	}
	if o.after != nil {
		e.Object(o.after)
	} else {
		e.Object(nil)
	}
	e.Int32(int32(o.attachment))
	e.Simple(&o.settings)
}
func doDecodecallGetFramebufferAttachment(d binary.Decoder, o *callGetFramebufferAttachment) {
	if obj := d.Object(); obj != nil {
		o.device = obj.(*path.Device)
	} else {
		o.device = nil
	}
	if obj := d.Object(); obj != nil {
		o.after = obj.(*path.Atom)
	} else {
		o.after = nil
	}
	o.attachment = gfxapi.FramebufferAttachment(d.Int32())
	d.Simple(&o.settings)
}
func doDecodeRawcallGetFramebufferAttachment(d binary.Decoder, o *callGetFramebufferAttachment) {
	if obj := d.Object(); obj != nil {
		o.device = obj.(*path.Device)
	} else {
		o.device = nil
	}
	if obj := d.Object(); obj != nil {
		o.after = obj.(*path.Atom)
	} else {
		o.after = nil
	}
	o.attachment = gfxapi.FramebufferAttachment(d.Int32())
	d.Simple(&o.settings)
}
func (*binaryClasscallGetFramebufferAttachment) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallGetFramebufferAttachment(e, obj.(*callGetFramebufferAttachment))
}
func (*binaryClasscallGetFramebufferAttachment) New() binary.Object {
	return &callGetFramebufferAttachment{}
}
func (*binaryClasscallGetFramebufferAttachment) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallGetFramebufferAttachment(d, obj.(*callGetFramebufferAttachment))
}
func (c *binaryClasscallGetFramebufferAttachment) Schema() *binary.Entity {
	return &entities[ixǁcallGetFramebufferAttachment]
}

type binaryClasscallGetFramebufferColor struct{}

func (*callGetFramebufferColor) Class() binary.Class {
	return (*binaryClasscallGetFramebufferColor)(nil)
}
func doEncodecallGetFramebufferColor(e binary.Encoder, o *callGetFramebufferColor) {
	if o.device != nil {
		e.Object(o.device)
	} else {
		e.Object(nil)
	}
	if o.after != nil {
		e.Object(o.after)
	} else {
		e.Object(nil)
	}
	e.Simple(&o.settings)
}
func doDecodecallGetFramebufferColor(d binary.Decoder, o *callGetFramebufferColor) {
	if obj := d.Object(); obj != nil {
		o.device = obj.(*path.Device)
	} else {
		o.device = nil
	}
	if obj := d.Object(); obj != nil {
		o.after = obj.(*path.Atom)
	} else {
		o.after = nil
	}
	d.Simple(&o.settings)
}
func doDecodeRawcallGetFramebufferColor(d binary.Decoder, o *callGetFramebufferColor) {
	if obj := d.Object(); obj != nil {
		o.device = obj.(*path.Device)
	} else {
		o.device = nil
	}
	if obj := d.Object(); obj != nil {
		o.after = obj.(*path.Atom)
	} else {
		o.after = nil
	}
	d.Simple(&o.settings)
}
func (*binaryClasscallGetFramebufferColor) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallGetFramebufferColor(e, obj.(*callGetFramebufferColor))
}
func (*binaryClasscallGetFramebufferColor) New() binary.Object {
	return &callGetFramebufferColor{}
}
func (*binaryClasscallGetFramebufferColor) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallGetFramebufferColor(d, obj.(*callGetFramebufferColor))
}
func (c *binaryClasscallGetFramebufferColor) Schema() *binary.Entity {
	return &entities[ixǁcallGetFramebufferColor]
}

type binaryClasscallGetFramebufferDepth struct{}

func (*callGetFramebufferDepth) Class() binary.Class {
	return (*binaryClasscallGetFramebufferDepth)(nil)
}
func doEncodecallGetFramebufferDepth(e binary.Encoder, o *callGetFramebufferDepth) {
	if o.device != nil {
		e.Object(o.device)
	} else {
		e.Object(nil)
	}
	if o.after != nil {
		e.Object(o.after)
	} else {
		e.Object(nil)
	}
}
func doDecodecallGetFramebufferDepth(d binary.Decoder, o *callGetFramebufferDepth) {
	if obj := d.Object(); obj != nil {
		o.device = obj.(*path.Device)
	} else {
		o.device = nil
	}
	if obj := d.Object(); obj != nil {
		o.after = obj.(*path.Atom)
	} else {
		o.after = nil
	}
}
func doDecodeRawcallGetFramebufferDepth(d binary.Decoder, o *callGetFramebufferDepth) {
	if obj := d.Object(); obj != nil {
		o.device = obj.(*path.Device)
	} else {
		o.device = nil
	}
	if obj := d.Object(); obj != nil {
		o.after = obj.(*path.Atom)
	} else {
		o.after = nil
	}
}
func (*binaryClasscallGetFramebufferDepth) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallGetFramebufferDepth(e, obj.(*callGetFramebufferDepth))
}
func (*binaryClasscallGetFramebufferDepth) New() binary.Object {
	return &callGetFramebufferDepth{}
}
func (*binaryClasscallGetFramebufferDepth) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallGetFramebufferDepth(d, obj.(*callGetFramebufferDepth))
}
func (c *binaryClasscallGetFramebufferDepth) Schema() *binary.Entity {
	return &entities[ixǁcallGetFramebufferDepth]
}

type binaryClasscallGetMemProfileRate struct{}

func (*callGetMemProfileRate) Class() binary.Class {
	return (*binaryClasscallGetMemProfileRate)(nil)
}
func doEncodecallGetMemProfileRate(e binary.Writer, o *callGetMemProfileRate) {
}
func doDecodecallGetMemProfileRate(d binary.Reader, o *callGetMemProfileRate) {
}
func doDecodeRawcallGetMemProfileRate(d binary.Reader, o *callGetMemProfileRate) {
}
func (*binaryClasscallGetMemProfileRate) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallGetMemProfileRate(e, obj.(*callGetMemProfileRate))
}
func (*binaryClasscallGetMemProfileRate) New() binary.Object {
	return &callGetMemProfileRate{}
}
func (*binaryClasscallGetMemProfileRate) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallGetMemProfileRate(d, obj.(*callGetMemProfileRate))
}
func (o *callGetMemProfileRate) WriteSimple(w binary.Writer) {
	doEncodecallGetMemProfileRate(w, o)
}
func (o *callGetMemProfileRate) ReadSimple(r binary.Reader) {
	doDecodecallGetMemProfileRate(r, o)
}
func (c *binaryClasscallGetMemProfileRate) Schema() *binary.Entity {
	return &entities[ixǁcallGetMemProfileRate]
}

type binaryClasscallGetPerformanceCounters struct{}

func (*callGetPerformanceCounters) Class() binary.Class {
	return (*binaryClasscallGetPerformanceCounters)(nil)
}
func doEncodecallGetPerformanceCounters(e binary.Writer, o *callGetPerformanceCounters) {
}
func doDecodecallGetPerformanceCounters(d binary.Reader, o *callGetPerformanceCounters) {
}
func doDecodeRawcallGetPerformanceCounters(d binary.Reader, o *callGetPerformanceCounters) {
}
func (*binaryClasscallGetPerformanceCounters) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallGetPerformanceCounters(e, obj.(*callGetPerformanceCounters))
}
func (*binaryClasscallGetPerformanceCounters) New() binary.Object {
	return &callGetPerformanceCounters{}
}
func (*binaryClasscallGetPerformanceCounters) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallGetPerformanceCounters(d, obj.(*callGetPerformanceCounters))
}
func (o *callGetPerformanceCounters) WriteSimple(w binary.Writer) {
	doEncodecallGetPerformanceCounters(w, o)
}
func (o *callGetPerformanceCounters) ReadSimple(r binary.Reader) {
	doDecodecallGetPerformanceCounters(r, o)
}
func (c *binaryClasscallGetPerformanceCounters) Schema() *binary.Entity {
	return &entities[ixǁcallGetPerformanceCounters]
}

type binaryClasscallGetProfile struct{}

func (*callGetProfile) Class() binary.Class {
	return (*binaryClasscallGetProfile)(nil)
}
func doEncodecallGetProfile(e binary.Writer, o *callGetProfile) {
	e.String(o.name)
	e.Int32(int32(o.debug))
}
func doDecodecallGetProfile(d binary.Reader, o *callGetProfile) {
	o.name = string(d.String())
	o.debug = int(d.Int32())
}
func doDecodeRawcallGetProfile(d binary.Reader, o *callGetProfile) {
	o.name = string(d.String())
	o.debug = int(d.Int32())
}
func (*binaryClasscallGetProfile) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallGetProfile(e, obj.(*callGetProfile))
}
func (*binaryClasscallGetProfile) New() binary.Object {
	return &callGetProfile{}
}
func (*binaryClasscallGetProfile) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallGetProfile(d, obj.(*callGetProfile))
}
func (o *callGetProfile) WriteSimple(w binary.Writer) {
	doEncodecallGetProfile(w, o)
}
func (o *callGetProfile) ReadSimple(r binary.Reader) {
	doDecodecallGetProfile(r, o)
}
func (c *binaryClasscallGetProfile) Schema() *binary.Entity {
	return &entities[ixǁcallGetProfile]
}

type binaryClasscallGetSchema struct{}

func (*callGetSchema) Class() binary.Class {
	return (*binaryClasscallGetSchema)(nil)
}
func doEncodecallGetSchema(e binary.Writer, o *callGetSchema) {
}
func doDecodecallGetSchema(d binary.Reader, o *callGetSchema) {
}
func doDecodeRawcallGetSchema(d binary.Reader, o *callGetSchema) {
}
func (*binaryClasscallGetSchema) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallGetSchema(e, obj.(*callGetSchema))
}
func (*binaryClasscallGetSchema) New() binary.Object {
	return &callGetSchema{}
}
func (*binaryClasscallGetSchema) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallGetSchema(d, obj.(*callGetSchema))
}
func (o *callGetSchema) WriteSimple(w binary.Writer) {
	doEncodecallGetSchema(w, o)
}
func (o *callGetSchema) ReadSimple(r binary.Reader) {
	doDecodecallGetSchema(r, o)
}
func (c *binaryClasscallGetSchema) Schema() *binary.Entity {
	return &entities[ixǁcallGetSchema]
}

type binaryClasscallGetStringTable struct{}

func (*callGetStringTable) Class() binary.Class {
	return (*binaryClasscallGetStringTable)(nil)
}
func doEncodecallGetStringTable(e binary.Writer, o *callGetStringTable) {
	e.Simple(&o.info)
}
func doDecodecallGetStringTable(d binary.Reader, o *callGetStringTable) {
	d.Simple(&o.info)
}
func doDecodeRawcallGetStringTable(d binary.Reader, o *callGetStringTable) {
	d.Simple(&o.info)
}
func (*binaryClasscallGetStringTable) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallGetStringTable(e, obj.(*callGetStringTable))
}
func (*binaryClasscallGetStringTable) New() binary.Object {
	return &callGetStringTable{}
}
func (*binaryClasscallGetStringTable) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallGetStringTable(d, obj.(*callGetStringTable))
}
func (o *callGetStringTable) WriteSimple(w binary.Writer) {
	doEncodecallGetStringTable(w, o)
}
func (o *callGetStringTable) ReadSimple(r binary.Reader) {
	doDecodecallGetStringTable(r, o)
}
func (c *binaryClasscallGetStringTable) Schema() *binary.Entity {
	return &entities[ixǁcallGetStringTable]
}

type binaryClasscallGetTimingInfo struct{}

func (*callGetTimingInfo) Class() binary.Class {
	return (*binaryClasscallGetTimingInfo)(nil)
}
func doEncodecallGetTimingInfo(e binary.Encoder, o *callGetTimingInfo) {
	if o.device != nil {
		e.Object(o.device)
	} else {
		e.Object(nil)
	}
	if o.capture != nil {
		e.Object(o.capture)
	} else {
		e.Object(nil)
	}
	e.Int32(int32(o.flags))
}
func doDecodecallGetTimingInfo(d binary.Decoder, o *callGetTimingInfo) {
	if obj := d.Object(); obj != nil {
		o.device = obj.(*path.Device)
	} else {
		o.device = nil
	}
	if obj := d.Object(); obj != nil {
		o.capture = obj.(*path.Capture)
	} else {
		o.capture = nil
	}
	o.flags = TimingFlags(d.Int32())
}
func doDecodeRawcallGetTimingInfo(d binary.Decoder, o *callGetTimingInfo) {
	if obj := d.Object(); obj != nil {
		o.device = obj.(*path.Device)
	} else {
		o.device = nil
	}
	if obj := d.Object(); obj != nil {
		o.capture = obj.(*path.Capture)
	} else {
		o.capture = nil
	}
	o.flags = TimingFlags(d.Int32())
}
func (*binaryClasscallGetTimingInfo) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallGetTimingInfo(e, obj.(*callGetTimingInfo))
}
func (*binaryClasscallGetTimingInfo) New() binary.Object {
	return &callGetTimingInfo{}
}
func (*binaryClasscallGetTimingInfo) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallGetTimingInfo(d, obj.(*callGetTimingInfo))
}
func (c *binaryClasscallGetTimingInfo) Schema() *binary.Entity {
	return &entities[ixǁcallGetTimingInfo]
}

type binaryClasscallImportCapture struct{}

func (*callImportCapture) Class() binary.Class {
	return (*binaryClasscallImportCapture)(nil)
}
func doEncodecallImportCapture(e binary.Writer, o *callImportCapture) {
	e.String(o.name)
	e.Uint32(uint32(len(o.Data)))
	e.Data(o.Data)
}
func doDecodecallImportCapture(d binary.Reader, o *callImportCapture) {
	o.name = string(d.String())
	if count := d.Count(); count > 0 {
		o.Data = make([]uint8, count)
		d.Data(o.Data)
	}
}
func doDecodeRawcallImportCapture(d binary.Reader, o *callImportCapture) {
	o.name = string(d.String())
	if count := d.Count(); count > 0 {
		o.Data = make([]uint8, count)
		d.Data(o.Data)
	}
}
func (*binaryClasscallImportCapture) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallImportCapture(e, obj.(*callImportCapture))
}
func (*binaryClasscallImportCapture) New() binary.Object {
	return &callImportCapture{}
}
func (*binaryClasscallImportCapture) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallImportCapture(d, obj.(*callImportCapture))
}
func (o *callImportCapture) WriteSimple(w binary.Writer) {
	doEncodecallImportCapture(w, o)
}
func (o *callImportCapture) ReadSimple(r binary.Reader) {
	doDecodecallImportCapture(r, o)
}
func (c *binaryClasscallImportCapture) Schema() *binary.Entity {
	return &entities[ixǁcallImportCapture]
}

type binaryClasscallLoadCapture struct{}

func (*callLoadCapture) Class() binary.Class {
	return (*binaryClasscallLoadCapture)(nil)
}
func doEncodecallLoadCapture(e binary.Writer, o *callLoadCapture) {
	e.String(o.path)
}
func doDecodecallLoadCapture(d binary.Reader, o *callLoadCapture) {
	o.path = string(d.String())
}
func doDecodeRawcallLoadCapture(d binary.Reader, o *callLoadCapture) {
	o.path = string(d.String())
}
func (*binaryClasscallLoadCapture) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallLoadCapture(e, obj.(*callLoadCapture))
}
func (*binaryClasscallLoadCapture) New() binary.Object {
	return &callLoadCapture{}
}
func (*binaryClasscallLoadCapture) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallLoadCapture(d, obj.(*callLoadCapture))
}
func (o *callLoadCapture) WriteSimple(w binary.Writer) {
	doEncodecallLoadCapture(w, o)
}
func (o *callLoadCapture) ReadSimple(r binary.Reader) {
	doDecodecallLoadCapture(r, o)
}
func (c *binaryClasscallLoadCapture) Schema() *binary.Entity {
	return &entities[ixǁcallLoadCapture]
}

type binaryClasscallRegisterAndroidDevice struct{}

func (*callRegisterAndroidDevice) Class() binary.Class {
	return (*binaryClasscallRegisterAndroidDevice)(nil)
}
func doEncodecallRegisterAndroidDevice(e binary.Writer, o *callRegisterAndroidDevice) {
	e.String(o.serial)
}
func doDecodecallRegisterAndroidDevice(d binary.Reader, o *callRegisterAndroidDevice) {
	o.serial = string(d.String())
}
func doDecodeRawcallRegisterAndroidDevice(d binary.Reader, o *callRegisterAndroidDevice) {
	o.serial = string(d.String())
}
func (*binaryClasscallRegisterAndroidDevice) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallRegisterAndroidDevice(e, obj.(*callRegisterAndroidDevice))
}
func (*binaryClasscallRegisterAndroidDevice) New() binary.Object {
	return &callRegisterAndroidDevice{}
}
func (*binaryClasscallRegisterAndroidDevice) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallRegisterAndroidDevice(d, obj.(*callRegisterAndroidDevice))
}
func (o *callRegisterAndroidDevice) WriteSimple(w binary.Writer) {
	doEncodecallRegisterAndroidDevice(w, o)
}
func (o *callRegisterAndroidDevice) ReadSimple(r binary.Reader) {
	doDecodecallRegisterAndroidDevice(r, o)
}
func (c *binaryClasscallRegisterAndroidDevice) Schema() *binary.Entity {
	return &entities[ixǁcallRegisterAndroidDevice]
}

type binaryClasscallSet struct{}

func (*callSet) Class() binary.Class {
	return (*binaryClasscallSet)(nil)
}
func doEncodecallSet(e binary.Encoder, o *callSet) {
	e.Object(o.p)
	schema.Any{}.EncodeValue(e, o.v)
}
func doDecodecallSet(d binary.Decoder, o *callSet) {
	o.p = path.PathCast(d.Object())
	o.v = schema.Any{}.DecodeValue(d)
}
func doDecodeRawcallSet(d binary.Decoder, o *callSet) {
	o.p = path.PathCast(d.Object())
	o.v = schema.Any{}.DecodeValue(d)
}
func (*binaryClasscallSet) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallSet(e, obj.(*callSet))
}
func (*binaryClasscallSet) New() binary.Object {
	return &callSet{}
}
func (*binaryClasscallSet) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallSet(d, obj.(*callSet))
}
func (c *binaryClasscallSet) Schema() *binary.Entity {
	return &entities[ixǁcallSet]
}

type binaryClasscallSetMemProfileRate struct{}

func (*callSetMemProfileRate) Class() binary.Class {
	return (*binaryClasscallSetMemProfileRate)(nil)
}
func doEncodecallSetMemProfileRate(e binary.Writer, o *callSetMemProfileRate) {
	e.Int32(int32(o.rate))
}
func doDecodecallSetMemProfileRate(d binary.Reader, o *callSetMemProfileRate) {
	o.rate = int(d.Int32())
}
func doDecodeRawcallSetMemProfileRate(d binary.Reader, o *callSetMemProfileRate) {
	o.rate = int(d.Int32())
}
func (*binaryClasscallSetMemProfileRate) Encode(e binary.Encoder, obj binary.Object) {
	doEncodecallSetMemProfileRate(e, obj.(*callSetMemProfileRate))
}
func (*binaryClasscallSetMemProfileRate) New() binary.Object {
	return &callSetMemProfileRate{}
}
func (*binaryClasscallSetMemProfileRate) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecodecallSetMemProfileRate(d, obj.(*callSetMemProfileRate))
}
func (o *callSetMemProfileRate) WriteSimple(w binary.Writer) {
	doEncodecallSetMemProfileRate(w, o)
}
func (o *callSetMemProfileRate) ReadSimple(r binary.Reader) {
	doDecodecallSetMemProfileRate(r, o)
}
func (c *binaryClasscallSetMemProfileRate) Schema() *binary.Entity {
	return &entities[ixǁcallSetMemProfileRate]
}

type binaryClassresultBeginCPUProfile struct{}

func (*resultBeginCPUProfile) Class() binary.Class {
	return (*binaryClassresultBeginCPUProfile)(nil)
}
func doEncoderesultBeginCPUProfile(e binary.Writer, o *resultBeginCPUProfile) {
}
func doDecoderesultBeginCPUProfile(d binary.Reader, o *resultBeginCPUProfile) {
}
func doDecodeRawresultBeginCPUProfile(d binary.Reader, o *resultBeginCPUProfile) {
}
func (*binaryClassresultBeginCPUProfile) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultBeginCPUProfile(e, obj.(*resultBeginCPUProfile))
}
func (*binaryClassresultBeginCPUProfile) New() binary.Object {
	return &resultBeginCPUProfile{}
}
func (*binaryClassresultBeginCPUProfile) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultBeginCPUProfile(d, obj.(*resultBeginCPUProfile))
}
func (o *resultBeginCPUProfile) WriteSimple(w binary.Writer) {
	doEncoderesultBeginCPUProfile(w, o)
}
func (o *resultBeginCPUProfile) ReadSimple(r binary.Reader) {
	doDecoderesultBeginCPUProfile(r, o)
}
func (c *binaryClassresultBeginCPUProfile) Schema() *binary.Entity {
	return &entities[ixǁresultBeginCPUProfile]
}

type binaryClassresultEndCPUProfile struct{}

func (*resultEndCPUProfile) Class() binary.Class {
	return (*binaryClassresultEndCPUProfile)(nil)
}
func doEncoderesultEndCPUProfile(e binary.Writer, o *resultEndCPUProfile) {
	e.Uint32(uint32(len(o.value)))
	e.Data(o.value)
}
func doDecoderesultEndCPUProfile(d binary.Reader, o *resultEndCPUProfile) {
	if count := d.Count(); count > 0 {
		o.value = make([]byte, count)
		d.Data(o.value)
	}
}
func doDecodeRawresultEndCPUProfile(d binary.Reader, o *resultEndCPUProfile) {
	if count := d.Count(); count > 0 {
		o.value = make([]byte, count)
		d.Data(o.value)
	}
}
func (*binaryClassresultEndCPUProfile) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultEndCPUProfile(e, obj.(*resultEndCPUProfile))
}
func (*binaryClassresultEndCPUProfile) New() binary.Object {
	return &resultEndCPUProfile{}
}
func (*binaryClassresultEndCPUProfile) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultEndCPUProfile(d, obj.(*resultEndCPUProfile))
}
func (o *resultEndCPUProfile) WriteSimple(w binary.Writer) {
	doEncoderesultEndCPUProfile(w, o)
}
func (o *resultEndCPUProfile) ReadSimple(r binary.Reader) {
	doDecoderesultEndCPUProfile(r, o)
}
func (c *binaryClassresultEndCPUProfile) Schema() *binary.Entity {
	return &entities[ixǁresultEndCPUProfile]
}

type binaryClassresultFollow struct{}

func (*resultFollow) Class() binary.Class {
	return (*binaryClassresultFollow)(nil)
}
func doEncoderesultFollow(e binary.Encoder, o *resultFollow) {
	e.Object(o.value)
}
func doDecoderesultFollow(d binary.Decoder, o *resultFollow) {
	o.value = path.PathCast(d.Object())
}
func doDecodeRawresultFollow(d binary.Decoder, o *resultFollow) {
	o.value = path.PathCast(d.Object())
}
func (*binaryClassresultFollow) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultFollow(e, obj.(*resultFollow))
}
func (*binaryClassresultFollow) New() binary.Object {
	return &resultFollow{}
}
func (*binaryClassresultFollow) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultFollow(d, obj.(*resultFollow))
}
func (c *binaryClassresultFollow) Schema() *binary.Entity {
	return &entities[ixǁresultFollow]
}

type binaryClassresultGet struct{}

func (*resultGet) Class() binary.Class {
	return (*binaryClassresultGet)(nil)
}
func doEncoderesultGet(e binary.Encoder, o *resultGet) {
	schema.Any{}.EncodeValue(e, o.value)
}
func doDecoderesultGet(d binary.Decoder, o *resultGet) {
	o.value = schema.Any{}.DecodeValue(d)
}
func doDecodeRawresultGet(d binary.Decoder, o *resultGet) {
	o.value = schema.Any{}.DecodeValue(d)
}
func (*binaryClassresultGet) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultGet(e, obj.(*resultGet))
}
func (*binaryClassresultGet) New() binary.Object {
	return &resultGet{}
}
func (*binaryClassresultGet) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultGet(d, obj.(*resultGet))
}
func (c *binaryClassresultGet) Schema() *binary.Entity {
	return &entities[ixǁresultGet]
}

type binaryClassresultGetAvailableStringTables struct{}

func (*resultGetAvailableStringTables) Class() binary.Class {
	return (*binaryClassresultGetAvailableStringTables)(nil)
}
func doEncoderesultGetAvailableStringTables(e binary.Writer, o *resultGetAvailableStringTables) {
	e.Uint32(uint32(len(o.value)))
	for i := range o.value {
		curr := &o.value[i]
		e.Simple(&(*curr))
	}
}
func doDecoderesultGetAvailableStringTables(d binary.Reader, o *resultGetAvailableStringTables) {
	if count := d.Count(); count > 0 {
		o.value = make([]stringtable.Info, count)
		for i := range o.value {
			curr := &o.value[i]
			d.Simple(&(*curr))
		}
	}
}
func doDecodeRawresultGetAvailableStringTables(d binary.Reader, o *resultGetAvailableStringTables) {
	if count := d.Count(); count > 0 {
		o.value = make([]stringtable.Info, count)
		for i := range o.value {
			curr := &o.value[i]
			d.Simple(&(*curr))
		}
	}
}
func (*binaryClassresultGetAvailableStringTables) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultGetAvailableStringTables(e, obj.(*resultGetAvailableStringTables))
}
func (*binaryClassresultGetAvailableStringTables) New() binary.Object {
	return &resultGetAvailableStringTables{}
}
func (*binaryClassresultGetAvailableStringTables) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultGetAvailableStringTables(d, obj.(*resultGetAvailableStringTables))
}
func (o *resultGetAvailableStringTables) WriteSimple(w binary.Writer) {
	doEncoderesultGetAvailableStringTables(w, o)
}
func (o *resultGetAvailableStringTables) ReadSimple(r binary.Reader) {
	doDecoderesultGetAvailableStringTables(r, o)
}
func (c *binaryClassresultGetAvailableStringTables) Schema() *binary.Entity {
	return &entities[ixǁresultGetAvailableStringTables]
}

type binaryClassresultGetCaptures struct{}

func (*resultGetCaptures) Class() binary.Class {
	return (*binaryClassresultGetCaptures)(nil)
}
func doEncoderesultGetCaptures(e binary.Encoder, o *resultGetCaptures) {
	e.Uint32(uint32(len(o.value)))
	for i := range o.value {
		curr := &o.value[i]
		if *curr != nil {
			e.Object(*curr)
		} else {
			e.Object(nil)
		}
	}
}
func doDecoderesultGetCaptures(d binary.Decoder, o *resultGetCaptures) {
	if count := d.Count(); count > 0 {
		o.value = make([]*path.Capture, count)
		for i := range o.value {
			curr := &o.value[i]
			if obj := d.Object(); obj != nil {
				*curr = obj.(*path.Capture)
			} else {
				*curr = nil
			}
		}
	}
}
func doDecodeRawresultGetCaptures(d binary.Decoder, o *resultGetCaptures) {
	if count := d.Count(); count > 0 {
		o.value = make([]*path.Capture, count)
		for i := range o.value {
			curr := &o.value[i]
			if obj := d.Object(); obj != nil {
				*curr = obj.(*path.Capture)
			} else {
				*curr = nil
			}
		}
	}
}
func (*binaryClassresultGetCaptures) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultGetCaptures(e, obj.(*resultGetCaptures))
}
func (*binaryClassresultGetCaptures) New() binary.Object {
	return &resultGetCaptures{}
}
func (*binaryClassresultGetCaptures) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultGetCaptures(d, obj.(*resultGetCaptures))
}
func (c *binaryClassresultGetCaptures) Schema() *binary.Entity {
	return &entities[ixǁresultGetCaptures]
}

type binaryClassresultGetDevices struct{}

func (*resultGetDevices) Class() binary.Class {
	return (*binaryClassresultGetDevices)(nil)
}
func doEncoderesultGetDevices(e binary.Encoder, o *resultGetDevices) {
	e.Uint32(uint32(len(o.value)))
	for i := range o.value {
		curr := &o.value[i]
		if *curr != nil {
			e.Object(*curr)
		} else {
			e.Object(nil)
		}
	}
}
func doDecoderesultGetDevices(d binary.Decoder, o *resultGetDevices) {
	if count := d.Count(); count > 0 {
		o.value = make([]*path.Device, count)
		for i := range o.value {
			curr := &o.value[i]
			if obj := d.Object(); obj != nil {
				*curr = obj.(*path.Device)
			} else {
				*curr = nil
			}
		}
	}
}
func doDecodeRawresultGetDevices(d binary.Decoder, o *resultGetDevices) {
	if count := d.Count(); count > 0 {
		o.value = make([]*path.Device, count)
		for i := range o.value {
			curr := &o.value[i]
			if obj := d.Object(); obj != nil {
				*curr = obj.(*path.Device)
			} else {
				*curr = nil
			}
		}
	}
}
func (*binaryClassresultGetDevices) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultGetDevices(e, obj.(*resultGetDevices))
}
func (*binaryClassresultGetDevices) New() binary.Object {
	return &resultGetDevices{}
}
func (*binaryClassresultGetDevices) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultGetDevices(d, obj.(*resultGetDevices))
}
func (c *binaryClassresultGetDevices) Schema() *binary.Entity {
	return &entities[ixǁresultGetDevices]
}

type binaryClassresultGetFeatures struct{}

func (*resultGetFeatures) Class() binary.Class {
	return (*binaryClassresultGetFeatures)(nil)
}
func doEncoderesultGetFeatures(e binary.Writer, o *resultGetFeatures) {
	e.Uint32(uint32(len(o.value)))
	for i := range o.value {
		curr := &o.value[i]
		e.String(*curr)
	}
}
func doDecoderesultGetFeatures(d binary.Reader, o *resultGetFeatures) {
	if count := d.Count(); count > 0 {
		o.value = make([]string, count)
		for i := range o.value {
			curr := &o.value[i]
			*curr = string(d.String())
		}
	}
}
func doDecodeRawresultGetFeatures(d binary.Reader, o *resultGetFeatures) {
	if count := d.Count(); count > 0 {
		o.value = make([]string, count)
		for i := range o.value {
			curr := &o.value[i]
			*curr = string(d.String())
		}
	}
}
func (*binaryClassresultGetFeatures) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultGetFeatures(e, obj.(*resultGetFeatures))
}
func (*binaryClassresultGetFeatures) New() binary.Object {
	return &resultGetFeatures{}
}
func (*binaryClassresultGetFeatures) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultGetFeatures(d, obj.(*resultGetFeatures))
}
func (o *resultGetFeatures) WriteSimple(w binary.Writer) {
	doEncoderesultGetFeatures(w, o)
}
func (o *resultGetFeatures) ReadSimple(r binary.Reader) {
	doDecoderesultGetFeatures(r, o)
}
func (c *binaryClassresultGetFeatures) Schema() *binary.Entity {
	return &entities[ixǁresultGetFeatures]
}

type binaryClassresultGetFramebufferAttachment struct{}

func (*resultGetFramebufferAttachment) Class() binary.Class {
	return (*binaryClassresultGetFramebufferAttachment)(nil)
}
func doEncoderesultGetFramebufferAttachment(e binary.Encoder, o *resultGetFramebufferAttachment) {
	if o.value != nil {
		e.Object(o.value)
	} else {
		e.Object(nil)
	}
}
func doDecoderesultGetFramebufferAttachment(d binary.Decoder, o *resultGetFramebufferAttachment) {
	if obj := d.Object(); obj != nil {
		o.value = obj.(*path.ImageInfo)
	} else {
		o.value = nil
	}
}
func doDecodeRawresultGetFramebufferAttachment(d binary.Decoder, o *resultGetFramebufferAttachment) {
	if obj := d.Object(); obj != nil {
		o.value = obj.(*path.ImageInfo)
	} else {
		o.value = nil
	}
}
func (*binaryClassresultGetFramebufferAttachment) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultGetFramebufferAttachment(e, obj.(*resultGetFramebufferAttachment))
}
func (*binaryClassresultGetFramebufferAttachment) New() binary.Object {
	return &resultGetFramebufferAttachment{}
}
func (*binaryClassresultGetFramebufferAttachment) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultGetFramebufferAttachment(d, obj.(*resultGetFramebufferAttachment))
}
func (c *binaryClassresultGetFramebufferAttachment) Schema() *binary.Entity {
	return &entities[ixǁresultGetFramebufferAttachment]
}

type binaryClassresultGetFramebufferColor struct{}

func (*resultGetFramebufferColor) Class() binary.Class {
	return (*binaryClassresultGetFramebufferColor)(nil)
}
func doEncoderesultGetFramebufferColor(e binary.Encoder, o *resultGetFramebufferColor) {
	if o.value != nil {
		e.Object(o.value)
	} else {
		e.Object(nil)
	}
}
func doDecoderesultGetFramebufferColor(d binary.Decoder, o *resultGetFramebufferColor) {
	if obj := d.Object(); obj != nil {
		o.value = obj.(*path.ImageInfo)
	} else {
		o.value = nil
	}
}
func doDecodeRawresultGetFramebufferColor(d binary.Decoder, o *resultGetFramebufferColor) {
	if obj := d.Object(); obj != nil {
		o.value = obj.(*path.ImageInfo)
	} else {
		o.value = nil
	}
}
func (*binaryClassresultGetFramebufferColor) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultGetFramebufferColor(e, obj.(*resultGetFramebufferColor))
}
func (*binaryClassresultGetFramebufferColor) New() binary.Object {
	return &resultGetFramebufferColor{}
}
func (*binaryClassresultGetFramebufferColor) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultGetFramebufferColor(d, obj.(*resultGetFramebufferColor))
}
func (c *binaryClassresultGetFramebufferColor) Schema() *binary.Entity {
	return &entities[ixǁresultGetFramebufferColor]
}

type binaryClassresultGetFramebufferDepth struct{}

func (*resultGetFramebufferDepth) Class() binary.Class {
	return (*binaryClassresultGetFramebufferDepth)(nil)
}
func doEncoderesultGetFramebufferDepth(e binary.Encoder, o *resultGetFramebufferDepth) {
	if o.value != nil {
		e.Object(o.value)
	} else {
		e.Object(nil)
	}
}
func doDecoderesultGetFramebufferDepth(d binary.Decoder, o *resultGetFramebufferDepth) {
	if obj := d.Object(); obj != nil {
		o.value = obj.(*path.ImageInfo)
	} else {
		o.value = nil
	}
}
func doDecodeRawresultGetFramebufferDepth(d binary.Decoder, o *resultGetFramebufferDepth) {
	if obj := d.Object(); obj != nil {
		o.value = obj.(*path.ImageInfo)
	} else {
		o.value = nil
	}
}
func (*binaryClassresultGetFramebufferDepth) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultGetFramebufferDepth(e, obj.(*resultGetFramebufferDepth))
}
func (*binaryClassresultGetFramebufferDepth) New() binary.Object {
	return &resultGetFramebufferDepth{}
}
func (*binaryClassresultGetFramebufferDepth) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultGetFramebufferDepth(d, obj.(*resultGetFramebufferDepth))
}
func (c *binaryClassresultGetFramebufferDepth) Schema() *binary.Entity {
	return &entities[ixǁresultGetFramebufferDepth]
}

type binaryClassresultGetMemProfileRate struct{}

func (*resultGetMemProfileRate) Class() binary.Class {
	return (*binaryClassresultGetMemProfileRate)(nil)
}
func doEncoderesultGetMemProfileRate(e binary.Writer, o *resultGetMemProfileRate) {
	e.Int32(int32(o.value))
}
func doDecoderesultGetMemProfileRate(d binary.Reader, o *resultGetMemProfileRate) {
	o.value = int(d.Int32())
}
func doDecodeRawresultGetMemProfileRate(d binary.Reader, o *resultGetMemProfileRate) {
	o.value = int(d.Int32())
}
func (*binaryClassresultGetMemProfileRate) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultGetMemProfileRate(e, obj.(*resultGetMemProfileRate))
}
func (*binaryClassresultGetMemProfileRate) New() binary.Object {
	return &resultGetMemProfileRate{}
}
func (*binaryClassresultGetMemProfileRate) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultGetMemProfileRate(d, obj.(*resultGetMemProfileRate))
}
func (o *resultGetMemProfileRate) WriteSimple(w binary.Writer) {
	doEncoderesultGetMemProfileRate(w, o)
}
func (o *resultGetMemProfileRate) ReadSimple(r binary.Reader) {
	doDecoderesultGetMemProfileRate(r, o)
}
func (c *binaryClassresultGetMemProfileRate) Schema() *binary.Entity {
	return &entities[ixǁresultGetMemProfileRate]
}

type binaryClassresultGetPerformanceCounters struct{}

func (*resultGetPerformanceCounters) Class() binary.Class {
	return (*binaryClassresultGetPerformanceCounters)(nil)
}
func doEncoderesultGetPerformanceCounters(e binary.Writer, o *resultGetPerformanceCounters) {
	e.Uint32(uint32(len(o.value)))
	e.Data(o.value)
}
func doDecoderesultGetPerformanceCounters(d binary.Reader, o *resultGetPerformanceCounters) {
	if count := d.Count(); count > 0 {
		o.value = make([]byte, count)
		d.Data(o.value)
	}
}
func doDecodeRawresultGetPerformanceCounters(d binary.Reader, o *resultGetPerformanceCounters) {
	if count := d.Count(); count > 0 {
		o.value = make([]byte, count)
		d.Data(o.value)
	}
}
func (*binaryClassresultGetPerformanceCounters) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultGetPerformanceCounters(e, obj.(*resultGetPerformanceCounters))
}
func (*binaryClassresultGetPerformanceCounters) New() binary.Object {
	return &resultGetPerformanceCounters{}
}
func (*binaryClassresultGetPerformanceCounters) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultGetPerformanceCounters(d, obj.(*resultGetPerformanceCounters))
}
func (o *resultGetPerformanceCounters) WriteSimple(w binary.Writer) {
	doEncoderesultGetPerformanceCounters(w, o)
}
func (o *resultGetPerformanceCounters) ReadSimple(r binary.Reader) {
	doDecoderesultGetPerformanceCounters(r, o)
}
func (c *binaryClassresultGetPerformanceCounters) Schema() *binary.Entity {
	return &entities[ixǁresultGetPerformanceCounters]
}

type binaryClassresultGetProfile struct{}

func (*resultGetProfile) Class() binary.Class {
	return (*binaryClassresultGetProfile)(nil)
}
func doEncoderesultGetProfile(e binary.Writer, o *resultGetProfile) {
	e.Uint32(uint32(len(o.value)))
	e.Data(o.value)
}
func doDecoderesultGetProfile(d binary.Reader, o *resultGetProfile) {
	if count := d.Count(); count > 0 {
		o.value = make([]byte, count)
		d.Data(o.value)
	}
}
func doDecodeRawresultGetProfile(d binary.Reader, o *resultGetProfile) {
	if count := d.Count(); count > 0 {
		o.value = make([]byte, count)
		d.Data(o.value)
	}
}
func (*binaryClassresultGetProfile) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultGetProfile(e, obj.(*resultGetProfile))
}
func (*binaryClassresultGetProfile) New() binary.Object {
	return &resultGetProfile{}
}
func (*binaryClassresultGetProfile) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultGetProfile(d, obj.(*resultGetProfile))
}
func (o *resultGetProfile) WriteSimple(w binary.Writer) {
	doEncoderesultGetProfile(w, o)
}
func (o *resultGetProfile) ReadSimple(r binary.Reader) {
	doDecoderesultGetProfile(r, o)
}
func (c *binaryClassresultGetProfile) Schema() *binary.Entity {
	return &entities[ixǁresultGetProfile]
}

type binaryClassresultGetSchema struct{}

func (*resultGetSchema) Class() binary.Class {
	return (*binaryClassresultGetSchema)(nil)
}
func doEncoderesultGetSchema(e binary.Encoder, o *resultGetSchema) {
	e.Struct(&o.value)
}
func doDecoderesultGetSchema(d binary.Decoder, o *resultGetSchema) {
	d.Struct(&o.value)
}
func doDecodeRawresultGetSchema(d binary.Decoder, o *resultGetSchema) {
	d.Struct(&o.value)
}
func (*binaryClassresultGetSchema) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultGetSchema(e, obj.(*resultGetSchema))
}
func (*binaryClassresultGetSchema) New() binary.Object {
	return &resultGetSchema{}
}
func (*binaryClassresultGetSchema) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultGetSchema(d, obj.(*resultGetSchema))
}
func (c *binaryClassresultGetSchema) Schema() *binary.Entity {
	return &entities[ixǁresultGetSchema]
}

type binaryClassresultGetStringTable struct{}

func (*resultGetStringTable) Class() binary.Class {
	return (*binaryClassresultGetStringTable)(nil)
}
func doEncoderesultGetStringTable(e binary.Encoder, o *resultGetStringTable) {
	if o.value != nil {
		e.Object(o.value)
	} else {
		e.Object(nil)
	}
}
func doDecoderesultGetStringTable(d binary.Decoder, o *resultGetStringTable) {
	if obj := d.Object(); obj != nil {
		o.value = obj.(*stringtable.StringTable)
	} else {
		o.value = nil
	}
}
func doDecodeRawresultGetStringTable(d binary.Decoder, o *resultGetStringTable) {
	if obj := d.Object(); obj != nil {
		o.value = obj.(*stringtable.StringTable)
	} else {
		o.value = nil
	}
}
func (*binaryClassresultGetStringTable) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultGetStringTable(e, obj.(*resultGetStringTable))
}
func (*binaryClassresultGetStringTable) New() binary.Object {
	return &resultGetStringTable{}
}
func (*binaryClassresultGetStringTable) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultGetStringTable(d, obj.(*resultGetStringTable))
}
func (c *binaryClassresultGetStringTable) Schema() *binary.Entity {
	return &entities[ixǁresultGetStringTable]
}

type binaryClassresultGetTimingInfo struct{}

func (*resultGetTimingInfo) Class() binary.Class {
	return (*binaryClassresultGetTimingInfo)(nil)
}
func doEncoderesultGetTimingInfo(e binary.Encoder, o *resultGetTimingInfo) {
	if o.value != nil {
		e.Object(o.value)
	} else {
		e.Object(nil)
	}
}
func doDecoderesultGetTimingInfo(d binary.Decoder, o *resultGetTimingInfo) {
	if obj := d.Object(); obj != nil {
		o.value = obj.(*path.TimingInfo)
	} else {
		o.value = nil
	}
}
func doDecodeRawresultGetTimingInfo(d binary.Decoder, o *resultGetTimingInfo) {
	if obj := d.Object(); obj != nil {
		o.value = obj.(*path.TimingInfo)
	} else {
		o.value = nil
	}
}
func (*binaryClassresultGetTimingInfo) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultGetTimingInfo(e, obj.(*resultGetTimingInfo))
}
func (*binaryClassresultGetTimingInfo) New() binary.Object {
	return &resultGetTimingInfo{}
}
func (*binaryClassresultGetTimingInfo) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultGetTimingInfo(d, obj.(*resultGetTimingInfo))
}
func (c *binaryClassresultGetTimingInfo) Schema() *binary.Entity {
	return &entities[ixǁresultGetTimingInfo]
}

type binaryClassresultImportCapture struct{}

func (*resultImportCapture) Class() binary.Class {
	return (*binaryClassresultImportCapture)(nil)
}
func doEncoderesultImportCapture(e binary.Encoder, o *resultImportCapture) {
	if o.value != nil {
		e.Object(o.value)
	} else {
		e.Object(nil)
	}
}
func doDecoderesultImportCapture(d binary.Decoder, o *resultImportCapture) {
	if obj := d.Object(); obj != nil {
		o.value = obj.(*path.Capture)
	} else {
		o.value = nil
	}
}
func doDecodeRawresultImportCapture(d binary.Decoder, o *resultImportCapture) {
	if obj := d.Object(); obj != nil {
		o.value = obj.(*path.Capture)
	} else {
		o.value = nil
	}
}
func (*binaryClassresultImportCapture) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultImportCapture(e, obj.(*resultImportCapture))
}
func (*binaryClassresultImportCapture) New() binary.Object {
	return &resultImportCapture{}
}
func (*binaryClassresultImportCapture) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultImportCapture(d, obj.(*resultImportCapture))
}
func (c *binaryClassresultImportCapture) Schema() *binary.Entity {
	return &entities[ixǁresultImportCapture]
}

type binaryClassresultLoadCapture struct{}

func (*resultLoadCapture) Class() binary.Class {
	return (*binaryClassresultLoadCapture)(nil)
}
func doEncoderesultLoadCapture(e binary.Encoder, o *resultLoadCapture) {
	if o.value != nil {
		e.Object(o.value)
	} else {
		e.Object(nil)
	}
}
func doDecoderesultLoadCapture(d binary.Decoder, o *resultLoadCapture) {
	if obj := d.Object(); obj != nil {
		o.value = obj.(*path.Capture)
	} else {
		o.value = nil
	}
}
func doDecodeRawresultLoadCapture(d binary.Decoder, o *resultLoadCapture) {
	if obj := d.Object(); obj != nil {
		o.value = obj.(*path.Capture)
	} else {
		o.value = nil
	}
}
func (*binaryClassresultLoadCapture) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultLoadCapture(e, obj.(*resultLoadCapture))
}
func (*binaryClassresultLoadCapture) New() binary.Object {
	return &resultLoadCapture{}
}
func (*binaryClassresultLoadCapture) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultLoadCapture(d, obj.(*resultLoadCapture))
}
func (c *binaryClassresultLoadCapture) Schema() *binary.Entity {
	return &entities[ixǁresultLoadCapture]
}

type binaryClassresultRegisterAndroidDevice struct{}

func (*resultRegisterAndroidDevice) Class() binary.Class {
	return (*binaryClassresultRegisterAndroidDevice)(nil)
}
func doEncoderesultRegisterAndroidDevice(e binary.Encoder, o *resultRegisterAndroidDevice) {
	if o.value != nil {
		e.Object(o.value)
	} else {
		e.Object(nil)
	}
}
func doDecoderesultRegisterAndroidDevice(d binary.Decoder, o *resultRegisterAndroidDevice) {
	if obj := d.Object(); obj != nil {
		o.value = obj.(*path.Device)
	} else {
		o.value = nil
	}
}
func doDecodeRawresultRegisterAndroidDevice(d binary.Decoder, o *resultRegisterAndroidDevice) {
	if obj := d.Object(); obj != nil {
		o.value = obj.(*path.Device)
	} else {
		o.value = nil
	}
}
func (*binaryClassresultRegisterAndroidDevice) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultRegisterAndroidDevice(e, obj.(*resultRegisterAndroidDevice))
}
func (*binaryClassresultRegisterAndroidDevice) New() binary.Object {
	return &resultRegisterAndroidDevice{}
}
func (*binaryClassresultRegisterAndroidDevice) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultRegisterAndroidDevice(d, obj.(*resultRegisterAndroidDevice))
}
func (c *binaryClassresultRegisterAndroidDevice) Schema() *binary.Entity {
	return &entities[ixǁresultRegisterAndroidDevice]
}

type binaryClassresultSet struct{}

func (*resultSet) Class() binary.Class {
	return (*binaryClassresultSet)(nil)
}
func doEncoderesultSet(e binary.Encoder, o *resultSet) {
	e.Object(o.value)
}
func doDecoderesultSet(d binary.Decoder, o *resultSet) {
	o.value = path.PathCast(d.Object())
}
func doDecodeRawresultSet(d binary.Decoder, o *resultSet) {
	o.value = path.PathCast(d.Object())
}
func (*binaryClassresultSet) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultSet(e, obj.(*resultSet))
}
func (*binaryClassresultSet) New() binary.Object {
	return &resultSet{}
}
func (*binaryClassresultSet) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultSet(d, obj.(*resultSet))
}
func (c *binaryClassresultSet) Schema() *binary.Entity {
	return &entities[ixǁresultSet]
}

type binaryClassresultSetMemProfileRate struct{}

func (*resultSetMemProfileRate) Class() binary.Class {
	return (*binaryClassresultSetMemProfileRate)(nil)
}
func doEncoderesultSetMemProfileRate(e binary.Writer, o *resultSetMemProfileRate) {
}
func doDecoderesultSetMemProfileRate(d binary.Reader, o *resultSetMemProfileRate) {
}
func doDecodeRawresultSetMemProfileRate(d binary.Reader, o *resultSetMemProfileRate) {
}
func (*binaryClassresultSetMemProfileRate) Encode(e binary.Encoder, obj binary.Object) {
	doEncoderesultSetMemProfileRate(e, obj.(*resultSetMemProfileRate))
}
func (*binaryClassresultSetMemProfileRate) New() binary.Object {
	return &resultSetMemProfileRate{}
}
func (*binaryClassresultSetMemProfileRate) DecodeTo(d binary.Decoder, obj binary.Object) {
	doDecoderesultSetMemProfileRate(d, obj.(*resultSetMemProfileRate))
}
func (o *resultSetMemProfileRate) WriteSimple(w binary.Writer) {
	doEncoderesultSetMemProfileRate(w, o)
}
func (o *resultSetMemProfileRate) ReadSimple(r binary.Reader) {
	doDecoderesultSetMemProfileRate(r, o)
}
func (c *binaryClassresultSetMemProfileRate) Schema() *binary.Entity {
	return &entities[ixǁresultSetMemProfileRate]
}