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

package service

import (
	"fmt"

	"android.googlesource.com/platform/tools/gpu/binary"
	"android.googlesource.com/platform/tools/gpu/binary/registry"
	"android.googlesource.com/platform/tools/gpu/binary/schema"
)

func init() {
	registry.Add((*ApiId)(nil).Class())
	registry.Add((*FieldInfo)(nil).Class())
	registry.Add((*StructInfo)(nil).Class())
	registry.Add((*ApiSchema)(nil).Class())
	registry.Add((*ArrayInfo)(nil).Class())
	registry.Add((*AtomRange)(nil).Class())
	registry.Add((*AtomGroup)(nil).Class())
	registry.Add((*ParameterInfo)(nil).Class())
	registry.Add((*AtomInfo)(nil).Class())
	registry.Add((*AtomRangeTimer)(nil).Class())
	registry.Add((*AtomStream)(nil).Class())
	registry.Add((*AtomStreamId)(nil).Class())
	registry.Add((*AtomTimer)(nil).Class())
	registry.Add((*Binary)(nil).Class())
	registry.Add((*BinaryId)(nil).Class())
	registry.Add((*SchemaId)(nil).Class())
	registry.Add((*Capture)(nil).Class())
	registry.Add((*CaptureId)(nil).Class())
	registry.Add((*ClassInfo)(nil).Class())
	registry.Add((*Device)(nil).Class())
	registry.Add((*DeviceId)(nil).Class())
	registry.Add((*EnumEntry)(nil).Class())
	registry.Add((*EnumInfo)(nil).Class())
	registry.Add((*Hierarchy)(nil).Class())
	registry.Add((*HierarchyId)(nil).Class())
	registry.Add((*ImageInfo)(nil).Class())
	registry.Add((*ImageInfoId)(nil).Class())
	registry.Add((*MapInfo)(nil).Class())
	registry.Add((*MemoryRange)(nil).Class())
	registry.Add((*MemoryInfo)(nil).Class())
	registry.Add((*MemoryInfoId)(nil).Class())
	registry.Add((*RenderSettings)(nil).Class())
	registry.Add((*Schema)(nil).Class())
	registry.Add((*SimpleInfo)(nil).Class())
	registry.Add((*StaticArrayInfo)(nil).Class())
	registry.Add((*TimingInfo)(nil).Class())
	registry.Add((*TimingInfoId)(nil).Class())
	registry.Add((*callGetCaptures)(nil).Class())
	registry.Add((*callGetDevices)(nil).Class())
	registry.Add((*callGetFramebufferColor)(nil).Class())
	registry.Add((*callGetFramebufferDepth)(nil).Class())
	registry.Add((*callGetHierarchy)(nil).Class())
	registry.Add((*callGetMemoryInfo)(nil).Class())
	registry.Add((*callGetState)(nil).Class())
	registry.Add((*callGetTimingInfo)(nil).Class())
	registry.Add((*callImport)(nil).Class())
	registry.Add((*callPrerenderFramebuffers)(nil).Class())
	registry.Add((*callReplaceAtom)(nil).Class())
	registry.Add((*callResolveAtomStream)(nil).Class())
	registry.Add((*callResolveBinary)(nil).Class())
	registry.Add((*callResolveCapture)(nil).Class())
	registry.Add((*callResolveDevice)(nil).Class())
	registry.Add((*callResolveHierarchy)(nil).Class())
	registry.Add((*callResolveImageInfo)(nil).Class())
	registry.Add((*callResolveMemoryInfo)(nil).Class())
	registry.Add((*callResolveSchema)(nil).Class())
	registry.Add((*callResolveTimingInfo)(nil).Class())
	registry.Add((*resultGetCaptures)(nil).Class())
	registry.Add((*resultGetDevices)(nil).Class())
	registry.Add((*resultGetFramebufferColor)(nil).Class())
	registry.Add((*resultGetFramebufferDepth)(nil).Class())
	registry.Add((*resultGetHierarchy)(nil).Class())
	registry.Add((*resultGetMemoryInfo)(nil).Class())
	registry.Add((*resultGetState)(nil).Class())
	registry.Add((*resultGetTimingInfo)(nil).Class())
	registry.Add((*resultImport)(nil).Class())
	registry.Add((*resultPrerenderFramebuffers)(nil).Class())
	registry.Add((*resultReplaceAtom)(nil).Class())
	registry.Add((*resultResolveAtomStream)(nil).Class())
	registry.Add((*resultResolveBinary)(nil).Class())
	registry.Add((*resultResolveCapture)(nil).Class())
	registry.Add((*resultResolveDevice)(nil).Class())
	registry.Add((*resultResolveHierarchy)(nil).Class())
	registry.Add((*resultResolveImageInfo)(nil).Class())
	registry.Add((*resultResolveMemoryInfo)(nil).Class())
	registry.Add((*resultResolveSchema)(nil).Class())
	registry.Add((*resultResolveTimingInfo)(nil).Class())
}

var (
	binaryIDApiId                       = binary.ID{0x20, 0x75, 0x65, 0xf1, 0x82, 0xb1, 0xe1, 0x6a, 0xcd, 0x10, 0x7f, 0x7f, 0x04, 0xee, 0x90, 0x07, 0xa3, 0x62, 0xd1, 0x41}
	binaryIDFieldInfo                   = binary.ID{0x16, 0xdb, 0x4c, 0x57, 0x0a, 0x1f, 0xf9, 0x33, 0x7c, 0x1f, 0x03, 0x0d, 0x2a, 0xce, 0x96, 0x7e, 0xba, 0xa8, 0x22, 0xa5}
	binaryIDStructInfo                  = binary.ID{0xb1, 0x61, 0x0f, 0x73, 0xad, 0x9a, 0xc4, 0xa8, 0x4f, 0xc9, 0x6c, 0x5c, 0x94, 0x26, 0x12, 0xfc, 0x5a, 0x42, 0x75, 0x2d}
	binaryIDApiSchema                   = binary.ID{0x81, 0xc2, 0x28, 0xff, 0x7b, 0xad, 0x6f, 0x74, 0x5e, 0x6c, 0xf7, 0xa3, 0x21, 0xb3, 0x12, 0x26, 0x5f, 0xa7, 0x75, 0x24}
	binaryIDArrayInfo                   = binary.ID{0xf1, 0x0b, 0xb1, 0xbf, 0x10, 0xf9, 0x53, 0x4a, 0xf6, 0x5a, 0x6f, 0xc7, 0xcb, 0xa9, 0x47, 0xfd, 0xb1, 0x23, 0x5b, 0x1d}
	binaryIDAtomRange                   = binary.ID{0xfa, 0xb9, 0x1d, 0x40, 0x16, 0xc4, 0x26, 0x4d, 0x40, 0x03, 0xb1, 0x72, 0xc9, 0x2f, 0x2f, 0x77, 0xde, 0xa7, 0x96, 0x4a}
	binaryIDAtomGroup                   = binary.ID{0x31, 0x4b, 0xc3, 0x9a, 0x0e, 0xb2, 0x00, 0x94, 0x68, 0xc7, 0xcd, 0xbe, 0x0b, 0x1a, 0x23, 0xf0, 0xf3, 0x75, 0x56, 0x1c}
	binaryIDParameterInfo               = binary.ID{0x46, 0x0a, 0xd9, 0x73, 0x17, 0xbd, 0x7d, 0x02, 0x14, 0xed, 0x06, 0xa8, 0x09, 0x15, 0xa4, 0xc3, 0xd0, 0xc3, 0xe0, 0xff}
	binaryIDAtomInfo                    = binary.ID{0xed, 0x4f, 0x94, 0x77, 0x10, 0x68, 0x9a, 0xea, 0x51, 0xb3, 0x0f, 0x2b, 0x68, 0x1d, 0x78, 0x5c, 0xa3, 0x23, 0x42, 0xd5}
	binaryIDAtomRangeTimer              = binary.ID{0xe5, 0xdd, 0xf5, 0x99, 0xf2, 0x23, 0xeb, 0x48, 0x06, 0x26, 0xe1, 0x03, 0x9f, 0x5a, 0x6e, 0x2d, 0xaf, 0x76, 0x8a, 0xf2}
	binaryIDAtomStream                  = binary.ID{0xda, 0x04, 0xb7, 0x57, 0x79, 0xd1, 0x38, 0xd4, 0xa3, 0x75, 0x8f, 0x31, 0x43, 0x7b, 0xaf, 0x08, 0x0a, 0x6d, 0x57, 0x2c}
	binaryIDAtomStreamId                = binary.ID{0xbe, 0x90, 0x3c, 0x40, 0x28, 0xee, 0x58, 0x7e, 0xab, 0x8c, 0xde, 0x44, 0x43, 0xb3, 0x94, 0x88, 0xff, 0x6b, 0xa0, 0x12}
	binaryIDAtomTimer                   = binary.ID{0x7b, 0x64, 0x0c, 0x00, 0x25, 0xee, 0x98, 0xa3, 0x51, 0x7b, 0x1b, 0x0d, 0x98, 0x73, 0x20, 0x93, 0x12, 0x9a, 0x7d, 0xc4}
	binaryIDBinary                      = binary.ID{0x9c, 0x60, 0xfa, 0x7c, 0xe1, 0x13, 0x87, 0x3d, 0x95, 0xc1, 0x76, 0xb8, 0x60, 0x56, 0xf7, 0x35, 0x5f, 0x98, 0x27, 0x8b}
	binaryIDBinaryId                    = binary.ID{0x71, 0x35, 0xf5, 0x97, 0xf9, 0x3a, 0x8a, 0x25, 0x88, 0xf6, 0x5b, 0xe6, 0x99, 0xf5, 0x1c, 0x9c, 0x97, 0xf5, 0x68, 0x3b}
	binaryIDSchemaId                    = binary.ID{0x5c, 0x52, 0xa3, 0xb3, 0xf2, 0xe7, 0x35, 0x90, 0xb6, 0xb2, 0x2e, 0x5e, 0xa7, 0xc5, 0xbf, 0x3a, 0xa6, 0xe7, 0x18, 0x4c}
	binaryIDCapture                     = binary.ID{0xe3, 0xb4, 0x59, 0x42, 0xf5, 0xfc, 0xe5, 0x09, 0x29, 0x27, 0x0b, 0xb9, 0x4f, 0x22, 0x3b, 0x4d, 0x13, 0xb5, 0x68, 0xb0}
	binaryIDCaptureId                   = binary.ID{0x71, 0x8d, 0x28, 0x9b, 0x6c, 0xa4, 0x85, 0x73, 0xc4, 0x8a, 0x21, 0xb3, 0x9c, 0xae, 0x27, 0xa8, 0xe2, 0x57, 0x9e, 0xdd}
	binaryIDClassInfo                   = binary.ID{0x82, 0x7f, 0xfa, 0x73, 0x67, 0x83, 0x4a, 0x7b, 0x4e, 0x8b, 0x52, 0xa0, 0x48, 0xab, 0x03, 0x63, 0xeb, 0xc0, 0x90, 0x32}
	binaryIDDevice                      = binary.ID{0x7f, 0xa5, 0x70, 0xd9, 0x93, 0xfc, 0x70, 0x27, 0x32, 0xd9, 0xb8, 0x6e, 0x2a, 0x9b, 0xf3, 0x84, 0x55, 0x4f, 0x26, 0x50}
	binaryIDDeviceId                    = binary.ID{0x9e, 0x5b, 0x14, 0x1f, 0xa6, 0x65, 0x62, 0x62, 0x15, 0x6a, 0x39, 0xd2, 0xa4, 0x64, 0x2f, 0x00, 0x49, 0x13, 0x64, 0x20}
	binaryIDEnumEntry                   = binary.ID{0xea, 0x7f, 0xa3, 0xef, 0xb6, 0x4c, 0x5a, 0x85, 0xc9, 0x5f, 0xb5, 0xa1, 0x28, 0xfe, 0xb3, 0xa7, 0x53, 0xae, 0xb7, 0xd0}
	binaryIDEnumInfo                    = binary.ID{0xc8, 0xb4, 0x37, 0x51, 0xa6, 0x94, 0x50, 0xe5, 0x0e, 0xc7, 0xe1, 0x2f, 0xd6, 0xf2, 0xad, 0x68, 0xf5, 0x31, 0x06, 0xe3}
	binaryIDHierarchy                   = binary.ID{0x4a, 0x29, 0x6b, 0x6f, 0x37, 0xca, 0x76, 0x25, 0xbc, 0x89, 0x1a, 0xea, 0x80, 0x56, 0xa9, 0x66, 0x0e, 0x1a, 0x1a, 0x97}
	binaryIDHierarchyId                 = binary.ID{0xfd, 0x20, 0x19, 0xa0, 0xb5, 0xac, 0x49, 0xc7, 0x7d, 0x6e, 0xf8, 0x32, 0x6b, 0x78, 0x9f, 0xd7, 0x6d, 0xf0, 0x2c, 0xaf}
	binaryIDImageInfo                   = binary.ID{0x83, 0x55, 0x77, 0x9d, 0xe7, 0x6b, 0xed, 0xd5, 0xc5, 0x3c, 0x86, 0x42, 0xfe, 0xd6, 0x1a, 0x6d, 0x2b, 0xd0, 0xfb, 0x88}
	binaryIDImageInfoId                 = binary.ID{0xb1, 0x03, 0x2c, 0x17, 0x12, 0xab, 0x40, 0x23, 0x1d, 0x01, 0xb9, 0x4b, 0x9b, 0x8c, 0x9d, 0x5a, 0x19, 0x45, 0xaf, 0x70}
	binaryIDMapInfo                     = binary.ID{0xf3, 0x40, 0x60, 0x02, 0x47, 0x89, 0x04, 0x5e, 0x0c, 0x8f, 0xd3, 0x9d, 0xa9, 0xd7, 0x19, 0x8b, 0xd0, 0x88, 0xd8, 0xdf}
	binaryIDMemoryRange                 = binary.ID{0xfa, 0xc5, 0x84, 0x24, 0x6c, 0x1b, 0x47, 0x0e, 0xe5, 0xdb, 0x67, 0x29, 0xd8, 0xb1, 0x81, 0x3b, 0xfe, 0x53, 0x3a, 0x9d}
	binaryIDMemoryInfo                  = binary.ID{0xfa, 0x6e, 0x9e, 0xc9, 0xe4, 0x44, 0x62, 0x53, 0xa0, 0x69, 0xe7, 0x64, 0x3b, 0x30, 0xc1, 0xaa, 0xfd, 0x73, 0xb1, 0x93}
	binaryIDMemoryInfoId                = binary.ID{0x84, 0x64, 0x1a, 0xae, 0xde, 0x19, 0x1a, 0xa3, 0xae, 0xc7, 0x31, 0x9f, 0x5e, 0x46, 0xa0, 0x51, 0x54, 0xc5, 0x46, 0x15}
	binaryIDRenderSettings              = binary.ID{0x18, 0x23, 0x35, 0xef, 0xd0, 0x3a, 0xe4, 0x25, 0x17, 0xc4, 0x7a, 0x2b, 0xab, 0x32, 0x10, 0x9c, 0x22, 0x86, 0x23, 0x00}
	binaryIDSchema                      = binary.ID{0x7d, 0xcb, 0xa0, 0x01, 0x4d, 0xb6, 0x8b, 0x05, 0x82, 0xe4, 0x54, 0x87, 0x36, 0xd1, 0xf9, 0x6b, 0x89, 0xeb, 0xff, 0xb2}
	binaryIDSimpleInfo                  = binary.ID{0xcd, 0x73, 0xc4, 0xe7, 0x48, 0x3f, 0x0b, 0xd8, 0x9c, 0x6d, 0xa8, 0x4e, 0x51, 0x6b, 0x4c, 0xcc, 0xa5, 0x94, 0x3a, 0x25}
	binaryIDStaticArrayInfo             = binary.ID{0x98, 0xa5, 0x0e, 0x08, 0x76, 0xa1, 0x4c, 0xe3, 0x39, 0x80, 0x9b, 0x62, 0x24, 0xaa, 0xeb, 0xe7, 0xe6, 0xfd, 0x5f, 0x03}
	binaryIDTimingInfo                  = binary.ID{0x19, 0xd8, 0xe7, 0xdb, 0xe7, 0xb2, 0xdc, 0x2e, 0x73, 0x08, 0xc2, 0x97, 0x2e, 0x68, 0xb9, 0x92, 0x52, 0x4a, 0x0a, 0xd7}
	binaryIDTimingInfoId                = binary.ID{0x71, 0x9c, 0x16, 0xeb, 0x4e, 0x5f, 0xa1, 0x6b, 0x71, 0x0c, 0xae, 0xbc, 0x5a, 0xe8, 0x6c, 0x29, 0x97, 0xaa, 0x52, 0x0f}
	binaryIDcallGetCaptures             = binary.ID{0xb0, 0x2f, 0x3d, 0xa5, 0x85, 0x95, 0xf4, 0x21, 0x20, 0x76, 0xa8, 0xa6, 0x5a, 0x53, 0x9f, 0xfc, 0xd8, 0x10, 0xdb, 0x15}
	binaryIDcallGetDevices              = binary.ID{0x19, 0x14, 0x64, 0x05, 0xf6, 0xad, 0x8d, 0x48, 0xc3, 0x8e, 0x7b, 0xc8, 0x18, 0x5b, 0x2f, 0x7c, 0xb7, 0x9f, 0x5c, 0x73}
	binaryIDcallGetFramebufferColor     = binary.ID{0x05, 0xfd, 0x78, 0xff, 0x3d, 0x76, 0x07, 0x2d, 0xee, 0x91, 0x3b, 0xf1, 0x99, 0x83, 0x1e, 0x4f, 0xaf, 0xd3, 0xca, 0x48}
	binaryIDcallGetFramebufferDepth     = binary.ID{0xdd, 0x68, 0xbd, 0xbc, 0x24, 0x0a, 0x1a, 0x1c, 0xa5, 0xa6, 0xfc, 0xe2, 0x64, 0x38, 0xac, 0x67, 0xa6, 0x86, 0x64, 0x5f}
	binaryIDcallGetHierarchy            = binary.ID{0xbf, 0x39, 0x53, 0xd4, 0xc3, 0xac, 0x61, 0x0a, 0xce, 0x6c, 0x72, 0x04, 0x39, 0xcd, 0x5f, 0xe5, 0x92, 0xd5, 0xf6, 0xa6}
	binaryIDcallGetMemoryInfo           = binary.ID{0x89, 0xa1, 0x6f, 0x75, 0x3d, 0x07, 0xb5, 0x9f, 0x0e, 0x20, 0xad, 0x27, 0xfd, 0xe8, 0x16, 0x50, 0x59, 0x24, 0x16, 0xb3}
	binaryIDcallGetState                = binary.ID{0xc3, 0xb2, 0x0b, 0xb8, 0x8b, 0xc7, 0x79, 0xcd, 0x06, 0xc3, 0x16, 0xef, 0x18, 0x3a, 0x96, 0x37, 0xf9, 0xad, 0x28, 0xb3}
	binaryIDcallGetTimingInfo           = binary.ID{0xb1, 0x32, 0x24, 0x67, 0x2e, 0xb9, 0x1f, 0x2f, 0x72, 0xf3, 0x6b, 0x00, 0x23, 0x1f, 0xd4, 0x1a, 0x57, 0x59, 0x22, 0x29}
	binaryIDcallImport                  = binary.ID{0x35, 0x11, 0x23, 0xbb, 0xa5, 0x10, 0x7a, 0x10, 0x7d, 0x46, 0x1d, 0x0b, 0xfc, 0x3c, 0x4e, 0x20, 0x68, 0x41, 0x1e, 0xb5}
	binaryIDcallPrerenderFramebuffers   = binary.ID{0x2f, 0x48, 0x59, 0x5f, 0xfc, 0xbf, 0xee, 0x9f, 0xfd, 0x8a, 0x56, 0x4b, 0xab, 0x90, 0xb7, 0xab, 0xeb, 0x38, 0xd1, 0x85}
	binaryIDcallReplaceAtom             = binary.ID{0x3b, 0x6a, 0x9a, 0x30, 0x3a, 0x32, 0xc0, 0x3a, 0x50, 0x5c, 0xed, 0xa9, 0xd4, 0x6a, 0x05, 0x54, 0xb3, 0xe2, 0x95, 0x3d}
	binaryIDcallResolveAtomStream       = binary.ID{0x6b, 0xef, 0x7c, 0x2b, 0x7e, 0x3c, 0x23, 0xe3, 0xe0, 0x38, 0xb8, 0xdc, 0xbb, 0xd2, 0x89, 0x93, 0xba, 0x99, 0x79, 0x90}
	binaryIDcallResolveBinary           = binary.ID{0x08, 0x68, 0x1b, 0x77, 0x97, 0x0b, 0xb5, 0x34, 0x9b, 0xed, 0x14, 0x58, 0x5e, 0x45, 0x09, 0x82, 0x0c, 0x47, 0x57, 0xe9}
	binaryIDcallResolveCapture          = binary.ID{0x4e, 0x6e, 0x5b, 0x49, 0x61, 0xef, 0xfc, 0x3c, 0x4a, 0xf8, 0xf6, 0xae, 0xc0, 0xca, 0xa1, 0x67, 0x17, 0x73, 0xff, 0xf8}
	binaryIDcallResolveDevice           = binary.ID{0x86, 0x54, 0x88, 0xf5, 0x8f, 0x3e, 0x97, 0x57, 0xe2, 0x98, 0x19, 0x7e, 0x67, 0x25, 0xfb, 0xa2, 0x75, 0xeb, 0x30, 0x0a}
	binaryIDcallResolveHierarchy        = binary.ID{0x39, 0x2a, 0x9f, 0x44, 0xfe, 0x2c, 0x0f, 0xd8, 0xc5, 0x44, 0x58, 0x51, 0x94, 0x6a, 0x95, 0xa4, 0x22, 0x90, 0x34, 0x36}
	binaryIDcallResolveImageInfo        = binary.ID{0x4e, 0x51, 0x41, 0x13, 0x68, 0x6f, 0x58, 0x5a, 0xed, 0xe0, 0x0a, 0x05, 0x0d, 0x01, 0x9d, 0x28, 0x9c, 0x21, 0x8c, 0xbb}
	binaryIDcallResolveMemoryInfo       = binary.ID{0xdf, 0x26, 0x6c, 0x3b, 0x06, 0x05, 0x08, 0xc5, 0xc1, 0xd1, 0x86, 0x64, 0x21, 0xf1, 0x58, 0x45, 0x0f, 0x3e, 0x2f, 0x0e}
	binaryIDcallResolveSchema           = binary.ID{0x45, 0xca, 0x16, 0xe5, 0x5d, 0x24, 0x69, 0x78, 0xa1, 0x23, 0x32, 0x77, 0x97, 0x13, 0xe2, 0xaf, 0x30, 0x3b, 0x70, 0x21}
	binaryIDcallResolveTimingInfo       = binary.ID{0xf9, 0x99, 0xeb, 0x43, 0x27, 0x9c, 0x38, 0x16, 0xa6, 0xb5, 0x6a, 0x0e, 0xa0, 0xdf, 0x79, 0xa1, 0x26, 0x2e, 0xe3, 0xe4}
	binaryIDresultGetCaptures           = binary.ID{0xb0, 0x3e, 0x04, 0x4d, 0x32, 0xfd, 0x8f, 0x93, 0x5a, 0xfa, 0x30, 0x09, 0x9e, 0xb6, 0x9b, 0x5d, 0x02, 0x93, 0xe4, 0x7b}
	binaryIDresultGetDevices            = binary.ID{0x7e, 0xc1, 0x80, 0xe3, 0x79, 0x1d, 0xea, 0x0d, 0x62, 0x02, 0x58, 0x6a, 0xeb, 0xa5, 0x24, 0x98, 0x30, 0x8e, 0x46, 0xe8}
	binaryIDresultGetFramebufferColor   = binary.ID{0xd1, 0xf2, 0x9c, 0x48, 0xeb, 0xb0, 0x4e, 0x4e, 0x82, 0xcf, 0xac, 0xe9, 0xc6, 0x71, 0x27, 0x04, 0x57, 0x7e, 0xe4, 0x25}
	binaryIDresultGetFramebufferDepth   = binary.ID{0x08, 0xd8, 0x4e, 0xd2, 0xe4, 0x2f, 0xc3, 0xb6, 0x10, 0x47, 0xeb, 0xae, 0xa2, 0x56, 0x99, 0x91, 0x31, 0x83, 0xb7, 0x27}
	binaryIDresultGetHierarchy          = binary.ID{0xff, 0x28, 0xe0, 0x58, 0x97, 0xa9, 0x5e, 0x1b, 0x62, 0xe1, 0xa0, 0xef, 0x05, 0xea, 0x3e, 0x62, 0x5d, 0x17, 0xaa, 0x47}
	binaryIDresultGetMemoryInfo         = binary.ID{0x54, 0xdc, 0x10, 0xcf, 0x6d, 0x96, 0x70, 0xd9, 0x00, 0x7d, 0xd7, 0x1f, 0x08, 0x4a, 0xa3, 0xaf, 0x57, 0xda, 0x09, 0xee}
	binaryIDresultGetState              = binary.ID{0xa0, 0x1e, 0x40, 0x20, 0xd1, 0x4d, 0xc6, 0x19, 0xf4, 0xcb, 0x10, 0xce, 0x81, 0x09, 0x89, 0xdf, 0xad, 0x63, 0xf6, 0xee}
	binaryIDresultGetTimingInfo         = binary.ID{0x1d, 0x17, 0x32, 0x54, 0xb3, 0xbd, 0xbe, 0x57, 0xda, 0xef, 0xb2, 0xb0, 0x4b, 0x5f, 0xc2, 0x85, 0x85, 0xcb, 0x8f, 0xf3}
	binaryIDresultImport                = binary.ID{0x1e, 0x86, 0x40, 0xb0, 0xc2, 0xb8, 0xa5, 0xa1, 0xf3, 0xc8, 0x51, 0x29, 0x87, 0x4d, 0x0c, 0xd9, 0x49, 0xd8, 0xbe, 0xed}
	binaryIDresultPrerenderFramebuffers = binary.ID{0xc2, 0x9e, 0x11, 0x61, 0x22, 0xcb, 0xd8, 0xfc, 0x6c, 0x5c, 0xb9, 0x0f, 0x07, 0x81, 0x67, 0xc9, 0x2e, 0x1f, 0x2f, 0xf8}
	binaryIDresultReplaceAtom           = binary.ID{0x52, 0x62, 0xe6, 0x27, 0x54, 0x4e, 0x8e, 0x8f, 0x1e, 0x9f, 0x5e, 0xf5, 0x8d, 0x64, 0x38, 0x99, 0xb4, 0x57, 0xef, 0xff}
	binaryIDresultResolveAtomStream     = binary.ID{0x05, 0xb9, 0x98, 0x3d, 0x6f, 0x5f, 0xc0, 0x23, 0xb2, 0xe1, 0x2e, 0x55, 0xf4, 0x37, 0x71, 0xe6, 0xd3, 0x98, 0xbf, 0x52}
	binaryIDresultResolveBinary         = binary.ID{0xbf, 0xbd, 0x77, 0xf6, 0xc1, 0x13, 0x8c, 0xfe, 0x38, 0xd5, 0x30, 0x3c, 0x58, 0xc8, 0x67, 0xbf, 0x17, 0xce, 0x71, 0xe9}
	binaryIDresultResolveCapture        = binary.ID{0xb3, 0x47, 0xd0, 0x3f, 0x28, 0x63, 0xfe, 0xa4, 0x32, 0xc6, 0xf0, 0x2c, 0xec, 0x6d, 0x33, 0x8a, 0xb2, 0x38, 0xf7, 0x37}
	binaryIDresultResolveDevice         = binary.ID{0x7f, 0xd2, 0x9f, 0x67, 0xe3, 0xbe, 0x0e, 0x46, 0x07, 0xdf, 0x8f, 0x6e, 0x6e, 0x85, 0x6d, 0x26, 0xcf, 0xd1, 0xa6, 0xa3}
	binaryIDresultResolveHierarchy      = binary.ID{0x60, 0xf3, 0x21, 0x98, 0x1b, 0x86, 0x98, 0x38, 0x8c, 0x1e, 0x33, 0x3c, 0x06, 0x9d, 0x67, 0x2a, 0x05, 0x50, 0xef, 0xfc}
	binaryIDresultResolveImageInfo      = binary.ID{0xdf, 0x45, 0x26, 0xc3, 0xec, 0x36, 0x2c, 0x5a, 0x08, 0xe3, 0x0f, 0x8e, 0x58, 0x52, 0xbd, 0xb2, 0xf3, 0x26, 0x69, 0x9f}
	binaryIDresultResolveMemoryInfo     = binary.ID{0x1f, 0xcf, 0x9a, 0x85, 0x99, 0x82, 0x5f, 0xa8, 0x46, 0x93, 0x60, 0xa5, 0x17, 0xda, 0x9e, 0x11, 0x34, 0xe8, 0x3d, 0x22}
	binaryIDresultResolveSchema         = binary.ID{0xe1, 0x27, 0x52, 0x76, 0x82, 0xcc, 0x3e, 0x6c, 0xb8, 0x6a, 0x10, 0xcb, 0x51, 0xc0, 0xcb, 0xf8, 0xa3, 0x32, 0xc7, 0xaa}
	binaryIDresultResolveTimingInfo     = binary.ID{0xc9, 0x37, 0xfb, 0xd4, 0x2d, 0x45, 0xcb, 0x15, 0x56, 0x1d, 0x08, 0xa2, 0xcc, 0xe9, 0xf8, 0x43, 0x68, 0x83, 0x3d, 0xa7}
)

type binaryClassApiId struct{}

func (*ApiId) Class() binary.Class {
	return (*binaryClassApiId)(nil)
}
func doEncodeApiId(e binary.Encoder, o *ApiId) error {
	if err := e.ID(o.ID); err != nil {
		return err
	}
	return nil
}
func doDecodeApiId(d binary.Decoder, o *ApiId) error {
	if obj, err := d.ID(); err != nil {
		return err
	} else {
		o.ID = binary.ID(obj)
	}
	return nil
}
func doSkipApiId(d binary.Decoder) error {
	if err := d.SkipID(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassApiId) ID() binary.ID      { return binaryIDApiId }
func (*binaryClassApiId) New() binary.Object { return &ApiId{} }
func (*binaryClassApiId) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeApiId(e, obj.(*ApiId))
}
func (*binaryClassApiId) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &ApiId{}
	return obj, doDecodeApiId(d, obj)
}
func (*binaryClassApiId) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeApiId(d, obj.(*ApiId))
}
func (*binaryClassApiId) Skip(d binary.Decoder) error { return doSkipApiId(d) }
func (*binaryClassApiId) Schema() *schema.Class       { return schemaApiId }

var schemaApiId = &schema.Class{
	TypeID: binaryIDApiId,
	Name:   "ApiId",
	Fields: []schema.Field{
		schema.Field{Declared: "ID", Type: &schema.Primitive{Name: "binary.ID", Method: schema.ID}},
	},
}

type binaryClassFieldInfo struct{}

func (*FieldInfo) Class() binary.Class {
	return (*binaryClassFieldInfo)(nil)
}
func doEncodeFieldInfo(e binary.Encoder, o *FieldInfo) error {
	if err := e.String(o.Name); err != nil {
		return err
	}
	if o.Type != nil {
		if err := e.Object(o.Type); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	return nil
}
func doDecodeFieldInfo(d binary.Decoder, o *FieldInfo) error {
	if obj, err := d.String(); err != nil {
		return err
	} else {
		o.Name = string(obj)
	}
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.Type = obj.(TypeInfo)
	} else {
		o.Type = nil
	}
	return nil
}
func doSkipFieldInfo(d binary.Decoder) error {
	if err := d.SkipString(); err != nil {
		return err
	}
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassFieldInfo) ID() binary.ID      { return binaryIDFieldInfo }
func (*binaryClassFieldInfo) New() binary.Object { return &FieldInfo{} }
func (*binaryClassFieldInfo) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeFieldInfo(e, obj.(*FieldInfo))
}
func (*binaryClassFieldInfo) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &FieldInfo{}
	return obj, doDecodeFieldInfo(d, obj)
}
func (*binaryClassFieldInfo) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeFieldInfo(d, obj.(*FieldInfo))
}
func (*binaryClassFieldInfo) Skip(d binary.Decoder) error { return doSkipFieldInfo(d) }
func (*binaryClassFieldInfo) Schema() *schema.Class       { return schemaFieldInfo }

var schemaFieldInfo = &schema.Class{
	TypeID: binaryIDFieldInfo,
	Name:   "FieldInfo",
	Fields: []schema.Field{
		schema.Field{Declared: "Name", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		schema.Field{Declared: "Type", Type: &schema.Interface{Name: "TypeInfo"}},
	},
}

type binaryClassStructInfo struct{}

func (*StructInfo) Class() binary.Class {
	return (*binaryClassStructInfo)(nil)
}
func doEncodeStructInfo(e binary.Encoder, o *StructInfo) error {
	if err := e.String(o.Name); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Kind)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(len(o.Fields))); err != nil {
		return err
	}
	for i := range o.Fields {
		if o.Fields[i] != nil {
			if err := e.Object(o.Fields[i]); err != nil {
				return err
			}
		} else if err := e.Object(nil); err != nil {
			return err
		}
	}
	return nil
}
func doDecodeStructInfo(d binary.Decoder, o *StructInfo) error {
	if obj, err := d.String(); err != nil {
		return err
	} else {
		o.Name = string(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Kind = TypeKind(obj)
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Fields = make(FieldInfoPtrArray, count)
		for i := range o.Fields {
			if obj, err := d.Object(); err != nil {
				return err
			} else if obj != nil {
				o.Fields[i] = obj.(*FieldInfo)
			} else {
				o.Fields[i] = nil
			}
		}
	}
	return nil
}
func doSkipStructInfo(d binary.Decoder) error {
	if err := d.SkipString(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if _, err := d.SkipObject(); err != nil {
				return err
			}
		}
	}
	return nil
}
func (*binaryClassStructInfo) ID() binary.ID      { return binaryIDStructInfo }
func (*binaryClassStructInfo) New() binary.Object { return &StructInfo{} }
func (*binaryClassStructInfo) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeStructInfo(e, obj.(*StructInfo))
}
func (*binaryClassStructInfo) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &StructInfo{}
	return obj, doDecodeStructInfo(d, obj)
}
func (*binaryClassStructInfo) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeStructInfo(d, obj.(*StructInfo))
}
func (*binaryClassStructInfo) Skip(d binary.Decoder) error { return doSkipStructInfo(d) }
func (*binaryClassStructInfo) Schema() *schema.Class       { return schemaStructInfo }

var schemaStructInfo = &schema.Class{
	TypeID: binaryIDStructInfo,
	Name:   "StructInfo",
	Fields: []schema.Field{
		schema.Field{Declared: "Name", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		schema.Field{Declared: "Kind", Type: &schema.Primitive{Name: "TypeKind", Method: schema.Int32}},
		schema.Field{Declared: "Fields", Type: &schema.Slice{Alias: "FieldInfoPtrArray", ValueType: &schema.Pointer{Type: &schema.Struct{Name: "FieldInfo"}}}},
	},
}

type binaryClassApiSchema struct{}

func (*ApiSchema) Class() binary.Class {
	return (*binaryClassApiSchema)(nil)
}
func doEncodeApiSchema(e binary.Encoder, o *ApiSchema) error {
	if err := e.Value(&o.Api); err != nil {
		return err
	}
	if err := e.Value(&o.State); err != nil {
		return err
	}
	return nil
}
func doDecodeApiSchema(d binary.Decoder, o *ApiSchema) error {
	if err := d.Value(&o.Api); err != nil {
		return err
	}
	if err := d.Value(&o.State); err != nil {
		return err
	}
	return nil
}
func doSkipApiSchema(d binary.Decoder) error {
	if err := d.SkipValue((*ApiId)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*StructInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassApiSchema) ID() binary.ID      { return binaryIDApiSchema }
func (*binaryClassApiSchema) New() binary.Object { return &ApiSchema{} }
func (*binaryClassApiSchema) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeApiSchema(e, obj.(*ApiSchema))
}
func (*binaryClassApiSchema) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &ApiSchema{}
	return obj, doDecodeApiSchema(d, obj)
}
func (*binaryClassApiSchema) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeApiSchema(d, obj.(*ApiSchema))
}
func (*binaryClassApiSchema) Skip(d binary.Decoder) error { return doSkipApiSchema(d) }
func (*binaryClassApiSchema) Schema() *schema.Class       { return schemaApiSchema }

var schemaApiSchema = &schema.Class{
	TypeID: binaryIDApiSchema,
	Name:   "ApiSchema",
	Fields: []schema.Field{
		schema.Field{Declared: "Api", Type: &schema.Struct{Name: "ApiId"}},
		schema.Field{Declared: "State", Type: &schema.Struct{Name: "StructInfo"}},
	},
}

type binaryClassArrayInfo struct{}

func (*ArrayInfo) Class() binary.Class {
	return (*binaryClassArrayInfo)(nil)
}
func doEncodeArrayInfo(e binary.Encoder, o *ArrayInfo) error {
	if err := e.String(o.Name); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Kind)); err != nil {
		return err
	}
	if o.ElementType != nil {
		if err := e.Object(o.ElementType); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	return nil
}
func doDecodeArrayInfo(d binary.Decoder, o *ArrayInfo) error {
	if obj, err := d.String(); err != nil {
		return err
	} else {
		o.Name = string(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Kind = TypeKind(obj)
	}
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.ElementType = obj.(TypeInfo)
	} else {
		o.ElementType = nil
	}
	return nil
}
func doSkipArrayInfo(d binary.Decoder) error {
	if err := d.SkipString(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassArrayInfo) ID() binary.ID      { return binaryIDArrayInfo }
func (*binaryClassArrayInfo) New() binary.Object { return &ArrayInfo{} }
func (*binaryClassArrayInfo) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeArrayInfo(e, obj.(*ArrayInfo))
}
func (*binaryClassArrayInfo) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &ArrayInfo{}
	return obj, doDecodeArrayInfo(d, obj)
}
func (*binaryClassArrayInfo) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeArrayInfo(d, obj.(*ArrayInfo))
}
func (*binaryClassArrayInfo) Skip(d binary.Decoder) error { return doSkipArrayInfo(d) }
func (*binaryClassArrayInfo) Schema() *schema.Class       { return schemaArrayInfo }

var schemaArrayInfo = &schema.Class{
	TypeID: binaryIDArrayInfo,
	Name:   "ArrayInfo",
	Fields: []schema.Field{
		schema.Field{Declared: "Name", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		schema.Field{Declared: "Kind", Type: &schema.Primitive{Name: "TypeKind", Method: schema.Int32}},
		schema.Field{Declared: "ElementType", Type: &schema.Interface{Name: "TypeInfo"}},
	},
}

type binaryClassAtomRange struct{}

func (*AtomRange) Class() binary.Class {
	return (*binaryClassAtomRange)(nil)
}
func doEncodeAtomRange(e binary.Encoder, o *AtomRange) error {
	if err := e.Uint64(o.First); err != nil {
		return err
	}
	if err := e.Uint64(o.Count); err != nil {
		return err
	}
	return nil
}
func doDecodeAtomRange(d binary.Decoder, o *AtomRange) error {
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.First = uint64(obj)
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.Count = uint64(obj)
	}
	return nil
}
func doSkipAtomRange(d binary.Decoder) error {
	if _, err := d.Uint64(); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassAtomRange) ID() binary.ID      { return binaryIDAtomRange }
func (*binaryClassAtomRange) New() binary.Object { return &AtomRange{} }
func (*binaryClassAtomRange) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeAtomRange(e, obj.(*AtomRange))
}
func (*binaryClassAtomRange) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &AtomRange{}
	return obj, doDecodeAtomRange(d, obj)
}
func (*binaryClassAtomRange) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeAtomRange(d, obj.(*AtomRange))
}
func (*binaryClassAtomRange) Skip(d binary.Decoder) error { return doSkipAtomRange(d) }
func (*binaryClassAtomRange) Schema() *schema.Class       { return schemaAtomRange }

var schemaAtomRange = &schema.Class{
	TypeID: binaryIDAtomRange,
	Name:   "AtomRange",
	Fields: []schema.Field{
		schema.Field{Declared: "First", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
		schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
	},
}

type binaryClassAtomGroup struct{}

func (*AtomGroup) Class() binary.Class {
	return (*binaryClassAtomGroup)(nil)
}
func doEncodeAtomGroup(e binary.Encoder, o *AtomGroup) error {
	if err := e.String(o.Name); err != nil {
		return err
	}
	if err := e.Value(&o.Range); err != nil {
		return err
	}
	if err := e.Uint32(uint32(len(o.SubGroups))); err != nil {
		return err
	}
	for i := range o.SubGroups {
		if err := e.Value(&o.SubGroups[i]); err != nil {
			return err
		}
	}
	return nil
}
func doDecodeAtomGroup(d binary.Decoder, o *AtomGroup) error {
	if obj, err := d.String(); err != nil {
		return err
	} else {
		o.Name = string(obj)
	}
	if err := d.Value(&o.Range); err != nil {
		return err
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.SubGroups = make(AtomGroupArray, count)
		for i := range o.SubGroups {
			if err := d.Value(&o.SubGroups[i]); err != nil {
				return err
			}
		}
	}
	return nil
}
func doSkipAtomGroup(d binary.Decoder) error {
	if err := d.SkipString(); err != nil {
		return err
	}
	if err := d.SkipValue((*AtomRange)(nil)); err != nil {
		return err
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if err := d.SkipValue((*AtomGroup)(nil)); err != nil {
				return err
			}
		}
	}
	return nil
}
func (*binaryClassAtomGroup) ID() binary.ID      { return binaryIDAtomGroup }
func (*binaryClassAtomGroup) New() binary.Object { return &AtomGroup{} }
func (*binaryClassAtomGroup) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeAtomGroup(e, obj.(*AtomGroup))
}
func (*binaryClassAtomGroup) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &AtomGroup{}
	return obj, doDecodeAtomGroup(d, obj)
}
func (*binaryClassAtomGroup) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeAtomGroup(d, obj.(*AtomGroup))
}
func (*binaryClassAtomGroup) Skip(d binary.Decoder) error { return doSkipAtomGroup(d) }
func (*binaryClassAtomGroup) Schema() *schema.Class       { return schemaAtomGroup }

var schemaAtomGroup = &schema.Class{
	TypeID: binaryIDAtomGroup,
	Name:   "AtomGroup",
	Fields: []schema.Field{
		schema.Field{Declared: "Name", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		schema.Field{Declared: "Range", Type: &schema.Struct{Name: "AtomRange"}},
		schema.Field{Declared: "SubGroups", Type: &schema.Slice{Alias: "AtomGroupArray", ValueType: &schema.Struct{Name: "AtomGroup"}}},
	},
}

type binaryClassParameterInfo struct{}

func (*ParameterInfo) Class() binary.Class {
	return (*binaryClassParameterInfo)(nil)
}
func doEncodeParameterInfo(e binary.Encoder, o *ParameterInfo) error {
	if err := e.String(o.Name); err != nil {
		return err
	}
	if o.Type != nil {
		if err := e.Object(o.Type); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	if err := e.Bool(o.Out); err != nil {
		return err
	}
	return nil
}
func doDecodeParameterInfo(d binary.Decoder, o *ParameterInfo) error {
	if obj, err := d.String(); err != nil {
		return err
	} else {
		o.Name = string(obj)
	}
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.Type = obj.(TypeInfo)
	} else {
		o.Type = nil
	}
	if obj, err := d.Bool(); err != nil {
		return err
	} else {
		o.Out = bool(obj)
	}
	return nil
}
func doSkipParameterInfo(d binary.Decoder) error {
	if err := d.SkipString(); err != nil {
		return err
	}
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	if _, err := d.Bool(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassParameterInfo) ID() binary.ID      { return binaryIDParameterInfo }
func (*binaryClassParameterInfo) New() binary.Object { return &ParameterInfo{} }
func (*binaryClassParameterInfo) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeParameterInfo(e, obj.(*ParameterInfo))
}
func (*binaryClassParameterInfo) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &ParameterInfo{}
	return obj, doDecodeParameterInfo(d, obj)
}
func (*binaryClassParameterInfo) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeParameterInfo(d, obj.(*ParameterInfo))
}
func (*binaryClassParameterInfo) Skip(d binary.Decoder) error { return doSkipParameterInfo(d) }
func (*binaryClassParameterInfo) Schema() *schema.Class       { return schemaParameterInfo }

var schemaParameterInfo = &schema.Class{
	TypeID: binaryIDParameterInfo,
	Name:   "ParameterInfo",
	Fields: []schema.Field{
		schema.Field{Declared: "Name", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		schema.Field{Declared: "Type", Type: &schema.Interface{Name: "TypeInfo"}},
		schema.Field{Declared: "Out", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
	},
}

type binaryClassAtomInfo struct{}

func (*AtomInfo) Class() binary.Class {
	return (*binaryClassAtomInfo)(nil)
}
func doEncodeAtomInfo(e binary.Encoder, o *AtomInfo) error {
	if err := e.Value(&o.Api); err != nil {
		return err
	}
	if err := e.Uint16(o.Type); err != nil {
		return err
	}
	if err := e.String(o.Name); err != nil {
		return err
	}
	if err := e.Uint32(uint32(len(o.Parameters))); err != nil {
		return err
	}
	for i := range o.Parameters {
		if err := e.Value(&o.Parameters[i]); err != nil {
			return err
		}
	}
	if err := e.Bool(o.IsCommand); err != nil {
		return err
	}
	if err := e.Bool(o.IsDrawCall); err != nil {
		return err
	}
	if err := e.Bool(o.IsEndOfFrame); err != nil {
		return err
	}
	if err := e.String(o.DocumentationUrl); err != nil {
		return err
	}
	return nil
}
func doDecodeAtomInfo(d binary.Decoder, o *AtomInfo) error {
	if err := d.Value(&o.Api); err != nil {
		return err
	}
	if obj, err := d.Uint16(); err != nil {
		return err
	} else {
		o.Type = uint16(obj)
	}
	if obj, err := d.String(); err != nil {
		return err
	} else {
		o.Name = string(obj)
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Parameters = make(ParameterInfoArray, count)
		for i := range o.Parameters {
			if err := d.Value(&o.Parameters[i]); err != nil {
				return err
			}
		}
	}
	if obj, err := d.Bool(); err != nil {
		return err
	} else {
		o.IsCommand = bool(obj)
	}
	if obj, err := d.Bool(); err != nil {
		return err
	} else {
		o.IsDrawCall = bool(obj)
	}
	if obj, err := d.Bool(); err != nil {
		return err
	} else {
		o.IsEndOfFrame = bool(obj)
	}
	if obj, err := d.String(); err != nil {
		return err
	} else {
		o.DocumentationUrl = string(obj)
	}
	return nil
}
func doSkipAtomInfo(d binary.Decoder) error {
	if err := d.SkipValue((*ApiId)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint16(); err != nil {
		return err
	}
	if err := d.SkipString(); err != nil {
		return err
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if err := d.SkipValue((*ParameterInfo)(nil)); err != nil {
				return err
			}
		}
	}
	if _, err := d.Bool(); err != nil {
		return err
	}
	if _, err := d.Bool(); err != nil {
		return err
	}
	if _, err := d.Bool(); err != nil {
		return err
	}
	if err := d.SkipString(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassAtomInfo) ID() binary.ID      { return binaryIDAtomInfo }
func (*binaryClassAtomInfo) New() binary.Object { return &AtomInfo{} }
func (*binaryClassAtomInfo) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeAtomInfo(e, obj.(*AtomInfo))
}
func (*binaryClassAtomInfo) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &AtomInfo{}
	return obj, doDecodeAtomInfo(d, obj)
}
func (*binaryClassAtomInfo) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeAtomInfo(d, obj.(*AtomInfo))
}
func (*binaryClassAtomInfo) Skip(d binary.Decoder) error { return doSkipAtomInfo(d) }
func (*binaryClassAtomInfo) Schema() *schema.Class       { return schemaAtomInfo }

var schemaAtomInfo = &schema.Class{
	TypeID: binaryIDAtomInfo,
	Name:   "AtomInfo",
	Fields: []schema.Field{
		schema.Field{Declared: "Api", Type: &schema.Struct{Name: "ApiId"}},
		schema.Field{Declared: "Type", Type: &schema.Primitive{Name: "uint16", Method: schema.Uint16}},
		schema.Field{Declared: "Name", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		schema.Field{Declared: "Parameters", Type: &schema.Slice{Alias: "ParameterInfoArray", ValueType: &schema.Struct{Name: "ParameterInfo"}}},
		schema.Field{Declared: "IsCommand", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
		schema.Field{Declared: "IsDrawCall", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
		schema.Field{Declared: "IsEndOfFrame", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
		schema.Field{Declared: "DocumentationUrl", Type: &schema.Primitive{Name: "string", Method: schema.String}},
	},
}

type binaryClassAtomRangeTimer struct{}

func (*AtomRangeTimer) Class() binary.Class {
	return (*binaryClassAtomRangeTimer)(nil)
}
func doEncodeAtomRangeTimer(e binary.Encoder, o *AtomRangeTimer) error {
	if err := e.Uint64(o.FromAtomId); err != nil {
		return err
	}
	if err := e.Uint64(o.ToAtomId); err != nil {
		return err
	}
	if err := e.Uint64(o.Nanoseconds); err != nil {
		return err
	}
	return nil
}
func doDecodeAtomRangeTimer(d binary.Decoder, o *AtomRangeTimer) error {
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.FromAtomId = uint64(obj)
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.ToAtomId = uint64(obj)
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.Nanoseconds = uint64(obj)
	}
	return nil
}
func doSkipAtomRangeTimer(d binary.Decoder) error {
	if _, err := d.Uint64(); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassAtomRangeTimer) ID() binary.ID      { return binaryIDAtomRangeTimer }
func (*binaryClassAtomRangeTimer) New() binary.Object { return &AtomRangeTimer{} }
func (*binaryClassAtomRangeTimer) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeAtomRangeTimer(e, obj.(*AtomRangeTimer))
}
func (*binaryClassAtomRangeTimer) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &AtomRangeTimer{}
	return obj, doDecodeAtomRangeTimer(d, obj)
}
func (*binaryClassAtomRangeTimer) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeAtomRangeTimer(d, obj.(*AtomRangeTimer))
}
func (*binaryClassAtomRangeTimer) Skip(d binary.Decoder) error { return doSkipAtomRangeTimer(d) }
func (*binaryClassAtomRangeTimer) Schema() *schema.Class       { return schemaAtomRangeTimer }

var schemaAtomRangeTimer = &schema.Class{
	TypeID: binaryIDAtomRangeTimer,
	Name:   "AtomRangeTimer",
	Fields: []schema.Field{
		schema.Field{Declared: "FromAtomId", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
		schema.Field{Declared: "ToAtomId", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
		schema.Field{Declared: "Nanoseconds", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
	},
}

type binaryClassAtomStream struct{}

func (*AtomStream) Class() binary.Class {
	return (*binaryClassAtomStream)(nil)
}
func doEncodeAtomStream(e binary.Encoder, o *AtomStream) error {
	if err := e.Uint32(uint32(len(o.Data))); err != nil {
		return err
	}
	if err := e.Data(o.Data); err != nil {
		return err
	}
	return nil
}
func doDecodeAtomStream(d binary.Decoder, o *AtomStream) error {
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Data = make(U8Array, count)
		if err := d.Data(o.Data); err != nil {
			return err
		}
	}
	return nil
}
func doSkipAtomStream(d binary.Decoder) error {
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		if err := d.Skip(count); err != nil {
			return err
		}
	}
	return nil
}
func (*binaryClassAtomStream) ID() binary.ID      { return binaryIDAtomStream }
func (*binaryClassAtomStream) New() binary.Object { return &AtomStream{} }
func (*binaryClassAtomStream) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeAtomStream(e, obj.(*AtomStream))
}
func (*binaryClassAtomStream) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &AtomStream{}
	return obj, doDecodeAtomStream(d, obj)
}
func (*binaryClassAtomStream) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeAtomStream(d, obj.(*AtomStream))
}
func (*binaryClassAtomStream) Skip(d binary.Decoder) error { return doSkipAtomStream(d) }
func (*binaryClassAtomStream) Schema() *schema.Class       { return schemaAtomStream }

var schemaAtomStream = &schema.Class{
	TypeID: binaryIDAtomStream,
	Name:   "AtomStream",
	Fields: []schema.Field{
		schema.Field{Declared: "Data", Type: &schema.Slice{Alias: "U8Array", ValueType: &schema.Primitive{Name: "uint8", Method: schema.Uint8}}},
	},
}

type binaryClassAtomStreamId struct{}

func (*AtomStreamId) Class() binary.Class {
	return (*binaryClassAtomStreamId)(nil)
}
func doEncodeAtomStreamId(e binary.Encoder, o *AtomStreamId) error {
	if err := e.ID(o.ID); err != nil {
		return err
	}
	return nil
}
func doDecodeAtomStreamId(d binary.Decoder, o *AtomStreamId) error {
	if obj, err := d.ID(); err != nil {
		return err
	} else {
		o.ID = binary.ID(obj)
	}
	return nil
}
func doSkipAtomStreamId(d binary.Decoder) error {
	if err := d.SkipID(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassAtomStreamId) ID() binary.ID      { return binaryIDAtomStreamId }
func (*binaryClassAtomStreamId) New() binary.Object { return &AtomStreamId{} }
func (*binaryClassAtomStreamId) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeAtomStreamId(e, obj.(*AtomStreamId))
}
func (*binaryClassAtomStreamId) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &AtomStreamId{}
	return obj, doDecodeAtomStreamId(d, obj)
}
func (*binaryClassAtomStreamId) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeAtomStreamId(d, obj.(*AtomStreamId))
}
func (*binaryClassAtomStreamId) Skip(d binary.Decoder) error { return doSkipAtomStreamId(d) }
func (*binaryClassAtomStreamId) Schema() *schema.Class       { return schemaAtomStreamId }

var schemaAtomStreamId = &schema.Class{
	TypeID: binaryIDAtomStreamId,
	Name:   "AtomStreamId",
	Fields: []schema.Field{
		schema.Field{Declared: "ID", Type: &schema.Primitive{Name: "binary.ID", Method: schema.ID}},
	},
}

type binaryClassAtomTimer struct{}

func (*AtomTimer) Class() binary.Class {
	return (*binaryClassAtomTimer)(nil)
}
func doEncodeAtomTimer(e binary.Encoder, o *AtomTimer) error {
	if err := e.Uint64(o.AtomId); err != nil {
		return err
	}
	if err := e.Uint64(o.Nanoseconds); err != nil {
		return err
	}
	return nil
}
func doDecodeAtomTimer(d binary.Decoder, o *AtomTimer) error {
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.AtomId = uint64(obj)
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.Nanoseconds = uint64(obj)
	}
	return nil
}
func doSkipAtomTimer(d binary.Decoder) error {
	if _, err := d.Uint64(); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassAtomTimer) ID() binary.ID      { return binaryIDAtomTimer }
func (*binaryClassAtomTimer) New() binary.Object { return &AtomTimer{} }
func (*binaryClassAtomTimer) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeAtomTimer(e, obj.(*AtomTimer))
}
func (*binaryClassAtomTimer) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &AtomTimer{}
	return obj, doDecodeAtomTimer(d, obj)
}
func (*binaryClassAtomTimer) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeAtomTimer(d, obj.(*AtomTimer))
}
func (*binaryClassAtomTimer) Skip(d binary.Decoder) error { return doSkipAtomTimer(d) }
func (*binaryClassAtomTimer) Schema() *schema.Class       { return schemaAtomTimer }

var schemaAtomTimer = &schema.Class{
	TypeID: binaryIDAtomTimer,
	Name:   "AtomTimer",
	Fields: []schema.Field{
		schema.Field{Declared: "AtomId", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
		schema.Field{Declared: "Nanoseconds", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
	},
}

type binaryClassBinary struct{}

func (*Binary) Class() binary.Class {
	return (*binaryClassBinary)(nil)
}
func doEncodeBinary(e binary.Encoder, o *Binary) error {
	if err := e.Uint32(uint32(len(o.Data))); err != nil {
		return err
	}
	if err := e.Data(o.Data); err != nil {
		return err
	}
	return nil
}
func doDecodeBinary(d binary.Decoder, o *Binary) error {
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Data = make(U8Array, count)
		if err := d.Data(o.Data); err != nil {
			return err
		}
	}
	return nil
}
func doSkipBinary(d binary.Decoder) error {
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		if err := d.Skip(count); err != nil {
			return err
		}
	}
	return nil
}
func (*binaryClassBinary) ID() binary.ID      { return binaryIDBinary }
func (*binaryClassBinary) New() binary.Object { return &Binary{} }
func (*binaryClassBinary) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeBinary(e, obj.(*Binary))
}
func (*binaryClassBinary) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Binary{}
	return obj, doDecodeBinary(d, obj)
}
func (*binaryClassBinary) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeBinary(d, obj.(*Binary))
}
func (*binaryClassBinary) Skip(d binary.Decoder) error { return doSkipBinary(d) }
func (*binaryClassBinary) Schema() *schema.Class       { return schemaBinary }

var schemaBinary = &schema.Class{
	TypeID: binaryIDBinary,
	Name:   "Binary",
	Fields: []schema.Field{
		schema.Field{Declared: "Data", Type: &schema.Slice{Alias: "U8Array", ValueType: &schema.Primitive{Name: "uint8", Method: schema.Uint8}}},
	},
}

type binaryClassBinaryId struct{}

func (*BinaryId) Class() binary.Class {
	return (*binaryClassBinaryId)(nil)
}
func doEncodeBinaryId(e binary.Encoder, o *BinaryId) error {
	if err := e.ID(o.ID); err != nil {
		return err
	}
	return nil
}
func doDecodeBinaryId(d binary.Decoder, o *BinaryId) error {
	if obj, err := d.ID(); err != nil {
		return err
	} else {
		o.ID = binary.ID(obj)
	}
	return nil
}
func doSkipBinaryId(d binary.Decoder) error {
	if err := d.SkipID(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassBinaryId) ID() binary.ID      { return binaryIDBinaryId }
func (*binaryClassBinaryId) New() binary.Object { return &BinaryId{} }
func (*binaryClassBinaryId) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeBinaryId(e, obj.(*BinaryId))
}
func (*binaryClassBinaryId) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &BinaryId{}
	return obj, doDecodeBinaryId(d, obj)
}
func (*binaryClassBinaryId) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeBinaryId(d, obj.(*BinaryId))
}
func (*binaryClassBinaryId) Skip(d binary.Decoder) error { return doSkipBinaryId(d) }
func (*binaryClassBinaryId) Schema() *schema.Class       { return schemaBinaryId }

var schemaBinaryId = &schema.Class{
	TypeID: binaryIDBinaryId,
	Name:   "BinaryId",
	Fields: []schema.Field{
		schema.Field{Declared: "ID", Type: &schema.Primitive{Name: "binary.ID", Method: schema.ID}},
	},
}

type binaryClassSchemaId struct{}

func (*SchemaId) Class() binary.Class {
	return (*binaryClassSchemaId)(nil)
}
func doEncodeSchemaId(e binary.Encoder, o *SchemaId) error {
	if err := e.ID(o.ID); err != nil {
		return err
	}
	return nil
}
func doDecodeSchemaId(d binary.Decoder, o *SchemaId) error {
	if obj, err := d.ID(); err != nil {
		return err
	} else {
		o.ID = binary.ID(obj)
	}
	return nil
}
func doSkipSchemaId(d binary.Decoder) error {
	if err := d.SkipID(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassSchemaId) ID() binary.ID      { return binaryIDSchemaId }
func (*binaryClassSchemaId) New() binary.Object { return &SchemaId{} }
func (*binaryClassSchemaId) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeSchemaId(e, obj.(*SchemaId))
}
func (*binaryClassSchemaId) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &SchemaId{}
	return obj, doDecodeSchemaId(d, obj)
}
func (*binaryClassSchemaId) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeSchemaId(d, obj.(*SchemaId))
}
func (*binaryClassSchemaId) Skip(d binary.Decoder) error { return doSkipSchemaId(d) }
func (*binaryClassSchemaId) Schema() *schema.Class       { return schemaSchemaId }

var schemaSchemaId = &schema.Class{
	TypeID: binaryIDSchemaId,
	Name:   "SchemaId",
	Fields: []schema.Field{
		schema.Field{Declared: "ID", Type: &schema.Primitive{Name: "binary.ID", Method: schema.ID}},
	},
}

type binaryClassCapture struct{}

func (*Capture) Class() binary.Class {
	return (*binaryClassCapture)(nil)
}
func doEncodeCapture(e binary.Encoder, o *Capture) error {
	if err := e.String(o.Name); err != nil {
		return err
	}
	if err := e.Value(&o.Atoms); err != nil {
		return err
	}
	if err := e.Uint32(uint32(len(o.Apis))); err != nil {
		return err
	}
	for i := range o.Apis {
		if err := e.Value(&o.Apis[i]); err != nil {
			return err
		}
	}
	if err := e.Value(&o.Schema); err != nil {
		return err
	}
	return nil
}
func doDecodeCapture(d binary.Decoder, o *Capture) error {
	if obj, err := d.String(); err != nil {
		return err
	} else {
		o.Name = string(obj)
	}
	if err := d.Value(&o.Atoms); err != nil {
		return err
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Apis = make(ApiIdArray, count)
		for i := range o.Apis {
			if err := d.Value(&o.Apis[i]); err != nil {
				return err
			}
		}
	}
	if err := d.Value(&o.Schema); err != nil {
		return err
	}
	return nil
}
func doSkipCapture(d binary.Decoder) error {
	if err := d.SkipString(); err != nil {
		return err
	}
	if err := d.SkipValue((*AtomStreamId)(nil)); err != nil {
		return err
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if err := d.SkipValue((*ApiId)(nil)); err != nil {
				return err
			}
		}
	}
	if err := d.SkipValue((*SchemaId)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCapture) ID() binary.ID      { return binaryIDCapture }
func (*binaryClassCapture) New() binary.Object { return &Capture{} }
func (*binaryClassCapture) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCapture(e, obj.(*Capture))
}
func (*binaryClassCapture) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Capture{}
	return obj, doDecodeCapture(d, obj)
}
func (*binaryClassCapture) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCapture(d, obj.(*Capture))
}
func (*binaryClassCapture) Skip(d binary.Decoder) error { return doSkipCapture(d) }
func (*binaryClassCapture) Schema() *schema.Class       { return schemaCapture }

var schemaCapture = &schema.Class{
	TypeID: binaryIDCapture,
	Name:   "Capture",
	Fields: []schema.Field{
		schema.Field{Declared: "Name", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		schema.Field{Declared: "Atoms", Type: &schema.Struct{Name: "AtomStreamId"}},
		schema.Field{Declared: "Apis", Type: &schema.Slice{Alias: "ApiIdArray", ValueType: &schema.Struct{Name: "ApiId"}}},
		schema.Field{Declared: "Schema", Type: &schema.Struct{Name: "SchemaId"}},
	},
}

type binaryClassCaptureId struct{}

func (*CaptureId) Class() binary.Class {
	return (*binaryClassCaptureId)(nil)
}
func doEncodeCaptureId(e binary.Encoder, o *CaptureId) error {
	if err := e.ID(o.ID); err != nil {
		return err
	}
	return nil
}
func doDecodeCaptureId(d binary.Decoder, o *CaptureId) error {
	if obj, err := d.ID(); err != nil {
		return err
	} else {
		o.ID = binary.ID(obj)
	}
	return nil
}
func doSkipCaptureId(d binary.Decoder) error {
	if err := d.SkipID(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCaptureId) ID() binary.ID      { return binaryIDCaptureId }
func (*binaryClassCaptureId) New() binary.Object { return &CaptureId{} }
func (*binaryClassCaptureId) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCaptureId(e, obj.(*CaptureId))
}
func (*binaryClassCaptureId) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CaptureId{}
	return obj, doDecodeCaptureId(d, obj)
}
func (*binaryClassCaptureId) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCaptureId(d, obj.(*CaptureId))
}
func (*binaryClassCaptureId) Skip(d binary.Decoder) error { return doSkipCaptureId(d) }
func (*binaryClassCaptureId) Schema() *schema.Class       { return schemaCaptureId }

var schemaCaptureId = &schema.Class{
	TypeID: binaryIDCaptureId,
	Name:   "CaptureId",
	Fields: []schema.Field{
		schema.Field{Declared: "ID", Type: &schema.Primitive{Name: "binary.ID", Method: schema.ID}},
	},
}

type binaryClassClassInfo struct{}

func (*ClassInfo) Class() binary.Class {
	return (*binaryClassClassInfo)(nil)
}
func doEncodeClassInfo(e binary.Encoder, o *ClassInfo) error {
	if err := e.String(o.Name); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Kind)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(len(o.Fields))); err != nil {
		return err
	}
	for i := range o.Fields {
		if o.Fields[i] != nil {
			if err := e.Object(o.Fields[i]); err != nil {
				return err
			}
		} else if err := e.Object(nil); err != nil {
			return err
		}
	}
	if err := e.Uint32(uint32(len(o.Extends))); err != nil {
		return err
	}
	for i := range o.Extends {
		if o.Extends[i] != nil {
			if err := e.Object(o.Extends[i]); err != nil {
				return err
			}
		} else if err := e.Object(nil); err != nil {
			return err
		}
	}
	return nil
}
func doDecodeClassInfo(d binary.Decoder, o *ClassInfo) error {
	if obj, err := d.String(); err != nil {
		return err
	} else {
		o.Name = string(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Kind = TypeKind(obj)
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Fields = make(FieldInfoPtrArray, count)
		for i := range o.Fields {
			if obj, err := d.Object(); err != nil {
				return err
			} else if obj != nil {
				o.Fields[i] = obj.(*FieldInfo)
			} else {
				o.Fields[i] = nil
			}
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Extends = make(ClassInfoPtrArray, count)
		for i := range o.Extends {
			if obj, err := d.Object(); err != nil {
				return err
			} else if obj != nil {
				o.Extends[i] = obj.(*ClassInfo)
			} else {
				o.Extends[i] = nil
			}
		}
	}
	return nil
}
func doSkipClassInfo(d binary.Decoder) error {
	if err := d.SkipString(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if _, err := d.SkipObject(); err != nil {
				return err
			}
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if _, err := d.SkipObject(); err != nil {
				return err
			}
		}
	}
	return nil
}
func (*binaryClassClassInfo) ID() binary.ID      { return binaryIDClassInfo }
func (*binaryClassClassInfo) New() binary.Object { return &ClassInfo{} }
func (*binaryClassClassInfo) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeClassInfo(e, obj.(*ClassInfo))
}
func (*binaryClassClassInfo) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &ClassInfo{}
	return obj, doDecodeClassInfo(d, obj)
}
func (*binaryClassClassInfo) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeClassInfo(d, obj.(*ClassInfo))
}
func (*binaryClassClassInfo) Skip(d binary.Decoder) error { return doSkipClassInfo(d) }
func (*binaryClassClassInfo) Schema() *schema.Class       { return schemaClassInfo }

var schemaClassInfo = &schema.Class{
	TypeID: binaryIDClassInfo,
	Name:   "ClassInfo",
	Fields: []schema.Field{
		schema.Field{Declared: "Name", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		schema.Field{Declared: "Kind", Type: &schema.Primitive{Name: "TypeKind", Method: schema.Int32}},
		schema.Field{Declared: "Fields", Type: &schema.Slice{Alias: "FieldInfoPtrArray", ValueType: &schema.Pointer{Type: &schema.Struct{Name: "FieldInfo"}}}},
		schema.Field{Declared: "Extends", Type: &schema.Slice{Alias: "ClassInfoPtrArray", ValueType: &schema.Pointer{Type: &schema.Struct{Name: "ClassInfo"}}}},
	},
}

type binaryClassDevice struct{}

func (*Device) Class() binary.Class {
	return (*binaryClassDevice)(nil)
}
func doEncodeDevice(e binary.Encoder, o *Device) error {
	if err := e.String(o.Name); err != nil {
		return err
	}
	if err := e.String(o.Model); err != nil {
		return err
	}
	if err := e.String(o.OS); err != nil {
		return err
	}
	if err := e.Uint8(o.PointerSize); err != nil {
		return err
	}
	if err := e.Uint8(o.PointerAlignment); err != nil {
		return err
	}
	if err := e.Uint64(o.MaxMemorySize); err != nil {
		return err
	}
	if err := e.Bool(o.RequiresShaderPatching); err != nil {
		return err
	}
	return nil
}
func doDecodeDevice(d binary.Decoder, o *Device) error {
	if obj, err := d.String(); err != nil {
		return err
	} else {
		o.Name = string(obj)
	}
	if obj, err := d.String(); err != nil {
		return err
	} else {
		o.Model = string(obj)
	}
	if obj, err := d.String(); err != nil {
		return err
	} else {
		o.OS = string(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.PointerSize = uint8(obj)
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.PointerAlignment = uint8(obj)
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.MaxMemorySize = uint64(obj)
	}
	if obj, err := d.Bool(); err != nil {
		return err
	} else {
		o.RequiresShaderPatching = bool(obj)
	}
	return nil
}
func doSkipDevice(d binary.Decoder) error {
	if err := d.SkipString(); err != nil {
		return err
	}
	if err := d.SkipString(); err != nil {
		return err
	}
	if err := d.SkipString(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	if _, err := d.Bool(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassDevice) ID() binary.ID      { return binaryIDDevice }
func (*binaryClassDevice) New() binary.Object { return &Device{} }
func (*binaryClassDevice) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeDevice(e, obj.(*Device))
}
func (*binaryClassDevice) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Device{}
	return obj, doDecodeDevice(d, obj)
}
func (*binaryClassDevice) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeDevice(d, obj.(*Device))
}
func (*binaryClassDevice) Skip(d binary.Decoder) error { return doSkipDevice(d) }
func (*binaryClassDevice) Schema() *schema.Class       { return schemaDevice }

var schemaDevice = &schema.Class{
	TypeID: binaryIDDevice,
	Name:   "Device",
	Fields: []schema.Field{
		schema.Field{Declared: "Name", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		schema.Field{Declared: "Model", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		schema.Field{Declared: "OS", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		schema.Field{Declared: "PointerSize", Type: &schema.Primitive{Name: "uint8", Method: schema.Uint8}},
		schema.Field{Declared: "PointerAlignment", Type: &schema.Primitive{Name: "uint8", Method: schema.Uint8}},
		schema.Field{Declared: "MaxMemorySize", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
		schema.Field{Declared: "RequiresShaderPatching", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
	},
}

type binaryClassDeviceId struct{}

func (*DeviceId) Class() binary.Class {
	return (*binaryClassDeviceId)(nil)
}
func doEncodeDeviceId(e binary.Encoder, o *DeviceId) error {
	if err := e.ID(o.ID); err != nil {
		return err
	}
	return nil
}
func doDecodeDeviceId(d binary.Decoder, o *DeviceId) error {
	if obj, err := d.ID(); err != nil {
		return err
	} else {
		o.ID = binary.ID(obj)
	}
	return nil
}
func doSkipDeviceId(d binary.Decoder) error {
	if err := d.SkipID(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassDeviceId) ID() binary.ID      { return binaryIDDeviceId }
func (*binaryClassDeviceId) New() binary.Object { return &DeviceId{} }
func (*binaryClassDeviceId) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeDeviceId(e, obj.(*DeviceId))
}
func (*binaryClassDeviceId) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &DeviceId{}
	return obj, doDecodeDeviceId(d, obj)
}
func (*binaryClassDeviceId) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeDeviceId(d, obj.(*DeviceId))
}
func (*binaryClassDeviceId) Skip(d binary.Decoder) error { return doSkipDeviceId(d) }
func (*binaryClassDeviceId) Schema() *schema.Class       { return schemaDeviceId }

var schemaDeviceId = &schema.Class{
	TypeID: binaryIDDeviceId,
	Name:   "DeviceId",
	Fields: []schema.Field{
		schema.Field{Declared: "ID", Type: &schema.Primitive{Name: "binary.ID", Method: schema.ID}},
	},
}

type binaryClassEnumEntry struct{}

func (*EnumEntry) Class() binary.Class {
	return (*binaryClassEnumEntry)(nil)
}
func doEncodeEnumEntry(e binary.Encoder, o *EnumEntry) error {
	if err := e.String(o.Name); err != nil {
		return err
	}
	if err := e.Uint32(o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeEnumEntry(d binary.Decoder, o *EnumEntry) error {
	if obj, err := d.String(); err != nil {
		return err
	} else {
		o.Name = string(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Value = uint32(obj)
	}
	return nil
}
func doSkipEnumEntry(d binary.Decoder) error {
	if err := d.SkipString(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassEnumEntry) ID() binary.ID      { return binaryIDEnumEntry }
func (*binaryClassEnumEntry) New() binary.Object { return &EnumEntry{} }
func (*binaryClassEnumEntry) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeEnumEntry(e, obj.(*EnumEntry))
}
func (*binaryClassEnumEntry) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &EnumEntry{}
	return obj, doDecodeEnumEntry(d, obj)
}
func (*binaryClassEnumEntry) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeEnumEntry(d, obj.(*EnumEntry))
}
func (*binaryClassEnumEntry) Skip(d binary.Decoder) error { return doSkipEnumEntry(d) }
func (*binaryClassEnumEntry) Schema() *schema.Class       { return schemaEnumEntry }

var schemaEnumEntry = &schema.Class{
	TypeID: binaryIDEnumEntry,
	Name:   "EnumEntry",
	Fields: []schema.Field{
		schema.Field{Declared: "Name", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		schema.Field{Declared: "Value", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
	},
}

type binaryClassEnumInfo struct{}

func (*EnumInfo) Class() binary.Class {
	return (*binaryClassEnumInfo)(nil)
}
func doEncodeEnumInfo(e binary.Encoder, o *EnumInfo) error {
	if err := e.String(o.Name); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Kind)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(len(o.Entries))); err != nil {
		return err
	}
	for i := range o.Entries {
		if err := e.Value(&o.Entries[i]); err != nil {
			return err
		}
	}
	if err := e.Uint32(uint32(len(o.Extends))); err != nil {
		return err
	}
	for i := range o.Extends {
		if o.Extends[i] != nil {
			if err := e.Object(o.Extends[i]); err != nil {
				return err
			}
		} else if err := e.Object(nil); err != nil {
			return err
		}
	}
	return nil
}
func doDecodeEnumInfo(d binary.Decoder, o *EnumInfo) error {
	if obj, err := d.String(); err != nil {
		return err
	} else {
		o.Name = string(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Kind = TypeKind(obj)
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Entries = make(EnumEntryArray, count)
		for i := range o.Entries {
			if err := d.Value(&o.Entries[i]); err != nil {
				return err
			}
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Extends = make(EnumInfoPtrArray, count)
		for i := range o.Extends {
			if obj, err := d.Object(); err != nil {
				return err
			} else if obj != nil {
				o.Extends[i] = obj.(*EnumInfo)
			} else {
				o.Extends[i] = nil
			}
		}
	}
	return nil
}
func doSkipEnumInfo(d binary.Decoder) error {
	if err := d.SkipString(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if err := d.SkipValue((*EnumEntry)(nil)); err != nil {
				return err
			}
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if _, err := d.SkipObject(); err != nil {
				return err
			}
		}
	}
	return nil
}
func (*binaryClassEnumInfo) ID() binary.ID      { return binaryIDEnumInfo }
func (*binaryClassEnumInfo) New() binary.Object { return &EnumInfo{} }
func (*binaryClassEnumInfo) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeEnumInfo(e, obj.(*EnumInfo))
}
func (*binaryClassEnumInfo) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &EnumInfo{}
	return obj, doDecodeEnumInfo(d, obj)
}
func (*binaryClassEnumInfo) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeEnumInfo(d, obj.(*EnumInfo))
}
func (*binaryClassEnumInfo) Skip(d binary.Decoder) error { return doSkipEnumInfo(d) }
func (*binaryClassEnumInfo) Schema() *schema.Class       { return schemaEnumInfo }

var schemaEnumInfo = &schema.Class{
	TypeID: binaryIDEnumInfo,
	Name:   "EnumInfo",
	Fields: []schema.Field{
		schema.Field{Declared: "Name", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		schema.Field{Declared: "Kind", Type: &schema.Primitive{Name: "TypeKind", Method: schema.Int32}},
		schema.Field{Declared: "Entries", Type: &schema.Slice{Alias: "EnumEntryArray", ValueType: &schema.Struct{Name: "EnumEntry"}}},
		schema.Field{Declared: "Extends", Type: &schema.Slice{Alias: "EnumInfoPtrArray", ValueType: &schema.Pointer{Type: &schema.Struct{Name: "EnumInfo"}}}},
	},
}

type binaryClassHierarchy struct{}

func (*Hierarchy) Class() binary.Class {
	return (*binaryClassHierarchy)(nil)
}
func doEncodeHierarchy(e binary.Encoder, o *Hierarchy) error {
	if err := e.Value(&o.Root); err != nil {
		return err
	}
	return nil
}
func doDecodeHierarchy(d binary.Decoder, o *Hierarchy) error {
	if err := d.Value(&o.Root); err != nil {
		return err
	}
	return nil
}
func doSkipHierarchy(d binary.Decoder) error {
	if err := d.SkipValue((*AtomGroup)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassHierarchy) ID() binary.ID      { return binaryIDHierarchy }
func (*binaryClassHierarchy) New() binary.Object { return &Hierarchy{} }
func (*binaryClassHierarchy) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeHierarchy(e, obj.(*Hierarchy))
}
func (*binaryClassHierarchy) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Hierarchy{}
	return obj, doDecodeHierarchy(d, obj)
}
func (*binaryClassHierarchy) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeHierarchy(d, obj.(*Hierarchy))
}
func (*binaryClassHierarchy) Skip(d binary.Decoder) error { return doSkipHierarchy(d) }
func (*binaryClassHierarchy) Schema() *schema.Class       { return schemaHierarchy }

var schemaHierarchy = &schema.Class{
	TypeID: binaryIDHierarchy,
	Name:   "Hierarchy",
	Fields: []schema.Field{
		schema.Field{Declared: "Root", Type: &schema.Struct{Name: "AtomGroup"}},
	},
}

type binaryClassHierarchyId struct{}

func (*HierarchyId) Class() binary.Class {
	return (*binaryClassHierarchyId)(nil)
}
func doEncodeHierarchyId(e binary.Encoder, o *HierarchyId) error {
	if err := e.ID(o.ID); err != nil {
		return err
	}
	return nil
}
func doDecodeHierarchyId(d binary.Decoder, o *HierarchyId) error {
	if obj, err := d.ID(); err != nil {
		return err
	} else {
		o.ID = binary.ID(obj)
	}
	return nil
}
func doSkipHierarchyId(d binary.Decoder) error {
	if err := d.SkipID(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassHierarchyId) ID() binary.ID      { return binaryIDHierarchyId }
func (*binaryClassHierarchyId) New() binary.Object { return &HierarchyId{} }
func (*binaryClassHierarchyId) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeHierarchyId(e, obj.(*HierarchyId))
}
func (*binaryClassHierarchyId) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &HierarchyId{}
	return obj, doDecodeHierarchyId(d, obj)
}
func (*binaryClassHierarchyId) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeHierarchyId(d, obj.(*HierarchyId))
}
func (*binaryClassHierarchyId) Skip(d binary.Decoder) error { return doSkipHierarchyId(d) }
func (*binaryClassHierarchyId) Schema() *schema.Class       { return schemaHierarchyId }

var schemaHierarchyId = &schema.Class{
	TypeID: binaryIDHierarchyId,
	Name:   "HierarchyId",
	Fields: []schema.Field{
		schema.Field{Declared: "ID", Type: &schema.Primitive{Name: "binary.ID", Method: schema.ID}},
	},
}

type binaryClassImageInfo struct{}

func (*ImageInfo) Class() binary.Class {
	return (*binaryClassImageInfo)(nil)
}
func doEncodeImageInfo(e binary.Encoder, o *ImageInfo) error {
	if err := e.Int32(int32(o.Format)); err != nil {
		return err
	}
	if err := e.Uint32(o.Width); err != nil {
		return err
	}
	if err := e.Uint32(o.Height); err != nil {
		return err
	}
	if err := e.Value(&o.Data); err != nil {
		return err
	}
	return nil
}
func doDecodeImageInfo(d binary.Decoder, o *ImageInfo) error {
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Format = ImageFormat(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Width = uint32(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Height = uint32(obj)
	}
	if err := d.Value(&o.Data); err != nil {
		return err
	}
	return nil
}
func doSkipImageInfo(d binary.Decoder) error {
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if err := d.SkipValue((*BinaryId)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassImageInfo) ID() binary.ID      { return binaryIDImageInfo }
func (*binaryClassImageInfo) New() binary.Object { return &ImageInfo{} }
func (*binaryClassImageInfo) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeImageInfo(e, obj.(*ImageInfo))
}
func (*binaryClassImageInfo) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &ImageInfo{}
	return obj, doDecodeImageInfo(d, obj)
}
func (*binaryClassImageInfo) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeImageInfo(d, obj.(*ImageInfo))
}
func (*binaryClassImageInfo) Skip(d binary.Decoder) error { return doSkipImageInfo(d) }
func (*binaryClassImageInfo) Schema() *schema.Class       { return schemaImageInfo }

var schemaImageInfo = &schema.Class{
	TypeID: binaryIDImageInfo,
	Name:   "ImageInfo",
	Fields: []schema.Field{
		schema.Field{Declared: "Format", Type: &schema.Primitive{Name: "ImageFormat", Method: schema.Int32}},
		schema.Field{Declared: "Width", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
		schema.Field{Declared: "Height", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
		schema.Field{Declared: "Data", Type: &schema.Struct{Name: "BinaryId"}},
	},
}

type binaryClassImageInfoId struct{}

func (*ImageInfoId) Class() binary.Class {
	return (*binaryClassImageInfoId)(nil)
}
func doEncodeImageInfoId(e binary.Encoder, o *ImageInfoId) error {
	if err := e.ID(o.ID); err != nil {
		return err
	}
	return nil
}
func doDecodeImageInfoId(d binary.Decoder, o *ImageInfoId) error {
	if obj, err := d.ID(); err != nil {
		return err
	} else {
		o.ID = binary.ID(obj)
	}
	return nil
}
func doSkipImageInfoId(d binary.Decoder) error {
	if err := d.SkipID(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassImageInfoId) ID() binary.ID      { return binaryIDImageInfoId }
func (*binaryClassImageInfoId) New() binary.Object { return &ImageInfoId{} }
func (*binaryClassImageInfoId) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeImageInfoId(e, obj.(*ImageInfoId))
}
func (*binaryClassImageInfoId) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &ImageInfoId{}
	return obj, doDecodeImageInfoId(d, obj)
}
func (*binaryClassImageInfoId) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeImageInfoId(d, obj.(*ImageInfoId))
}
func (*binaryClassImageInfoId) Skip(d binary.Decoder) error { return doSkipImageInfoId(d) }
func (*binaryClassImageInfoId) Schema() *schema.Class       { return schemaImageInfoId }

var schemaImageInfoId = &schema.Class{
	TypeID: binaryIDImageInfoId,
	Name:   "ImageInfoId",
	Fields: []schema.Field{
		schema.Field{Declared: "ID", Type: &schema.Primitive{Name: "binary.ID", Method: schema.ID}},
	},
}

type binaryClassMapInfo struct{}

func (*MapInfo) Class() binary.Class {
	return (*binaryClassMapInfo)(nil)
}
func doEncodeMapInfo(e binary.Encoder, o *MapInfo) error {
	if err := e.String(o.Name); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Kind)); err != nil {
		return err
	}
	if o.KeyType != nil {
		if err := e.Object(o.KeyType); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	if o.ValueType != nil {
		if err := e.Object(o.ValueType); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	return nil
}
func doDecodeMapInfo(d binary.Decoder, o *MapInfo) error {
	if obj, err := d.String(); err != nil {
		return err
	} else {
		o.Name = string(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Kind = TypeKind(obj)
	}
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.KeyType = obj.(TypeInfo)
	} else {
		o.KeyType = nil
	}
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.ValueType = obj.(TypeInfo)
	} else {
		o.ValueType = nil
	}
	return nil
}
func doSkipMapInfo(d binary.Decoder) error {
	if err := d.SkipString(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassMapInfo) ID() binary.ID      { return binaryIDMapInfo }
func (*binaryClassMapInfo) New() binary.Object { return &MapInfo{} }
func (*binaryClassMapInfo) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeMapInfo(e, obj.(*MapInfo))
}
func (*binaryClassMapInfo) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &MapInfo{}
	return obj, doDecodeMapInfo(d, obj)
}
func (*binaryClassMapInfo) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeMapInfo(d, obj.(*MapInfo))
}
func (*binaryClassMapInfo) Skip(d binary.Decoder) error { return doSkipMapInfo(d) }
func (*binaryClassMapInfo) Schema() *schema.Class       { return schemaMapInfo }

var schemaMapInfo = &schema.Class{
	TypeID: binaryIDMapInfo,
	Name:   "MapInfo",
	Fields: []schema.Field{
		schema.Field{Declared: "Name", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		schema.Field{Declared: "Kind", Type: &schema.Primitive{Name: "TypeKind", Method: schema.Int32}},
		schema.Field{Declared: "KeyType", Type: &schema.Interface{Name: "TypeInfo"}},
		schema.Field{Declared: "ValueType", Type: &schema.Interface{Name: "TypeInfo"}},
	},
}

type binaryClassMemoryRange struct{}

func (*MemoryRange) Class() binary.Class {
	return (*binaryClassMemoryRange)(nil)
}
func doEncodeMemoryRange(e binary.Encoder, o *MemoryRange) error {
	if err := e.Uint64(o.Base); err != nil {
		return err
	}
	if err := e.Uint64(o.Size); err != nil {
		return err
	}
	return nil
}
func doDecodeMemoryRange(d binary.Decoder, o *MemoryRange) error {
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.Base = uint64(obj)
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.Size = uint64(obj)
	}
	return nil
}
func doSkipMemoryRange(d binary.Decoder) error {
	if _, err := d.Uint64(); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassMemoryRange) ID() binary.ID      { return binaryIDMemoryRange }
func (*binaryClassMemoryRange) New() binary.Object { return &MemoryRange{} }
func (*binaryClassMemoryRange) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeMemoryRange(e, obj.(*MemoryRange))
}
func (*binaryClassMemoryRange) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &MemoryRange{}
	return obj, doDecodeMemoryRange(d, obj)
}
func (*binaryClassMemoryRange) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeMemoryRange(d, obj.(*MemoryRange))
}
func (*binaryClassMemoryRange) Skip(d binary.Decoder) error { return doSkipMemoryRange(d) }
func (*binaryClassMemoryRange) Schema() *schema.Class       { return schemaMemoryRange }

var schemaMemoryRange = &schema.Class{
	TypeID: binaryIDMemoryRange,
	Name:   "MemoryRange",
	Fields: []schema.Field{
		schema.Field{Declared: "Base", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
		schema.Field{Declared: "Size", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
	},
}

type binaryClassMemoryInfo struct{}

func (*MemoryInfo) Class() binary.Class {
	return (*binaryClassMemoryInfo)(nil)
}
func doEncodeMemoryInfo(e binary.Encoder, o *MemoryInfo) error {
	if err := e.Uint32(uint32(len(o.Data))); err != nil {
		return err
	}
	if err := e.Data(o.Data); err != nil {
		return err
	}
	if err := e.Uint32(uint32(len(o.Stale))); err != nil {
		return err
	}
	for i := range o.Stale {
		if err := e.Value(&o.Stale[i]); err != nil {
			return err
		}
	}
	if err := e.Uint32(uint32(len(o.Current))); err != nil {
		return err
	}
	for i := range o.Current {
		if err := e.Value(&o.Current[i]); err != nil {
			return err
		}
	}
	if err := e.Uint32(uint32(len(o.Unknown))); err != nil {
		return err
	}
	for i := range o.Unknown {
		if err := e.Value(&o.Unknown[i]); err != nil {
			return err
		}
	}
	return nil
}
func doDecodeMemoryInfo(d binary.Decoder, o *MemoryInfo) error {
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Data = make(U8Array, count)
		if err := d.Data(o.Data); err != nil {
			return err
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Stale = make(MemoryRangeArray, count)
		for i := range o.Stale {
			if err := d.Value(&o.Stale[i]); err != nil {
				return err
			}
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Current = make(MemoryRangeArray, count)
		for i := range o.Current {
			if err := d.Value(&o.Current[i]); err != nil {
				return err
			}
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Unknown = make(MemoryRangeArray, count)
		for i := range o.Unknown {
			if err := d.Value(&o.Unknown[i]); err != nil {
				return err
			}
		}
	}
	return nil
}
func doSkipMemoryInfo(d binary.Decoder) error {
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		if err := d.Skip(count); err != nil {
			return err
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if err := d.SkipValue((*MemoryRange)(nil)); err != nil {
				return err
			}
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if err := d.SkipValue((*MemoryRange)(nil)); err != nil {
				return err
			}
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if err := d.SkipValue((*MemoryRange)(nil)); err != nil {
				return err
			}
		}
	}
	return nil
}
func (*binaryClassMemoryInfo) ID() binary.ID      { return binaryIDMemoryInfo }
func (*binaryClassMemoryInfo) New() binary.Object { return &MemoryInfo{} }
func (*binaryClassMemoryInfo) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeMemoryInfo(e, obj.(*MemoryInfo))
}
func (*binaryClassMemoryInfo) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &MemoryInfo{}
	return obj, doDecodeMemoryInfo(d, obj)
}
func (*binaryClassMemoryInfo) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeMemoryInfo(d, obj.(*MemoryInfo))
}
func (*binaryClassMemoryInfo) Skip(d binary.Decoder) error { return doSkipMemoryInfo(d) }
func (*binaryClassMemoryInfo) Schema() *schema.Class       { return schemaMemoryInfo }

var schemaMemoryInfo = &schema.Class{
	TypeID: binaryIDMemoryInfo,
	Name:   "MemoryInfo",
	Fields: []schema.Field{
		schema.Field{Declared: "Data", Type: &schema.Slice{Alias: "U8Array", ValueType: &schema.Primitive{Name: "uint8", Method: schema.Uint8}}},
		schema.Field{Declared: "Stale", Type: &schema.Slice{Alias: "MemoryRangeArray", ValueType: &schema.Struct{Name: "MemoryRange"}}},
		schema.Field{Declared: "Current", Type: &schema.Slice{Alias: "MemoryRangeArray", ValueType: &schema.Struct{Name: "MemoryRange"}}},
		schema.Field{Declared: "Unknown", Type: &schema.Slice{Alias: "MemoryRangeArray", ValueType: &schema.Struct{Name: "MemoryRange"}}},
	},
}

type binaryClassMemoryInfoId struct{}

func (*MemoryInfoId) Class() binary.Class {
	return (*binaryClassMemoryInfoId)(nil)
}
func doEncodeMemoryInfoId(e binary.Encoder, o *MemoryInfoId) error {
	if err := e.ID(o.ID); err != nil {
		return err
	}
	return nil
}
func doDecodeMemoryInfoId(d binary.Decoder, o *MemoryInfoId) error {
	if obj, err := d.ID(); err != nil {
		return err
	} else {
		o.ID = binary.ID(obj)
	}
	return nil
}
func doSkipMemoryInfoId(d binary.Decoder) error {
	if err := d.SkipID(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassMemoryInfoId) ID() binary.ID      { return binaryIDMemoryInfoId }
func (*binaryClassMemoryInfoId) New() binary.Object { return &MemoryInfoId{} }
func (*binaryClassMemoryInfoId) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeMemoryInfoId(e, obj.(*MemoryInfoId))
}
func (*binaryClassMemoryInfoId) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &MemoryInfoId{}
	return obj, doDecodeMemoryInfoId(d, obj)
}
func (*binaryClassMemoryInfoId) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeMemoryInfoId(d, obj.(*MemoryInfoId))
}
func (*binaryClassMemoryInfoId) Skip(d binary.Decoder) error { return doSkipMemoryInfoId(d) }
func (*binaryClassMemoryInfoId) Schema() *schema.Class       { return schemaMemoryInfoId }

var schemaMemoryInfoId = &schema.Class{
	TypeID: binaryIDMemoryInfoId,
	Name:   "MemoryInfoId",
	Fields: []schema.Field{
		schema.Field{Declared: "ID", Type: &schema.Primitive{Name: "binary.ID", Method: schema.ID}},
	},
}

type binaryClassRenderSettings struct{}

func (*RenderSettings) Class() binary.Class {
	return (*binaryClassRenderSettings)(nil)
}
func doEncodeRenderSettings(e binary.Encoder, o *RenderSettings) error {
	if err := e.Uint32(o.MaxWidth); err != nil {
		return err
	}
	if err := e.Uint32(o.MaxHeight); err != nil {
		return err
	}
	if err := e.Bool(o.Wireframe); err != nil {
		return err
	}
	return nil
}
func doDecodeRenderSettings(d binary.Decoder, o *RenderSettings) error {
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.MaxWidth = uint32(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.MaxHeight = uint32(obj)
	}
	if obj, err := d.Bool(); err != nil {
		return err
	} else {
		o.Wireframe = bool(obj)
	}
	return nil
}
func doSkipRenderSettings(d binary.Decoder) error {
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Bool(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassRenderSettings) ID() binary.ID      { return binaryIDRenderSettings }
func (*binaryClassRenderSettings) New() binary.Object { return &RenderSettings{} }
func (*binaryClassRenderSettings) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeRenderSettings(e, obj.(*RenderSettings))
}
func (*binaryClassRenderSettings) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &RenderSettings{}
	return obj, doDecodeRenderSettings(d, obj)
}
func (*binaryClassRenderSettings) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeRenderSettings(d, obj.(*RenderSettings))
}
func (*binaryClassRenderSettings) Skip(d binary.Decoder) error { return doSkipRenderSettings(d) }
func (*binaryClassRenderSettings) Schema() *schema.Class       { return schemaRenderSettings }

var schemaRenderSettings = &schema.Class{
	TypeID: binaryIDRenderSettings,
	Name:   "RenderSettings",
	Fields: []schema.Field{
		schema.Field{Declared: "MaxWidth", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
		schema.Field{Declared: "MaxHeight", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
		schema.Field{Declared: "Wireframe", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
	},
}

type binaryClassSchema struct{}

func (*Schema) Class() binary.Class {
	return (*binaryClassSchema)(nil)
}
func doEncodeSchema(e binary.Encoder, o *Schema) error {
	if err := e.Uint32(uint32(len(o.Atoms))); err != nil {
		return err
	}
	for i := range o.Atoms {
		if err := e.Value(&o.Atoms[i]); err != nil {
			return err
		}
	}
	if err := e.Uint32(uint32(len(o.Apis))); err != nil {
		return err
	}
	for i := range o.Apis {
		if err := e.Value(&o.Apis[i]); err != nil {
			return err
		}
	}
	return nil
}
func doDecodeSchema(d binary.Decoder, o *Schema) error {
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Atoms = make(AtomInfoArray, count)
		for i := range o.Atoms {
			if err := d.Value(&o.Atoms[i]); err != nil {
				return err
			}
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Apis = make(ApiSchemaArray, count)
		for i := range o.Apis {
			if err := d.Value(&o.Apis[i]); err != nil {
				return err
			}
		}
	}
	return nil
}
func doSkipSchema(d binary.Decoder) error {
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if err := d.SkipValue((*AtomInfo)(nil)); err != nil {
				return err
			}
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if err := d.SkipValue((*ApiSchema)(nil)); err != nil {
				return err
			}
		}
	}
	return nil
}
func (*binaryClassSchema) ID() binary.ID      { return binaryIDSchema }
func (*binaryClassSchema) New() binary.Object { return &Schema{} }
func (*binaryClassSchema) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeSchema(e, obj.(*Schema))
}
func (*binaryClassSchema) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Schema{}
	return obj, doDecodeSchema(d, obj)
}
func (*binaryClassSchema) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeSchema(d, obj.(*Schema))
}
func (*binaryClassSchema) Skip(d binary.Decoder) error { return doSkipSchema(d) }
func (*binaryClassSchema) Schema() *schema.Class       { return schemaSchema }

var schemaSchema = &schema.Class{
	TypeID: binaryIDSchema,
	Name:   "Schema",
	Fields: []schema.Field{
		schema.Field{Declared: "Atoms", Type: &schema.Slice{Alias: "AtomInfoArray", ValueType: &schema.Struct{Name: "AtomInfo"}}},
		schema.Field{Declared: "Apis", Type: &schema.Slice{Alias: "ApiSchemaArray", ValueType: &schema.Struct{Name: "ApiSchema"}}},
	},
}

type binaryClassSimpleInfo struct{}

func (*SimpleInfo) Class() binary.Class {
	return (*binaryClassSimpleInfo)(nil)
}
func doEncodeSimpleInfo(e binary.Encoder, o *SimpleInfo) error {
	if err := e.String(o.Name); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Kind)); err != nil {
		return err
	}
	return nil
}
func doDecodeSimpleInfo(d binary.Decoder, o *SimpleInfo) error {
	if obj, err := d.String(); err != nil {
		return err
	} else {
		o.Name = string(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Kind = TypeKind(obj)
	}
	return nil
}
func doSkipSimpleInfo(d binary.Decoder) error {
	if err := d.SkipString(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassSimpleInfo) ID() binary.ID      { return binaryIDSimpleInfo }
func (*binaryClassSimpleInfo) New() binary.Object { return &SimpleInfo{} }
func (*binaryClassSimpleInfo) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeSimpleInfo(e, obj.(*SimpleInfo))
}
func (*binaryClassSimpleInfo) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &SimpleInfo{}
	return obj, doDecodeSimpleInfo(d, obj)
}
func (*binaryClassSimpleInfo) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeSimpleInfo(d, obj.(*SimpleInfo))
}
func (*binaryClassSimpleInfo) Skip(d binary.Decoder) error { return doSkipSimpleInfo(d) }
func (*binaryClassSimpleInfo) Schema() *schema.Class       { return schemaSimpleInfo }

var schemaSimpleInfo = &schema.Class{
	TypeID: binaryIDSimpleInfo,
	Name:   "SimpleInfo",
	Fields: []schema.Field{
		schema.Field{Declared: "Name", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		schema.Field{Declared: "Kind", Type: &schema.Primitive{Name: "TypeKind", Method: schema.Int32}},
	},
}

type binaryClassStaticArrayInfo struct{}

func (*StaticArrayInfo) Class() binary.Class {
	return (*binaryClassStaticArrayInfo)(nil)
}
func doEncodeStaticArrayInfo(e binary.Encoder, o *StaticArrayInfo) error {
	if err := e.String(o.Name); err != nil {
		return err
	}
	if err := e.Int32(int32(o.Kind)); err != nil {
		return err
	}
	if o.ElementType != nil {
		if err := e.Object(o.ElementType); err != nil {
			return err
		}
	} else if err := e.Object(nil); err != nil {
		return err
	}
	if err := e.Uint32(o.Size); err != nil {
		return err
	}
	return nil
}
func doDecodeStaticArrayInfo(d binary.Decoder, o *StaticArrayInfo) error {
	if obj, err := d.String(); err != nil {
		return err
	} else {
		o.Name = string(obj)
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Kind = TypeKind(obj)
	}
	if obj, err := d.Object(); err != nil {
		return err
	} else if obj != nil {
		o.ElementType = obj.(TypeInfo)
	} else {
		o.ElementType = nil
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Size = uint32(obj)
	}
	return nil
}
func doSkipStaticArrayInfo(d binary.Decoder) error {
	if err := d.SkipString(); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	if _, err := d.SkipObject(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassStaticArrayInfo) ID() binary.ID      { return binaryIDStaticArrayInfo }
func (*binaryClassStaticArrayInfo) New() binary.Object { return &StaticArrayInfo{} }
func (*binaryClassStaticArrayInfo) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeStaticArrayInfo(e, obj.(*StaticArrayInfo))
}
func (*binaryClassStaticArrayInfo) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &StaticArrayInfo{}
	return obj, doDecodeStaticArrayInfo(d, obj)
}
func (*binaryClassStaticArrayInfo) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeStaticArrayInfo(d, obj.(*StaticArrayInfo))
}
func (*binaryClassStaticArrayInfo) Skip(d binary.Decoder) error { return doSkipStaticArrayInfo(d) }
func (*binaryClassStaticArrayInfo) Schema() *schema.Class       { return schemaStaticArrayInfo }

var schemaStaticArrayInfo = &schema.Class{
	TypeID: binaryIDStaticArrayInfo,
	Name:   "StaticArrayInfo",
	Fields: []schema.Field{
		schema.Field{Declared: "Name", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		schema.Field{Declared: "Kind", Type: &schema.Primitive{Name: "TypeKind", Method: schema.Int32}},
		schema.Field{Declared: "ElementType", Type: &schema.Interface{Name: "TypeInfo"}},
		schema.Field{Declared: "Size", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
	},
}

type binaryClassTimingInfo struct{}

func (*TimingInfo) Class() binary.Class {
	return (*binaryClassTimingInfo)(nil)
}
func doEncodeTimingInfo(e binary.Encoder, o *TimingInfo) error {
	if err := e.Uint32(uint32(len(o.PerCommand))); err != nil {
		return err
	}
	for i := range o.PerCommand {
		if err := e.Value(&o.PerCommand[i]); err != nil {
			return err
		}
	}
	if err := e.Uint32(uint32(len(o.PerDrawCall))); err != nil {
		return err
	}
	for i := range o.PerDrawCall {
		if err := e.Value(&o.PerDrawCall[i]); err != nil {
			return err
		}
	}
	if err := e.Uint32(uint32(len(o.PerFrame))); err != nil {
		return err
	}
	for i := range o.PerFrame {
		if err := e.Value(&o.PerFrame[i]); err != nil {
			return err
		}
	}
	return nil
}
func doDecodeTimingInfo(d binary.Decoder, o *TimingInfo) error {
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.PerCommand = make(AtomTimerArray, count)
		for i := range o.PerCommand {
			if err := d.Value(&o.PerCommand[i]); err != nil {
				return err
			}
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.PerDrawCall = make(AtomRangeTimerArray, count)
		for i := range o.PerDrawCall {
			if err := d.Value(&o.PerDrawCall[i]); err != nil {
				return err
			}
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.PerFrame = make(AtomRangeTimerArray, count)
		for i := range o.PerFrame {
			if err := d.Value(&o.PerFrame[i]); err != nil {
				return err
			}
		}
	}
	return nil
}
func doSkipTimingInfo(d binary.Decoder) error {
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if err := d.SkipValue((*AtomTimer)(nil)); err != nil {
				return err
			}
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if err := d.SkipValue((*AtomRangeTimer)(nil)); err != nil {
				return err
			}
		}
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if err := d.SkipValue((*AtomRangeTimer)(nil)); err != nil {
				return err
			}
		}
	}
	return nil
}
func (*binaryClassTimingInfo) ID() binary.ID      { return binaryIDTimingInfo }
func (*binaryClassTimingInfo) New() binary.Object { return &TimingInfo{} }
func (*binaryClassTimingInfo) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeTimingInfo(e, obj.(*TimingInfo))
}
func (*binaryClassTimingInfo) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &TimingInfo{}
	return obj, doDecodeTimingInfo(d, obj)
}
func (*binaryClassTimingInfo) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeTimingInfo(d, obj.(*TimingInfo))
}
func (*binaryClassTimingInfo) Skip(d binary.Decoder) error { return doSkipTimingInfo(d) }
func (*binaryClassTimingInfo) Schema() *schema.Class       { return schemaTimingInfo }

var schemaTimingInfo = &schema.Class{
	TypeID: binaryIDTimingInfo,
	Name:   "TimingInfo",
	Fields: []schema.Field{
		schema.Field{Declared: "PerCommand", Type: &schema.Slice{Alias: "AtomTimerArray", ValueType: &schema.Struct{Name: "AtomTimer"}}},
		schema.Field{Declared: "PerDrawCall", Type: &schema.Slice{Alias: "AtomRangeTimerArray", ValueType: &schema.Struct{Name: "AtomRangeTimer"}}},
		schema.Field{Declared: "PerFrame", Type: &schema.Slice{Alias: "AtomRangeTimerArray", ValueType: &schema.Struct{Name: "AtomRangeTimer"}}},
	},
}

type binaryClassTimingInfoId struct{}

func (*TimingInfoId) Class() binary.Class {
	return (*binaryClassTimingInfoId)(nil)
}
func doEncodeTimingInfoId(e binary.Encoder, o *TimingInfoId) error {
	if err := e.ID(o.ID); err != nil {
		return err
	}
	return nil
}
func doDecodeTimingInfoId(d binary.Decoder, o *TimingInfoId) error {
	if obj, err := d.ID(); err != nil {
		return err
	} else {
		o.ID = binary.ID(obj)
	}
	return nil
}
func doSkipTimingInfoId(d binary.Decoder) error {
	if err := d.SkipID(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassTimingInfoId) ID() binary.ID      { return binaryIDTimingInfoId }
func (*binaryClassTimingInfoId) New() binary.Object { return &TimingInfoId{} }
func (*binaryClassTimingInfoId) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeTimingInfoId(e, obj.(*TimingInfoId))
}
func (*binaryClassTimingInfoId) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &TimingInfoId{}
	return obj, doDecodeTimingInfoId(d, obj)
}
func (*binaryClassTimingInfoId) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeTimingInfoId(d, obj.(*TimingInfoId))
}
func (*binaryClassTimingInfoId) Skip(d binary.Decoder) error { return doSkipTimingInfoId(d) }
func (*binaryClassTimingInfoId) Schema() *schema.Class       { return schemaTimingInfoId }

var schemaTimingInfoId = &schema.Class{
	TypeID: binaryIDTimingInfoId,
	Name:   "TimingInfoId",
	Fields: []schema.Field{
		schema.Field{Declared: "ID", Type: &schema.Primitive{Name: "binary.ID", Method: schema.ID}},
	},
}

type binaryClasscallGetCaptures struct{}

func (*callGetCaptures) Class() binary.Class {
	return (*binaryClasscallGetCaptures)(nil)
}
func doEncodecallGetCaptures(e binary.Encoder, o *callGetCaptures) error {
	return nil
}
func doDecodecallGetCaptures(d binary.Decoder, o *callGetCaptures) error {
	return nil
}
func doSkipcallGetCaptures(d binary.Decoder) error {
	return nil
}
func (*binaryClasscallGetCaptures) ID() binary.ID      { return binaryIDcallGetCaptures }
func (*binaryClasscallGetCaptures) New() binary.Object { return &callGetCaptures{} }
func (*binaryClasscallGetCaptures) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodecallGetCaptures(e, obj.(*callGetCaptures))
}
func (*binaryClasscallGetCaptures) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &callGetCaptures{}
	return obj, doDecodecallGetCaptures(d, obj)
}
func (*binaryClasscallGetCaptures) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodecallGetCaptures(d, obj.(*callGetCaptures))
}
func (*binaryClasscallGetCaptures) Skip(d binary.Decoder) error { return doSkipcallGetCaptures(d) }
func (*binaryClasscallGetCaptures) Schema() *schema.Class       { return schemacallGetCaptures }

var schemacallGetCaptures = &schema.Class{
	TypeID: binaryIDcallGetCaptures,
	Name:   "callGetCaptures",
	Fields: []schema.Field{},
}

type binaryClasscallGetDevices struct{}

func (*callGetDevices) Class() binary.Class {
	return (*binaryClasscallGetDevices)(nil)
}
func doEncodecallGetDevices(e binary.Encoder, o *callGetDevices) error {
	return nil
}
func doDecodecallGetDevices(d binary.Decoder, o *callGetDevices) error {
	return nil
}
func doSkipcallGetDevices(d binary.Decoder) error {
	return nil
}
func (*binaryClasscallGetDevices) ID() binary.ID      { return binaryIDcallGetDevices }
func (*binaryClasscallGetDevices) New() binary.Object { return &callGetDevices{} }
func (*binaryClasscallGetDevices) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodecallGetDevices(e, obj.(*callGetDevices))
}
func (*binaryClasscallGetDevices) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &callGetDevices{}
	return obj, doDecodecallGetDevices(d, obj)
}
func (*binaryClasscallGetDevices) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodecallGetDevices(d, obj.(*callGetDevices))
}
func (*binaryClasscallGetDevices) Skip(d binary.Decoder) error { return doSkipcallGetDevices(d) }
func (*binaryClasscallGetDevices) Schema() *schema.Class       { return schemacallGetDevices }

var schemacallGetDevices = &schema.Class{
	TypeID: binaryIDcallGetDevices,
	Name:   "callGetDevices",
	Fields: []schema.Field{},
}

type binaryClasscallGetFramebufferColor struct{}

func (*callGetFramebufferColor) Class() binary.Class {
	return (*binaryClasscallGetFramebufferColor)(nil)
}
func doEncodecallGetFramebufferColor(e binary.Encoder, o *callGetFramebufferColor) error {
	if err := e.Value(&o.device); err != nil {
		return err
	}
	if err := e.Value(&o.capture); err != nil {
		return err
	}
	if err := e.Value(&o.api); err != nil {
		return err
	}
	if err := e.Uint64(o.after); err != nil {
		return err
	}
	if err := e.Value(&o.settings); err != nil {
		return err
	}
	return nil
}
func doDecodecallGetFramebufferColor(d binary.Decoder, o *callGetFramebufferColor) error {
	if err := d.Value(&o.device); err != nil {
		return err
	}
	if err := d.Value(&o.capture); err != nil {
		return err
	}
	if err := d.Value(&o.api); err != nil {
		return err
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.after = uint64(obj)
	}
	if err := d.Value(&o.settings); err != nil {
		return err
	}
	return nil
}
func doSkipcallGetFramebufferColor(d binary.Decoder) error {
	if err := d.SkipValue((*DeviceId)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*CaptureId)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*ApiId)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	if err := d.SkipValue((*RenderSettings)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClasscallGetFramebufferColor) ID() binary.ID      { return binaryIDcallGetFramebufferColor }
func (*binaryClasscallGetFramebufferColor) New() binary.Object { return &callGetFramebufferColor{} }
func (*binaryClasscallGetFramebufferColor) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodecallGetFramebufferColor(e, obj.(*callGetFramebufferColor))
}
func (*binaryClasscallGetFramebufferColor) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &callGetFramebufferColor{}
	return obj, doDecodecallGetFramebufferColor(d, obj)
}
func (*binaryClasscallGetFramebufferColor) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodecallGetFramebufferColor(d, obj.(*callGetFramebufferColor))
}
func (*binaryClasscallGetFramebufferColor) Skip(d binary.Decoder) error {
	return doSkipcallGetFramebufferColor(d)
}
func (*binaryClasscallGetFramebufferColor) Schema() *schema.Class {
	return schemacallGetFramebufferColor
}

var schemacallGetFramebufferColor = &schema.Class{
	TypeID: binaryIDcallGetFramebufferColor,
	Name:   "callGetFramebufferColor",
	Fields: []schema.Field{
		schema.Field{Declared: "device", Type: &schema.Struct{Name: "DeviceId"}},
		schema.Field{Declared: "capture", Type: &schema.Struct{Name: "CaptureId"}},
		schema.Field{Declared: "api", Type: &schema.Struct{Name: "ApiId"}},
		schema.Field{Declared: "after", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
		schema.Field{Declared: "settings", Type: &schema.Struct{Name: "RenderSettings"}},
	},
}

type binaryClasscallGetFramebufferDepth struct{}

func (*callGetFramebufferDepth) Class() binary.Class {
	return (*binaryClasscallGetFramebufferDepth)(nil)
}
func doEncodecallGetFramebufferDepth(e binary.Encoder, o *callGetFramebufferDepth) error {
	if err := e.Value(&o.device); err != nil {
		return err
	}
	if err := e.Value(&o.capture); err != nil {
		return err
	}
	if err := e.Value(&o.api); err != nil {
		return err
	}
	if err := e.Uint64(o.after); err != nil {
		return err
	}
	return nil
}
func doDecodecallGetFramebufferDepth(d binary.Decoder, o *callGetFramebufferDepth) error {
	if err := d.Value(&o.device); err != nil {
		return err
	}
	if err := d.Value(&o.capture); err != nil {
		return err
	}
	if err := d.Value(&o.api); err != nil {
		return err
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.after = uint64(obj)
	}
	return nil
}
func doSkipcallGetFramebufferDepth(d binary.Decoder) error {
	if err := d.SkipValue((*DeviceId)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*CaptureId)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*ApiId)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClasscallGetFramebufferDepth) ID() binary.ID      { return binaryIDcallGetFramebufferDepth }
func (*binaryClasscallGetFramebufferDepth) New() binary.Object { return &callGetFramebufferDepth{} }
func (*binaryClasscallGetFramebufferDepth) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodecallGetFramebufferDepth(e, obj.(*callGetFramebufferDepth))
}
func (*binaryClasscallGetFramebufferDepth) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &callGetFramebufferDepth{}
	return obj, doDecodecallGetFramebufferDepth(d, obj)
}
func (*binaryClasscallGetFramebufferDepth) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodecallGetFramebufferDepth(d, obj.(*callGetFramebufferDepth))
}
func (*binaryClasscallGetFramebufferDepth) Skip(d binary.Decoder) error {
	return doSkipcallGetFramebufferDepth(d)
}
func (*binaryClasscallGetFramebufferDepth) Schema() *schema.Class {
	return schemacallGetFramebufferDepth
}

var schemacallGetFramebufferDepth = &schema.Class{
	TypeID: binaryIDcallGetFramebufferDepth,
	Name:   "callGetFramebufferDepth",
	Fields: []schema.Field{
		schema.Field{Declared: "device", Type: &schema.Struct{Name: "DeviceId"}},
		schema.Field{Declared: "capture", Type: &schema.Struct{Name: "CaptureId"}},
		schema.Field{Declared: "api", Type: &schema.Struct{Name: "ApiId"}},
		schema.Field{Declared: "after", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
	},
}

type binaryClasscallGetHierarchy struct{}

func (*callGetHierarchy) Class() binary.Class {
	return (*binaryClasscallGetHierarchy)(nil)
}
func doEncodecallGetHierarchy(e binary.Encoder, o *callGetHierarchy) error {
	if err := e.Value(&o.capture); err != nil {
		return err
	}
	return nil
}
func doDecodecallGetHierarchy(d binary.Decoder, o *callGetHierarchy) error {
	if err := d.Value(&o.capture); err != nil {
		return err
	}
	return nil
}
func doSkipcallGetHierarchy(d binary.Decoder) error {
	if err := d.SkipValue((*CaptureId)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClasscallGetHierarchy) ID() binary.ID      { return binaryIDcallGetHierarchy }
func (*binaryClasscallGetHierarchy) New() binary.Object { return &callGetHierarchy{} }
func (*binaryClasscallGetHierarchy) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodecallGetHierarchy(e, obj.(*callGetHierarchy))
}
func (*binaryClasscallGetHierarchy) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &callGetHierarchy{}
	return obj, doDecodecallGetHierarchy(d, obj)
}
func (*binaryClasscallGetHierarchy) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodecallGetHierarchy(d, obj.(*callGetHierarchy))
}
func (*binaryClasscallGetHierarchy) Skip(d binary.Decoder) error { return doSkipcallGetHierarchy(d) }
func (*binaryClasscallGetHierarchy) Schema() *schema.Class       { return schemacallGetHierarchy }

var schemacallGetHierarchy = &schema.Class{
	TypeID: binaryIDcallGetHierarchy,
	Name:   "callGetHierarchy",
	Fields: []schema.Field{
		schema.Field{Declared: "capture", Type: &schema.Struct{Name: "CaptureId"}},
	},
}

type binaryClasscallGetMemoryInfo struct{}

func (*callGetMemoryInfo) Class() binary.Class {
	return (*binaryClasscallGetMemoryInfo)(nil)
}
func doEncodecallGetMemoryInfo(e binary.Encoder, o *callGetMemoryInfo) error {
	if err := e.Value(&o.capture); err != nil {
		return err
	}
	if err := e.Uint64(o.after); err != nil {
		return err
	}
	if err := e.Value(&o.rng); err != nil {
		return err
	}
	return nil
}
func doDecodecallGetMemoryInfo(d binary.Decoder, o *callGetMemoryInfo) error {
	if err := d.Value(&o.capture); err != nil {
		return err
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.after = uint64(obj)
	}
	if err := d.Value(&o.rng); err != nil {
		return err
	}
	return nil
}
func doSkipcallGetMemoryInfo(d binary.Decoder) error {
	if err := d.SkipValue((*CaptureId)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	if err := d.SkipValue((*MemoryRange)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClasscallGetMemoryInfo) ID() binary.ID      { return binaryIDcallGetMemoryInfo }
func (*binaryClasscallGetMemoryInfo) New() binary.Object { return &callGetMemoryInfo{} }
func (*binaryClasscallGetMemoryInfo) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodecallGetMemoryInfo(e, obj.(*callGetMemoryInfo))
}
func (*binaryClasscallGetMemoryInfo) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &callGetMemoryInfo{}
	return obj, doDecodecallGetMemoryInfo(d, obj)
}
func (*binaryClasscallGetMemoryInfo) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodecallGetMemoryInfo(d, obj.(*callGetMemoryInfo))
}
func (*binaryClasscallGetMemoryInfo) Skip(d binary.Decoder) error { return doSkipcallGetMemoryInfo(d) }
func (*binaryClasscallGetMemoryInfo) Schema() *schema.Class       { return schemacallGetMemoryInfo }

var schemacallGetMemoryInfo = &schema.Class{
	TypeID: binaryIDcallGetMemoryInfo,
	Name:   "callGetMemoryInfo",
	Fields: []schema.Field{
		schema.Field{Declared: "capture", Type: &schema.Struct{Name: "CaptureId"}},
		schema.Field{Declared: "after", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
		schema.Field{Declared: "rng", Type: &schema.Struct{Name: "MemoryRange"}},
	},
}

type binaryClasscallGetState struct{}

func (*callGetState) Class() binary.Class {
	return (*binaryClasscallGetState)(nil)
}
func doEncodecallGetState(e binary.Encoder, o *callGetState) error {
	if err := e.Value(&o.capture); err != nil {
		return err
	}
	if err := e.Uint64(o.after); err != nil {
		return err
	}
	return nil
}
func doDecodecallGetState(d binary.Decoder, o *callGetState) error {
	if err := d.Value(&o.capture); err != nil {
		return err
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.after = uint64(obj)
	}
	return nil
}
func doSkipcallGetState(d binary.Decoder) error {
	if err := d.SkipValue((*CaptureId)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClasscallGetState) ID() binary.ID      { return binaryIDcallGetState }
func (*binaryClasscallGetState) New() binary.Object { return &callGetState{} }
func (*binaryClasscallGetState) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodecallGetState(e, obj.(*callGetState))
}
func (*binaryClasscallGetState) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &callGetState{}
	return obj, doDecodecallGetState(d, obj)
}
func (*binaryClasscallGetState) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodecallGetState(d, obj.(*callGetState))
}
func (*binaryClasscallGetState) Skip(d binary.Decoder) error { return doSkipcallGetState(d) }
func (*binaryClasscallGetState) Schema() *schema.Class       { return schemacallGetState }

var schemacallGetState = &schema.Class{
	TypeID: binaryIDcallGetState,
	Name:   "callGetState",
	Fields: []schema.Field{
		schema.Field{Declared: "capture", Type: &schema.Struct{Name: "CaptureId"}},
		schema.Field{Declared: "after", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
	},
}

type binaryClasscallGetTimingInfo struct{}

func (*callGetTimingInfo) Class() binary.Class {
	return (*binaryClasscallGetTimingInfo)(nil)
}
func doEncodecallGetTimingInfo(e binary.Encoder, o *callGetTimingInfo) error {
	if err := e.Value(&o.device); err != nil {
		return err
	}
	if err := e.Value(&o.capture); err != nil {
		return err
	}
	if err := e.Int32(int32(o.mask)); err != nil {
		return err
	}
	return nil
}
func doDecodecallGetTimingInfo(d binary.Decoder, o *callGetTimingInfo) error {
	if err := d.Value(&o.device); err != nil {
		return err
	}
	if err := d.Value(&o.capture); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.mask = TimingMask(obj)
	}
	return nil
}
func doSkipcallGetTimingInfo(d binary.Decoder) error {
	if err := d.SkipValue((*DeviceId)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*CaptureId)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClasscallGetTimingInfo) ID() binary.ID      { return binaryIDcallGetTimingInfo }
func (*binaryClasscallGetTimingInfo) New() binary.Object { return &callGetTimingInfo{} }
func (*binaryClasscallGetTimingInfo) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodecallGetTimingInfo(e, obj.(*callGetTimingInfo))
}
func (*binaryClasscallGetTimingInfo) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &callGetTimingInfo{}
	return obj, doDecodecallGetTimingInfo(d, obj)
}
func (*binaryClasscallGetTimingInfo) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodecallGetTimingInfo(d, obj.(*callGetTimingInfo))
}
func (*binaryClasscallGetTimingInfo) Skip(d binary.Decoder) error { return doSkipcallGetTimingInfo(d) }
func (*binaryClasscallGetTimingInfo) Schema() *schema.Class       { return schemacallGetTimingInfo }

var schemacallGetTimingInfo = &schema.Class{
	TypeID: binaryIDcallGetTimingInfo,
	Name:   "callGetTimingInfo",
	Fields: []schema.Field{
		schema.Field{Declared: "device", Type: &schema.Struct{Name: "DeviceId"}},
		schema.Field{Declared: "capture", Type: &schema.Struct{Name: "CaptureId"}},
		schema.Field{Declared: "mask", Type: &schema.Primitive{Name: "TimingMask", Method: schema.Int32}},
	},
}

type binaryClasscallImport struct{}

func (*callImport) Class() binary.Class {
	return (*binaryClasscallImport)(nil)
}
func doEncodecallImport(e binary.Encoder, o *callImport) error {
	if err := e.String(o.name); err != nil {
		return err
	}
	if err := e.Uint32(uint32(len(o.Data))); err != nil {
		return err
	}
	if err := e.Data(o.Data); err != nil {
		return err
	}
	return nil
}
func doDecodecallImport(d binary.Decoder, o *callImport) error {
	if obj, err := d.String(); err != nil {
		return err
	} else {
		o.name = string(obj)
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Data = make(U8Array, count)
		if err := d.Data(o.Data); err != nil {
			return err
		}
	}
	return nil
}
func doSkipcallImport(d binary.Decoder) error {
	if err := d.SkipString(); err != nil {
		return err
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		if err := d.Skip(count); err != nil {
			return err
		}
	}
	return nil
}
func (*binaryClasscallImport) ID() binary.ID      { return binaryIDcallImport }
func (*binaryClasscallImport) New() binary.Object { return &callImport{} }
func (*binaryClasscallImport) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodecallImport(e, obj.(*callImport))
}
func (*binaryClasscallImport) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &callImport{}
	return obj, doDecodecallImport(d, obj)
}
func (*binaryClasscallImport) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodecallImport(d, obj.(*callImport))
}
func (*binaryClasscallImport) Skip(d binary.Decoder) error { return doSkipcallImport(d) }
func (*binaryClasscallImport) Schema() *schema.Class       { return schemacallImport }

var schemacallImport = &schema.Class{
	TypeID: binaryIDcallImport,
	Name:   "callImport",
	Fields: []schema.Field{
		schema.Field{Declared: "name", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		schema.Field{Declared: "Data", Type: &schema.Slice{Alias: "U8Array", ValueType: &schema.Primitive{Name: "uint8", Method: schema.Uint8}}},
	},
}

type binaryClasscallPrerenderFramebuffers struct{}

func (*callPrerenderFramebuffers) Class() binary.Class {
	return (*binaryClasscallPrerenderFramebuffers)(nil)
}
func doEncodecallPrerenderFramebuffers(e binary.Encoder, o *callPrerenderFramebuffers) error {
	if err := e.Value(&o.device); err != nil {
		return err
	}
	if err := e.Value(&o.capture); err != nil {
		return err
	}
	if err := e.Value(&o.api); err != nil {
		return err
	}
	if err := e.Uint32(o.width); err != nil {
		return err
	}
	if err := e.Uint32(o.height); err != nil {
		return err
	}
	if err := e.Uint32(uint32(len(o.atomIds))); err != nil {
		return err
	}
	for i := range o.atomIds {
		if err := e.Uint64(o.atomIds[i]); err != nil {
			return err
		}
	}
	return nil
}
func doDecodecallPrerenderFramebuffers(d binary.Decoder, o *callPrerenderFramebuffers) error {
	if err := d.Value(&o.device); err != nil {
		return err
	}
	if err := d.Value(&o.capture); err != nil {
		return err
	}
	if err := d.Value(&o.api); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.width = uint32(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.height = uint32(obj)
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.atomIds = make(U64Array, count)
		for i := range o.atomIds {
			if obj, err := d.Uint64(); err != nil {
				return err
			} else {
				o.atomIds[i] = uint64(obj)
			}
		}
	}
	return nil
}
func doSkipcallPrerenderFramebuffers(d binary.Decoder) error {
	if err := d.SkipValue((*DeviceId)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*CaptureId)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*ApiId)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if _, err := d.Uint64(); err != nil {
				return err
			}
		}
	}
	return nil
}
func (*binaryClasscallPrerenderFramebuffers) ID() binary.ID      { return binaryIDcallPrerenderFramebuffers }
func (*binaryClasscallPrerenderFramebuffers) New() binary.Object { return &callPrerenderFramebuffers{} }
func (*binaryClasscallPrerenderFramebuffers) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodecallPrerenderFramebuffers(e, obj.(*callPrerenderFramebuffers))
}
func (*binaryClasscallPrerenderFramebuffers) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &callPrerenderFramebuffers{}
	return obj, doDecodecallPrerenderFramebuffers(d, obj)
}
func (*binaryClasscallPrerenderFramebuffers) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodecallPrerenderFramebuffers(d, obj.(*callPrerenderFramebuffers))
}
func (*binaryClasscallPrerenderFramebuffers) Skip(d binary.Decoder) error {
	return doSkipcallPrerenderFramebuffers(d)
}
func (*binaryClasscallPrerenderFramebuffers) Schema() *schema.Class {
	return schemacallPrerenderFramebuffers
}

var schemacallPrerenderFramebuffers = &schema.Class{
	TypeID: binaryIDcallPrerenderFramebuffers,
	Name:   "callPrerenderFramebuffers",
	Fields: []schema.Field{
		schema.Field{Declared: "device", Type: &schema.Struct{Name: "DeviceId"}},
		schema.Field{Declared: "capture", Type: &schema.Struct{Name: "CaptureId"}},
		schema.Field{Declared: "api", Type: &schema.Struct{Name: "ApiId"}},
		schema.Field{Declared: "width", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
		schema.Field{Declared: "height", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
		schema.Field{Declared: "atomIds", Type: &schema.Slice{Alias: "U64Array", ValueType: &schema.Primitive{Name: "uint64", Method: schema.Uint64}}},
	},
}

type binaryClasscallReplaceAtom struct{}

func (*callReplaceAtom) Class() binary.Class {
	return (*binaryClasscallReplaceAtom)(nil)
}
func doEncodecallReplaceAtom(e binary.Encoder, o *callReplaceAtom) error {
	if err := e.Value(&o.capture); err != nil {
		return err
	}
	if err := e.Uint64(o.atomId); err != nil {
		return err
	}
	if err := e.Uint16(o.atomType); err != nil {
		return err
	}
	if err := e.Value(&o.data); err != nil {
		return err
	}
	return nil
}
func doDecodecallReplaceAtom(d binary.Decoder, o *callReplaceAtom) error {
	if err := d.Value(&o.capture); err != nil {
		return err
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.atomId = uint64(obj)
	}
	if obj, err := d.Uint16(); err != nil {
		return err
	} else {
		o.atomType = uint16(obj)
	}
	if err := d.Value(&o.data); err != nil {
		return err
	}
	return nil
}
func doSkipcallReplaceAtom(d binary.Decoder) error {
	if err := d.SkipValue((*CaptureId)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	if _, err := d.Uint16(); err != nil {
		return err
	}
	if err := d.SkipValue((*Binary)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClasscallReplaceAtom) ID() binary.ID      { return binaryIDcallReplaceAtom }
func (*binaryClasscallReplaceAtom) New() binary.Object { return &callReplaceAtom{} }
func (*binaryClasscallReplaceAtom) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodecallReplaceAtom(e, obj.(*callReplaceAtom))
}
func (*binaryClasscallReplaceAtom) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &callReplaceAtom{}
	return obj, doDecodecallReplaceAtom(d, obj)
}
func (*binaryClasscallReplaceAtom) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodecallReplaceAtom(d, obj.(*callReplaceAtom))
}
func (*binaryClasscallReplaceAtom) Skip(d binary.Decoder) error { return doSkipcallReplaceAtom(d) }
func (*binaryClasscallReplaceAtom) Schema() *schema.Class       { return schemacallReplaceAtom }

var schemacallReplaceAtom = &schema.Class{
	TypeID: binaryIDcallReplaceAtom,
	Name:   "callReplaceAtom",
	Fields: []schema.Field{
		schema.Field{Declared: "capture", Type: &schema.Struct{Name: "CaptureId"}},
		schema.Field{Declared: "atomId", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
		schema.Field{Declared: "atomType", Type: &schema.Primitive{Name: "uint16", Method: schema.Uint16}},
		schema.Field{Declared: "data", Type: &schema.Struct{Name: "Binary"}},
	},
}

type binaryClasscallResolveAtomStream struct{}

func (*callResolveAtomStream) Class() binary.Class {
	return (*binaryClasscallResolveAtomStream)(nil)
}
func doEncodecallResolveAtomStream(e binary.Encoder, o *callResolveAtomStream) error {
	if err := e.Value(&o.id); err != nil {
		return err
	}
	return nil
}
func doDecodecallResolveAtomStream(d binary.Decoder, o *callResolveAtomStream) error {
	if err := d.Value(&o.id); err != nil {
		return err
	}
	return nil
}
func doSkipcallResolveAtomStream(d binary.Decoder) error {
	if err := d.SkipValue((*AtomStreamId)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClasscallResolveAtomStream) ID() binary.ID      { return binaryIDcallResolveAtomStream }
func (*binaryClasscallResolveAtomStream) New() binary.Object { return &callResolveAtomStream{} }
func (*binaryClasscallResolveAtomStream) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodecallResolveAtomStream(e, obj.(*callResolveAtomStream))
}
func (*binaryClasscallResolveAtomStream) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &callResolveAtomStream{}
	return obj, doDecodecallResolveAtomStream(d, obj)
}
func (*binaryClasscallResolveAtomStream) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodecallResolveAtomStream(d, obj.(*callResolveAtomStream))
}
func (*binaryClasscallResolveAtomStream) Skip(d binary.Decoder) error {
	return doSkipcallResolveAtomStream(d)
}
func (*binaryClasscallResolveAtomStream) Schema() *schema.Class { return schemacallResolveAtomStream }

var schemacallResolveAtomStream = &schema.Class{
	TypeID: binaryIDcallResolveAtomStream,
	Name:   "callResolveAtomStream",
	Fields: []schema.Field{
		schema.Field{Declared: "id", Type: &schema.Struct{Name: "AtomStreamId"}},
	},
}

type binaryClasscallResolveBinary struct{}

func (*callResolveBinary) Class() binary.Class {
	return (*binaryClasscallResolveBinary)(nil)
}
func doEncodecallResolveBinary(e binary.Encoder, o *callResolveBinary) error {
	if err := e.Value(&o.id); err != nil {
		return err
	}
	return nil
}
func doDecodecallResolveBinary(d binary.Decoder, o *callResolveBinary) error {
	if err := d.Value(&o.id); err != nil {
		return err
	}
	return nil
}
func doSkipcallResolveBinary(d binary.Decoder) error {
	if err := d.SkipValue((*BinaryId)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClasscallResolveBinary) ID() binary.ID      { return binaryIDcallResolveBinary }
func (*binaryClasscallResolveBinary) New() binary.Object { return &callResolveBinary{} }
func (*binaryClasscallResolveBinary) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodecallResolveBinary(e, obj.(*callResolveBinary))
}
func (*binaryClasscallResolveBinary) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &callResolveBinary{}
	return obj, doDecodecallResolveBinary(d, obj)
}
func (*binaryClasscallResolveBinary) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodecallResolveBinary(d, obj.(*callResolveBinary))
}
func (*binaryClasscallResolveBinary) Skip(d binary.Decoder) error { return doSkipcallResolveBinary(d) }
func (*binaryClasscallResolveBinary) Schema() *schema.Class       { return schemacallResolveBinary }

var schemacallResolveBinary = &schema.Class{
	TypeID: binaryIDcallResolveBinary,
	Name:   "callResolveBinary",
	Fields: []schema.Field{
		schema.Field{Declared: "id", Type: &schema.Struct{Name: "BinaryId"}},
	},
}

type binaryClasscallResolveCapture struct{}

func (*callResolveCapture) Class() binary.Class {
	return (*binaryClasscallResolveCapture)(nil)
}
func doEncodecallResolveCapture(e binary.Encoder, o *callResolveCapture) error {
	if err := e.Value(&o.id); err != nil {
		return err
	}
	return nil
}
func doDecodecallResolveCapture(d binary.Decoder, o *callResolveCapture) error {
	if err := d.Value(&o.id); err != nil {
		return err
	}
	return nil
}
func doSkipcallResolveCapture(d binary.Decoder) error {
	if err := d.SkipValue((*CaptureId)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClasscallResolveCapture) ID() binary.ID      { return binaryIDcallResolveCapture }
func (*binaryClasscallResolveCapture) New() binary.Object { return &callResolveCapture{} }
func (*binaryClasscallResolveCapture) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodecallResolveCapture(e, obj.(*callResolveCapture))
}
func (*binaryClasscallResolveCapture) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &callResolveCapture{}
	return obj, doDecodecallResolveCapture(d, obj)
}
func (*binaryClasscallResolveCapture) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodecallResolveCapture(d, obj.(*callResolveCapture))
}
func (*binaryClasscallResolveCapture) Skip(d binary.Decoder) error { return doSkipcallResolveCapture(d) }
func (*binaryClasscallResolveCapture) Schema() *schema.Class       { return schemacallResolveCapture }

var schemacallResolveCapture = &schema.Class{
	TypeID: binaryIDcallResolveCapture,
	Name:   "callResolveCapture",
	Fields: []schema.Field{
		schema.Field{Declared: "id", Type: &schema.Struct{Name: "CaptureId"}},
	},
}

type binaryClasscallResolveDevice struct{}

func (*callResolveDevice) Class() binary.Class {
	return (*binaryClasscallResolveDevice)(nil)
}
func doEncodecallResolveDevice(e binary.Encoder, o *callResolveDevice) error {
	if err := e.Value(&o.id); err != nil {
		return err
	}
	return nil
}
func doDecodecallResolveDevice(d binary.Decoder, o *callResolveDevice) error {
	if err := d.Value(&o.id); err != nil {
		return err
	}
	return nil
}
func doSkipcallResolveDevice(d binary.Decoder) error {
	if err := d.SkipValue((*DeviceId)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClasscallResolveDevice) ID() binary.ID      { return binaryIDcallResolveDevice }
func (*binaryClasscallResolveDevice) New() binary.Object { return &callResolveDevice{} }
func (*binaryClasscallResolveDevice) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodecallResolveDevice(e, obj.(*callResolveDevice))
}
func (*binaryClasscallResolveDevice) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &callResolveDevice{}
	return obj, doDecodecallResolveDevice(d, obj)
}
func (*binaryClasscallResolveDevice) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodecallResolveDevice(d, obj.(*callResolveDevice))
}
func (*binaryClasscallResolveDevice) Skip(d binary.Decoder) error { return doSkipcallResolveDevice(d) }
func (*binaryClasscallResolveDevice) Schema() *schema.Class       { return schemacallResolveDevice }

var schemacallResolveDevice = &schema.Class{
	TypeID: binaryIDcallResolveDevice,
	Name:   "callResolveDevice",
	Fields: []schema.Field{
		schema.Field{Declared: "id", Type: &schema.Struct{Name: "DeviceId"}},
	},
}

type binaryClasscallResolveHierarchy struct{}

func (*callResolveHierarchy) Class() binary.Class {
	return (*binaryClasscallResolveHierarchy)(nil)
}
func doEncodecallResolveHierarchy(e binary.Encoder, o *callResolveHierarchy) error {
	if err := e.Value(&o.id); err != nil {
		return err
	}
	return nil
}
func doDecodecallResolveHierarchy(d binary.Decoder, o *callResolveHierarchy) error {
	if err := d.Value(&o.id); err != nil {
		return err
	}
	return nil
}
func doSkipcallResolveHierarchy(d binary.Decoder) error {
	if err := d.SkipValue((*HierarchyId)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClasscallResolveHierarchy) ID() binary.ID      { return binaryIDcallResolveHierarchy }
func (*binaryClasscallResolveHierarchy) New() binary.Object { return &callResolveHierarchy{} }
func (*binaryClasscallResolveHierarchy) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodecallResolveHierarchy(e, obj.(*callResolveHierarchy))
}
func (*binaryClasscallResolveHierarchy) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &callResolveHierarchy{}
	return obj, doDecodecallResolveHierarchy(d, obj)
}
func (*binaryClasscallResolveHierarchy) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodecallResolveHierarchy(d, obj.(*callResolveHierarchy))
}
func (*binaryClasscallResolveHierarchy) Skip(d binary.Decoder) error {
	return doSkipcallResolveHierarchy(d)
}
func (*binaryClasscallResolveHierarchy) Schema() *schema.Class { return schemacallResolveHierarchy }

var schemacallResolveHierarchy = &schema.Class{
	TypeID: binaryIDcallResolveHierarchy,
	Name:   "callResolveHierarchy",
	Fields: []schema.Field{
		schema.Field{Declared: "id", Type: &schema.Struct{Name: "HierarchyId"}},
	},
}

type binaryClasscallResolveImageInfo struct{}

func (*callResolveImageInfo) Class() binary.Class {
	return (*binaryClasscallResolveImageInfo)(nil)
}
func doEncodecallResolveImageInfo(e binary.Encoder, o *callResolveImageInfo) error {
	if err := e.Value(&o.id); err != nil {
		return err
	}
	return nil
}
func doDecodecallResolveImageInfo(d binary.Decoder, o *callResolveImageInfo) error {
	if err := d.Value(&o.id); err != nil {
		return err
	}
	return nil
}
func doSkipcallResolveImageInfo(d binary.Decoder) error {
	if err := d.SkipValue((*ImageInfoId)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClasscallResolveImageInfo) ID() binary.ID      { return binaryIDcallResolveImageInfo }
func (*binaryClasscallResolveImageInfo) New() binary.Object { return &callResolveImageInfo{} }
func (*binaryClasscallResolveImageInfo) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodecallResolveImageInfo(e, obj.(*callResolveImageInfo))
}
func (*binaryClasscallResolveImageInfo) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &callResolveImageInfo{}
	return obj, doDecodecallResolveImageInfo(d, obj)
}
func (*binaryClasscallResolveImageInfo) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodecallResolveImageInfo(d, obj.(*callResolveImageInfo))
}
func (*binaryClasscallResolveImageInfo) Skip(d binary.Decoder) error {
	return doSkipcallResolveImageInfo(d)
}
func (*binaryClasscallResolveImageInfo) Schema() *schema.Class { return schemacallResolveImageInfo }

var schemacallResolveImageInfo = &schema.Class{
	TypeID: binaryIDcallResolveImageInfo,
	Name:   "callResolveImageInfo",
	Fields: []schema.Field{
		schema.Field{Declared: "id", Type: &schema.Struct{Name: "ImageInfoId"}},
	},
}

type binaryClasscallResolveMemoryInfo struct{}

func (*callResolveMemoryInfo) Class() binary.Class {
	return (*binaryClasscallResolveMemoryInfo)(nil)
}
func doEncodecallResolveMemoryInfo(e binary.Encoder, o *callResolveMemoryInfo) error {
	if err := e.Value(&o.id); err != nil {
		return err
	}
	return nil
}
func doDecodecallResolveMemoryInfo(d binary.Decoder, o *callResolveMemoryInfo) error {
	if err := d.Value(&o.id); err != nil {
		return err
	}
	return nil
}
func doSkipcallResolveMemoryInfo(d binary.Decoder) error {
	if err := d.SkipValue((*MemoryInfoId)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClasscallResolveMemoryInfo) ID() binary.ID      { return binaryIDcallResolveMemoryInfo }
func (*binaryClasscallResolveMemoryInfo) New() binary.Object { return &callResolveMemoryInfo{} }
func (*binaryClasscallResolveMemoryInfo) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodecallResolveMemoryInfo(e, obj.(*callResolveMemoryInfo))
}
func (*binaryClasscallResolveMemoryInfo) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &callResolveMemoryInfo{}
	return obj, doDecodecallResolveMemoryInfo(d, obj)
}
func (*binaryClasscallResolveMemoryInfo) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodecallResolveMemoryInfo(d, obj.(*callResolveMemoryInfo))
}
func (*binaryClasscallResolveMemoryInfo) Skip(d binary.Decoder) error {
	return doSkipcallResolveMemoryInfo(d)
}
func (*binaryClasscallResolveMemoryInfo) Schema() *schema.Class { return schemacallResolveMemoryInfo }

var schemacallResolveMemoryInfo = &schema.Class{
	TypeID: binaryIDcallResolveMemoryInfo,
	Name:   "callResolveMemoryInfo",
	Fields: []schema.Field{
		schema.Field{Declared: "id", Type: &schema.Struct{Name: "MemoryInfoId"}},
	},
}

type binaryClasscallResolveSchema struct{}

func (*callResolveSchema) Class() binary.Class {
	return (*binaryClasscallResolveSchema)(nil)
}
func doEncodecallResolveSchema(e binary.Encoder, o *callResolveSchema) error {
	if err := e.Value(&o.id); err != nil {
		return err
	}
	return nil
}
func doDecodecallResolveSchema(d binary.Decoder, o *callResolveSchema) error {
	if err := d.Value(&o.id); err != nil {
		return err
	}
	return nil
}
func doSkipcallResolveSchema(d binary.Decoder) error {
	if err := d.SkipValue((*SchemaId)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClasscallResolveSchema) ID() binary.ID      { return binaryIDcallResolveSchema }
func (*binaryClasscallResolveSchema) New() binary.Object { return &callResolveSchema{} }
func (*binaryClasscallResolveSchema) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodecallResolveSchema(e, obj.(*callResolveSchema))
}
func (*binaryClasscallResolveSchema) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &callResolveSchema{}
	return obj, doDecodecallResolveSchema(d, obj)
}
func (*binaryClasscallResolveSchema) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodecallResolveSchema(d, obj.(*callResolveSchema))
}
func (*binaryClasscallResolveSchema) Skip(d binary.Decoder) error { return doSkipcallResolveSchema(d) }
func (*binaryClasscallResolveSchema) Schema() *schema.Class       { return schemacallResolveSchema }

var schemacallResolveSchema = &schema.Class{
	TypeID: binaryIDcallResolveSchema,
	Name:   "callResolveSchema",
	Fields: []schema.Field{
		schema.Field{Declared: "id", Type: &schema.Struct{Name: "SchemaId"}},
	},
}

type binaryClasscallResolveTimingInfo struct{}

func (*callResolveTimingInfo) Class() binary.Class {
	return (*binaryClasscallResolveTimingInfo)(nil)
}
func doEncodecallResolveTimingInfo(e binary.Encoder, o *callResolveTimingInfo) error {
	if err := e.Value(&o.id); err != nil {
		return err
	}
	return nil
}
func doDecodecallResolveTimingInfo(d binary.Decoder, o *callResolveTimingInfo) error {
	if err := d.Value(&o.id); err != nil {
		return err
	}
	return nil
}
func doSkipcallResolveTimingInfo(d binary.Decoder) error {
	if err := d.SkipValue((*TimingInfoId)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClasscallResolveTimingInfo) ID() binary.ID      { return binaryIDcallResolveTimingInfo }
func (*binaryClasscallResolveTimingInfo) New() binary.Object { return &callResolveTimingInfo{} }
func (*binaryClasscallResolveTimingInfo) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodecallResolveTimingInfo(e, obj.(*callResolveTimingInfo))
}
func (*binaryClasscallResolveTimingInfo) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &callResolveTimingInfo{}
	return obj, doDecodecallResolveTimingInfo(d, obj)
}
func (*binaryClasscallResolveTimingInfo) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodecallResolveTimingInfo(d, obj.(*callResolveTimingInfo))
}
func (*binaryClasscallResolveTimingInfo) Skip(d binary.Decoder) error {
	return doSkipcallResolveTimingInfo(d)
}
func (*binaryClasscallResolveTimingInfo) Schema() *schema.Class { return schemacallResolveTimingInfo }

var schemacallResolveTimingInfo = &schema.Class{
	TypeID: binaryIDcallResolveTimingInfo,
	Name:   "callResolveTimingInfo",
	Fields: []schema.Field{
		schema.Field{Declared: "id", Type: &schema.Struct{Name: "TimingInfoId"}},
	},
}

type binaryClassresultGetCaptures struct{}

func (*resultGetCaptures) Class() binary.Class {
	return (*binaryClassresultGetCaptures)(nil)
}
func doEncoderesultGetCaptures(e binary.Encoder, o *resultGetCaptures) error {
	if err := e.Uint32(uint32(len(o.value))); err != nil {
		return err
	}
	for i := range o.value {
		if err := e.Value(&o.value[i]); err != nil {
			return err
		}
	}
	return nil
}
func doDecoderesultGetCaptures(d binary.Decoder, o *resultGetCaptures) error {
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.value = make(CaptureIdArray, count)
		for i := range o.value {
			if err := d.Value(&o.value[i]); err != nil {
				return err
			}
		}
	}
	return nil
}
func doSkipresultGetCaptures(d binary.Decoder) error {
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if err := d.SkipValue((*CaptureId)(nil)); err != nil {
				return err
			}
		}
	}
	return nil
}
func (*binaryClassresultGetCaptures) ID() binary.ID      { return binaryIDresultGetCaptures }
func (*binaryClassresultGetCaptures) New() binary.Object { return &resultGetCaptures{} }
func (*binaryClassresultGetCaptures) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncoderesultGetCaptures(e, obj.(*resultGetCaptures))
}
func (*binaryClassresultGetCaptures) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &resultGetCaptures{}
	return obj, doDecoderesultGetCaptures(d, obj)
}
func (*binaryClassresultGetCaptures) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecoderesultGetCaptures(d, obj.(*resultGetCaptures))
}
func (*binaryClassresultGetCaptures) Skip(d binary.Decoder) error { return doSkipresultGetCaptures(d) }
func (*binaryClassresultGetCaptures) Schema() *schema.Class       { return schemaresultGetCaptures }

var schemaresultGetCaptures = &schema.Class{
	TypeID: binaryIDresultGetCaptures,
	Name:   "resultGetCaptures",
	Fields: []schema.Field{
		schema.Field{Declared: "value", Type: &schema.Slice{Alias: "CaptureIdArray", ValueType: &schema.Struct{Name: "CaptureId"}}},
	},
}

type binaryClassresultGetDevices struct{}

func (*resultGetDevices) Class() binary.Class {
	return (*binaryClassresultGetDevices)(nil)
}
func doEncoderesultGetDevices(e binary.Encoder, o *resultGetDevices) error {
	if err := e.Uint32(uint32(len(o.value))); err != nil {
		return err
	}
	for i := range o.value {
		if err := e.Value(&o.value[i]); err != nil {
			return err
		}
	}
	return nil
}
func doDecoderesultGetDevices(d binary.Decoder, o *resultGetDevices) error {
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		o.value = make(DeviceIdArray, count)
		for i := range o.value {
			if err := d.Value(&o.value[i]); err != nil {
				return err
			}
		}
	}
	return nil
}
func doSkipresultGetDevices(d binary.Decoder) error {
	if count, err := d.Uint32(); err != nil {
		return err
	} else {
		for i := uint32(0); i < count; i++ {
			if err := d.SkipValue((*DeviceId)(nil)); err != nil {
				return err
			}
		}
	}
	return nil
}
func (*binaryClassresultGetDevices) ID() binary.ID      { return binaryIDresultGetDevices }
func (*binaryClassresultGetDevices) New() binary.Object { return &resultGetDevices{} }
func (*binaryClassresultGetDevices) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncoderesultGetDevices(e, obj.(*resultGetDevices))
}
func (*binaryClassresultGetDevices) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &resultGetDevices{}
	return obj, doDecoderesultGetDevices(d, obj)
}
func (*binaryClassresultGetDevices) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecoderesultGetDevices(d, obj.(*resultGetDevices))
}
func (*binaryClassresultGetDevices) Skip(d binary.Decoder) error { return doSkipresultGetDevices(d) }
func (*binaryClassresultGetDevices) Schema() *schema.Class       { return schemaresultGetDevices }

var schemaresultGetDevices = &schema.Class{
	TypeID: binaryIDresultGetDevices,
	Name:   "resultGetDevices",
	Fields: []schema.Field{
		schema.Field{Declared: "value", Type: &schema.Slice{Alias: "DeviceIdArray", ValueType: &schema.Struct{Name: "DeviceId"}}},
	},
}

type binaryClassresultGetFramebufferColor struct{}

func (*resultGetFramebufferColor) Class() binary.Class {
	return (*binaryClassresultGetFramebufferColor)(nil)
}
func doEncoderesultGetFramebufferColor(e binary.Encoder, o *resultGetFramebufferColor) error {
	if err := e.Value(&o.value); err != nil {
		return err
	}
	return nil
}
func doDecoderesultGetFramebufferColor(d binary.Decoder, o *resultGetFramebufferColor) error {
	if err := d.Value(&o.value); err != nil {
		return err
	}
	return nil
}
func doSkipresultGetFramebufferColor(d binary.Decoder) error {
	if err := d.SkipValue((*ImageInfoId)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassresultGetFramebufferColor) ID() binary.ID      { return binaryIDresultGetFramebufferColor }
func (*binaryClassresultGetFramebufferColor) New() binary.Object { return &resultGetFramebufferColor{} }
func (*binaryClassresultGetFramebufferColor) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncoderesultGetFramebufferColor(e, obj.(*resultGetFramebufferColor))
}
func (*binaryClassresultGetFramebufferColor) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &resultGetFramebufferColor{}
	return obj, doDecoderesultGetFramebufferColor(d, obj)
}
func (*binaryClassresultGetFramebufferColor) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecoderesultGetFramebufferColor(d, obj.(*resultGetFramebufferColor))
}
func (*binaryClassresultGetFramebufferColor) Skip(d binary.Decoder) error {
	return doSkipresultGetFramebufferColor(d)
}
func (*binaryClassresultGetFramebufferColor) Schema() *schema.Class {
	return schemaresultGetFramebufferColor
}

var schemaresultGetFramebufferColor = &schema.Class{
	TypeID: binaryIDresultGetFramebufferColor,
	Name:   "resultGetFramebufferColor",
	Fields: []schema.Field{
		schema.Field{Declared: "value", Type: &schema.Struct{Name: "ImageInfoId"}},
	},
}

type binaryClassresultGetFramebufferDepth struct{}

func (*resultGetFramebufferDepth) Class() binary.Class {
	return (*binaryClassresultGetFramebufferDepth)(nil)
}
func doEncoderesultGetFramebufferDepth(e binary.Encoder, o *resultGetFramebufferDepth) error {
	if err := e.Value(&o.value); err != nil {
		return err
	}
	return nil
}
func doDecoderesultGetFramebufferDepth(d binary.Decoder, o *resultGetFramebufferDepth) error {
	if err := d.Value(&o.value); err != nil {
		return err
	}
	return nil
}
func doSkipresultGetFramebufferDepth(d binary.Decoder) error {
	if err := d.SkipValue((*ImageInfoId)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassresultGetFramebufferDepth) ID() binary.ID      { return binaryIDresultGetFramebufferDepth }
func (*binaryClassresultGetFramebufferDepth) New() binary.Object { return &resultGetFramebufferDepth{} }
func (*binaryClassresultGetFramebufferDepth) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncoderesultGetFramebufferDepth(e, obj.(*resultGetFramebufferDepth))
}
func (*binaryClassresultGetFramebufferDepth) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &resultGetFramebufferDepth{}
	return obj, doDecoderesultGetFramebufferDepth(d, obj)
}
func (*binaryClassresultGetFramebufferDepth) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecoderesultGetFramebufferDepth(d, obj.(*resultGetFramebufferDepth))
}
func (*binaryClassresultGetFramebufferDepth) Skip(d binary.Decoder) error {
	return doSkipresultGetFramebufferDepth(d)
}
func (*binaryClassresultGetFramebufferDepth) Schema() *schema.Class {
	return schemaresultGetFramebufferDepth
}

var schemaresultGetFramebufferDepth = &schema.Class{
	TypeID: binaryIDresultGetFramebufferDepth,
	Name:   "resultGetFramebufferDepth",
	Fields: []schema.Field{
		schema.Field{Declared: "value", Type: &schema.Struct{Name: "ImageInfoId"}},
	},
}

type binaryClassresultGetHierarchy struct{}

func (*resultGetHierarchy) Class() binary.Class {
	return (*binaryClassresultGetHierarchy)(nil)
}
func doEncoderesultGetHierarchy(e binary.Encoder, o *resultGetHierarchy) error {
	if err := e.Value(&o.value); err != nil {
		return err
	}
	return nil
}
func doDecoderesultGetHierarchy(d binary.Decoder, o *resultGetHierarchy) error {
	if err := d.Value(&o.value); err != nil {
		return err
	}
	return nil
}
func doSkipresultGetHierarchy(d binary.Decoder) error {
	if err := d.SkipValue((*HierarchyId)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassresultGetHierarchy) ID() binary.ID      { return binaryIDresultGetHierarchy }
func (*binaryClassresultGetHierarchy) New() binary.Object { return &resultGetHierarchy{} }
func (*binaryClassresultGetHierarchy) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncoderesultGetHierarchy(e, obj.(*resultGetHierarchy))
}
func (*binaryClassresultGetHierarchy) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &resultGetHierarchy{}
	return obj, doDecoderesultGetHierarchy(d, obj)
}
func (*binaryClassresultGetHierarchy) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecoderesultGetHierarchy(d, obj.(*resultGetHierarchy))
}
func (*binaryClassresultGetHierarchy) Skip(d binary.Decoder) error { return doSkipresultGetHierarchy(d) }
func (*binaryClassresultGetHierarchy) Schema() *schema.Class       { return schemaresultGetHierarchy }

var schemaresultGetHierarchy = &schema.Class{
	TypeID: binaryIDresultGetHierarchy,
	Name:   "resultGetHierarchy",
	Fields: []schema.Field{
		schema.Field{Declared: "value", Type: &schema.Struct{Name: "HierarchyId"}},
	},
}

type binaryClassresultGetMemoryInfo struct{}

func (*resultGetMemoryInfo) Class() binary.Class {
	return (*binaryClassresultGetMemoryInfo)(nil)
}
func doEncoderesultGetMemoryInfo(e binary.Encoder, o *resultGetMemoryInfo) error {
	if err := e.Value(&o.value); err != nil {
		return err
	}
	return nil
}
func doDecoderesultGetMemoryInfo(d binary.Decoder, o *resultGetMemoryInfo) error {
	if err := d.Value(&o.value); err != nil {
		return err
	}
	return nil
}
func doSkipresultGetMemoryInfo(d binary.Decoder) error {
	if err := d.SkipValue((*MemoryInfoId)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassresultGetMemoryInfo) ID() binary.ID      { return binaryIDresultGetMemoryInfo }
func (*binaryClassresultGetMemoryInfo) New() binary.Object { return &resultGetMemoryInfo{} }
func (*binaryClassresultGetMemoryInfo) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncoderesultGetMemoryInfo(e, obj.(*resultGetMemoryInfo))
}
func (*binaryClassresultGetMemoryInfo) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &resultGetMemoryInfo{}
	return obj, doDecoderesultGetMemoryInfo(d, obj)
}
func (*binaryClassresultGetMemoryInfo) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecoderesultGetMemoryInfo(d, obj.(*resultGetMemoryInfo))
}
func (*binaryClassresultGetMemoryInfo) Skip(d binary.Decoder) error {
	return doSkipresultGetMemoryInfo(d)
}
func (*binaryClassresultGetMemoryInfo) Schema() *schema.Class { return schemaresultGetMemoryInfo }

var schemaresultGetMemoryInfo = &schema.Class{
	TypeID: binaryIDresultGetMemoryInfo,
	Name:   "resultGetMemoryInfo",
	Fields: []schema.Field{
		schema.Field{Declared: "value", Type: &schema.Struct{Name: "MemoryInfoId"}},
	},
}

type binaryClassresultGetState struct{}

func (*resultGetState) Class() binary.Class {
	return (*binaryClassresultGetState)(nil)
}
func doEncoderesultGetState(e binary.Encoder, o *resultGetState) error {
	if err := e.Value(&o.value); err != nil {
		return err
	}
	return nil
}
func doDecoderesultGetState(d binary.Decoder, o *resultGetState) error {
	if err := d.Value(&o.value); err != nil {
		return err
	}
	return nil
}
func doSkipresultGetState(d binary.Decoder) error {
	if err := d.SkipValue((*BinaryId)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassresultGetState) ID() binary.ID      { return binaryIDresultGetState }
func (*binaryClassresultGetState) New() binary.Object { return &resultGetState{} }
func (*binaryClassresultGetState) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncoderesultGetState(e, obj.(*resultGetState))
}
func (*binaryClassresultGetState) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &resultGetState{}
	return obj, doDecoderesultGetState(d, obj)
}
func (*binaryClassresultGetState) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecoderesultGetState(d, obj.(*resultGetState))
}
func (*binaryClassresultGetState) Skip(d binary.Decoder) error { return doSkipresultGetState(d) }
func (*binaryClassresultGetState) Schema() *schema.Class       { return schemaresultGetState }

var schemaresultGetState = &schema.Class{
	TypeID: binaryIDresultGetState,
	Name:   "resultGetState",
	Fields: []schema.Field{
		schema.Field{Declared: "value", Type: &schema.Struct{Name: "BinaryId"}},
	},
}

type binaryClassresultGetTimingInfo struct{}

func (*resultGetTimingInfo) Class() binary.Class {
	return (*binaryClassresultGetTimingInfo)(nil)
}
func doEncoderesultGetTimingInfo(e binary.Encoder, o *resultGetTimingInfo) error {
	if err := e.Value(&o.value); err != nil {
		return err
	}
	return nil
}
func doDecoderesultGetTimingInfo(d binary.Decoder, o *resultGetTimingInfo) error {
	if err := d.Value(&o.value); err != nil {
		return err
	}
	return nil
}
func doSkipresultGetTimingInfo(d binary.Decoder) error {
	if err := d.SkipValue((*TimingInfoId)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassresultGetTimingInfo) ID() binary.ID      { return binaryIDresultGetTimingInfo }
func (*binaryClassresultGetTimingInfo) New() binary.Object { return &resultGetTimingInfo{} }
func (*binaryClassresultGetTimingInfo) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncoderesultGetTimingInfo(e, obj.(*resultGetTimingInfo))
}
func (*binaryClassresultGetTimingInfo) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &resultGetTimingInfo{}
	return obj, doDecoderesultGetTimingInfo(d, obj)
}
func (*binaryClassresultGetTimingInfo) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecoderesultGetTimingInfo(d, obj.(*resultGetTimingInfo))
}
func (*binaryClassresultGetTimingInfo) Skip(d binary.Decoder) error {
	return doSkipresultGetTimingInfo(d)
}
func (*binaryClassresultGetTimingInfo) Schema() *schema.Class { return schemaresultGetTimingInfo }

var schemaresultGetTimingInfo = &schema.Class{
	TypeID: binaryIDresultGetTimingInfo,
	Name:   "resultGetTimingInfo",
	Fields: []schema.Field{
		schema.Field{Declared: "value", Type: &schema.Struct{Name: "TimingInfoId"}},
	},
}

type binaryClassresultImport struct{}

func (*resultImport) Class() binary.Class {
	return (*binaryClassresultImport)(nil)
}
func doEncoderesultImport(e binary.Encoder, o *resultImport) error {
	if err := e.Value(&o.value); err != nil {
		return err
	}
	return nil
}
func doDecoderesultImport(d binary.Decoder, o *resultImport) error {
	if err := d.Value(&o.value); err != nil {
		return err
	}
	return nil
}
func doSkipresultImport(d binary.Decoder) error {
	if err := d.SkipValue((*CaptureId)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassresultImport) ID() binary.ID      { return binaryIDresultImport }
func (*binaryClassresultImport) New() binary.Object { return &resultImport{} }
func (*binaryClassresultImport) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncoderesultImport(e, obj.(*resultImport))
}
func (*binaryClassresultImport) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &resultImport{}
	return obj, doDecoderesultImport(d, obj)
}
func (*binaryClassresultImport) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecoderesultImport(d, obj.(*resultImport))
}
func (*binaryClassresultImport) Skip(d binary.Decoder) error { return doSkipresultImport(d) }
func (*binaryClassresultImport) Schema() *schema.Class       { return schemaresultImport }

var schemaresultImport = &schema.Class{
	TypeID: binaryIDresultImport,
	Name:   "resultImport",
	Fields: []schema.Field{
		schema.Field{Declared: "value", Type: &schema.Struct{Name: "CaptureId"}},
	},
}

type binaryClassresultPrerenderFramebuffers struct{}

func (*resultPrerenderFramebuffers) Class() binary.Class {
	return (*binaryClassresultPrerenderFramebuffers)(nil)
}
func doEncoderesultPrerenderFramebuffers(e binary.Encoder, o *resultPrerenderFramebuffers) error {
	if err := e.Value(&o.value); err != nil {
		return err
	}
	return nil
}
func doDecoderesultPrerenderFramebuffers(d binary.Decoder, o *resultPrerenderFramebuffers) error {
	if err := d.Value(&o.value); err != nil {
		return err
	}
	return nil
}
func doSkipresultPrerenderFramebuffers(d binary.Decoder) error {
	if err := d.SkipValue((*BinaryId)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassresultPrerenderFramebuffers) ID() binary.ID {
	return binaryIDresultPrerenderFramebuffers
}
func (*binaryClassresultPrerenderFramebuffers) New() binary.Object {
	return &resultPrerenderFramebuffers{}
}
func (*binaryClassresultPrerenderFramebuffers) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncoderesultPrerenderFramebuffers(e, obj.(*resultPrerenderFramebuffers))
}
func (*binaryClassresultPrerenderFramebuffers) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &resultPrerenderFramebuffers{}
	return obj, doDecoderesultPrerenderFramebuffers(d, obj)
}
func (*binaryClassresultPrerenderFramebuffers) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecoderesultPrerenderFramebuffers(d, obj.(*resultPrerenderFramebuffers))
}
func (*binaryClassresultPrerenderFramebuffers) Skip(d binary.Decoder) error {
	return doSkipresultPrerenderFramebuffers(d)
}
func (*binaryClassresultPrerenderFramebuffers) Schema() *schema.Class {
	return schemaresultPrerenderFramebuffers
}

var schemaresultPrerenderFramebuffers = &schema.Class{
	TypeID: binaryIDresultPrerenderFramebuffers,
	Name:   "resultPrerenderFramebuffers",
	Fields: []schema.Field{
		schema.Field{Declared: "value", Type: &schema.Struct{Name: "BinaryId"}},
	},
}

type binaryClassresultReplaceAtom struct{}

func (*resultReplaceAtom) Class() binary.Class {
	return (*binaryClassresultReplaceAtom)(nil)
}
func doEncoderesultReplaceAtom(e binary.Encoder, o *resultReplaceAtom) error {
	if err := e.Value(&o.value); err != nil {
		return err
	}
	return nil
}
func doDecoderesultReplaceAtom(d binary.Decoder, o *resultReplaceAtom) error {
	if err := d.Value(&o.value); err != nil {
		return err
	}
	return nil
}
func doSkipresultReplaceAtom(d binary.Decoder) error {
	if err := d.SkipValue((*CaptureId)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassresultReplaceAtom) ID() binary.ID      { return binaryIDresultReplaceAtom }
func (*binaryClassresultReplaceAtom) New() binary.Object { return &resultReplaceAtom{} }
func (*binaryClassresultReplaceAtom) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncoderesultReplaceAtom(e, obj.(*resultReplaceAtom))
}
func (*binaryClassresultReplaceAtom) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &resultReplaceAtom{}
	return obj, doDecoderesultReplaceAtom(d, obj)
}
func (*binaryClassresultReplaceAtom) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecoderesultReplaceAtom(d, obj.(*resultReplaceAtom))
}
func (*binaryClassresultReplaceAtom) Skip(d binary.Decoder) error { return doSkipresultReplaceAtom(d) }
func (*binaryClassresultReplaceAtom) Schema() *schema.Class       { return schemaresultReplaceAtom }

var schemaresultReplaceAtom = &schema.Class{
	TypeID: binaryIDresultReplaceAtom,
	Name:   "resultReplaceAtom",
	Fields: []schema.Field{
		schema.Field{Declared: "value", Type: &schema.Struct{Name: "CaptureId"}},
	},
}

type binaryClassresultResolveAtomStream struct{}

func (*resultResolveAtomStream) Class() binary.Class {
	return (*binaryClassresultResolveAtomStream)(nil)
}
func doEncoderesultResolveAtomStream(e binary.Encoder, o *resultResolveAtomStream) error {
	if err := e.Value(&o.value); err != nil {
		return err
	}
	return nil
}
func doDecoderesultResolveAtomStream(d binary.Decoder, o *resultResolveAtomStream) error {
	if err := d.Value(&o.value); err != nil {
		return err
	}
	return nil
}
func doSkipresultResolveAtomStream(d binary.Decoder) error {
	if err := d.SkipValue((*AtomStream)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassresultResolveAtomStream) ID() binary.ID      { return binaryIDresultResolveAtomStream }
func (*binaryClassresultResolveAtomStream) New() binary.Object { return &resultResolveAtomStream{} }
func (*binaryClassresultResolveAtomStream) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncoderesultResolveAtomStream(e, obj.(*resultResolveAtomStream))
}
func (*binaryClassresultResolveAtomStream) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &resultResolveAtomStream{}
	return obj, doDecoderesultResolveAtomStream(d, obj)
}
func (*binaryClassresultResolveAtomStream) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecoderesultResolveAtomStream(d, obj.(*resultResolveAtomStream))
}
func (*binaryClassresultResolveAtomStream) Skip(d binary.Decoder) error {
	return doSkipresultResolveAtomStream(d)
}
func (*binaryClassresultResolveAtomStream) Schema() *schema.Class {
	return schemaresultResolveAtomStream
}

var schemaresultResolveAtomStream = &schema.Class{
	TypeID: binaryIDresultResolveAtomStream,
	Name:   "resultResolveAtomStream",
	Fields: []schema.Field{
		schema.Field{Declared: "value", Type: &schema.Struct{Name: "AtomStream"}},
	},
}

type binaryClassresultResolveBinary struct{}

func (*resultResolveBinary) Class() binary.Class {
	return (*binaryClassresultResolveBinary)(nil)
}
func doEncoderesultResolveBinary(e binary.Encoder, o *resultResolveBinary) error {
	if err := e.Value(&o.value); err != nil {
		return err
	}
	return nil
}
func doDecoderesultResolveBinary(d binary.Decoder, o *resultResolveBinary) error {
	if err := d.Value(&o.value); err != nil {
		return err
	}
	return nil
}
func doSkipresultResolveBinary(d binary.Decoder) error {
	if err := d.SkipValue((*Binary)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassresultResolveBinary) ID() binary.ID      { return binaryIDresultResolveBinary }
func (*binaryClassresultResolveBinary) New() binary.Object { return &resultResolveBinary{} }
func (*binaryClassresultResolveBinary) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncoderesultResolveBinary(e, obj.(*resultResolveBinary))
}
func (*binaryClassresultResolveBinary) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &resultResolveBinary{}
	return obj, doDecoderesultResolveBinary(d, obj)
}
func (*binaryClassresultResolveBinary) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecoderesultResolveBinary(d, obj.(*resultResolveBinary))
}
func (*binaryClassresultResolveBinary) Skip(d binary.Decoder) error {
	return doSkipresultResolveBinary(d)
}
func (*binaryClassresultResolveBinary) Schema() *schema.Class { return schemaresultResolveBinary }

var schemaresultResolveBinary = &schema.Class{
	TypeID: binaryIDresultResolveBinary,
	Name:   "resultResolveBinary",
	Fields: []schema.Field{
		schema.Field{Declared: "value", Type: &schema.Struct{Name: "Binary"}},
	},
}

type binaryClassresultResolveCapture struct{}

func (*resultResolveCapture) Class() binary.Class {
	return (*binaryClassresultResolveCapture)(nil)
}
func doEncoderesultResolveCapture(e binary.Encoder, o *resultResolveCapture) error {
	if err := e.Value(&o.value); err != nil {
		return err
	}
	return nil
}
func doDecoderesultResolveCapture(d binary.Decoder, o *resultResolveCapture) error {
	if err := d.Value(&o.value); err != nil {
		return err
	}
	return nil
}
func doSkipresultResolveCapture(d binary.Decoder) error {
	if err := d.SkipValue((*Capture)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassresultResolveCapture) ID() binary.ID      { return binaryIDresultResolveCapture }
func (*binaryClassresultResolveCapture) New() binary.Object { return &resultResolveCapture{} }
func (*binaryClassresultResolveCapture) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncoderesultResolveCapture(e, obj.(*resultResolveCapture))
}
func (*binaryClassresultResolveCapture) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &resultResolveCapture{}
	return obj, doDecoderesultResolveCapture(d, obj)
}
func (*binaryClassresultResolveCapture) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecoderesultResolveCapture(d, obj.(*resultResolveCapture))
}
func (*binaryClassresultResolveCapture) Skip(d binary.Decoder) error {
	return doSkipresultResolveCapture(d)
}
func (*binaryClassresultResolveCapture) Schema() *schema.Class { return schemaresultResolveCapture }

var schemaresultResolveCapture = &schema.Class{
	TypeID: binaryIDresultResolveCapture,
	Name:   "resultResolveCapture",
	Fields: []schema.Field{
		schema.Field{Declared: "value", Type: &schema.Struct{Name: "Capture"}},
	},
}

type binaryClassresultResolveDevice struct{}

func (*resultResolveDevice) Class() binary.Class {
	return (*binaryClassresultResolveDevice)(nil)
}
func doEncoderesultResolveDevice(e binary.Encoder, o *resultResolveDevice) error {
	if err := e.Value(&o.value); err != nil {
		return err
	}
	return nil
}
func doDecoderesultResolveDevice(d binary.Decoder, o *resultResolveDevice) error {
	if err := d.Value(&o.value); err != nil {
		return err
	}
	return nil
}
func doSkipresultResolveDevice(d binary.Decoder) error {
	if err := d.SkipValue((*Device)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassresultResolveDevice) ID() binary.ID      { return binaryIDresultResolveDevice }
func (*binaryClassresultResolveDevice) New() binary.Object { return &resultResolveDevice{} }
func (*binaryClassresultResolveDevice) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncoderesultResolveDevice(e, obj.(*resultResolveDevice))
}
func (*binaryClassresultResolveDevice) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &resultResolveDevice{}
	return obj, doDecoderesultResolveDevice(d, obj)
}
func (*binaryClassresultResolveDevice) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecoderesultResolveDevice(d, obj.(*resultResolveDevice))
}
func (*binaryClassresultResolveDevice) Skip(d binary.Decoder) error {
	return doSkipresultResolveDevice(d)
}
func (*binaryClassresultResolveDevice) Schema() *schema.Class { return schemaresultResolveDevice }

var schemaresultResolveDevice = &schema.Class{
	TypeID: binaryIDresultResolveDevice,
	Name:   "resultResolveDevice",
	Fields: []schema.Field{
		schema.Field{Declared: "value", Type: &schema.Struct{Name: "Device"}},
	},
}

type binaryClassresultResolveHierarchy struct{}

func (*resultResolveHierarchy) Class() binary.Class {
	return (*binaryClassresultResolveHierarchy)(nil)
}
func doEncoderesultResolveHierarchy(e binary.Encoder, o *resultResolveHierarchy) error {
	if err := e.Value(&o.value); err != nil {
		return err
	}
	return nil
}
func doDecoderesultResolveHierarchy(d binary.Decoder, o *resultResolveHierarchy) error {
	if err := d.Value(&o.value); err != nil {
		return err
	}
	return nil
}
func doSkipresultResolveHierarchy(d binary.Decoder) error {
	if err := d.SkipValue((*Hierarchy)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassresultResolveHierarchy) ID() binary.ID      { return binaryIDresultResolveHierarchy }
func (*binaryClassresultResolveHierarchy) New() binary.Object { return &resultResolveHierarchy{} }
func (*binaryClassresultResolveHierarchy) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncoderesultResolveHierarchy(e, obj.(*resultResolveHierarchy))
}
func (*binaryClassresultResolveHierarchy) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &resultResolveHierarchy{}
	return obj, doDecoderesultResolveHierarchy(d, obj)
}
func (*binaryClassresultResolveHierarchy) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecoderesultResolveHierarchy(d, obj.(*resultResolveHierarchy))
}
func (*binaryClassresultResolveHierarchy) Skip(d binary.Decoder) error {
	return doSkipresultResolveHierarchy(d)
}
func (*binaryClassresultResolveHierarchy) Schema() *schema.Class { return schemaresultResolveHierarchy }

var schemaresultResolveHierarchy = &schema.Class{
	TypeID: binaryIDresultResolveHierarchy,
	Name:   "resultResolveHierarchy",
	Fields: []schema.Field{
		schema.Field{Declared: "value", Type: &schema.Struct{Name: "Hierarchy"}},
	},
}

type binaryClassresultResolveImageInfo struct{}

func (*resultResolveImageInfo) Class() binary.Class {
	return (*binaryClassresultResolveImageInfo)(nil)
}
func doEncoderesultResolveImageInfo(e binary.Encoder, o *resultResolveImageInfo) error {
	if err := e.Value(&o.value); err != nil {
		return err
	}
	return nil
}
func doDecoderesultResolveImageInfo(d binary.Decoder, o *resultResolveImageInfo) error {
	if err := d.Value(&o.value); err != nil {
		return err
	}
	return nil
}
func doSkipresultResolveImageInfo(d binary.Decoder) error {
	if err := d.SkipValue((*ImageInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassresultResolveImageInfo) ID() binary.ID      { return binaryIDresultResolveImageInfo }
func (*binaryClassresultResolveImageInfo) New() binary.Object { return &resultResolveImageInfo{} }
func (*binaryClassresultResolveImageInfo) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncoderesultResolveImageInfo(e, obj.(*resultResolveImageInfo))
}
func (*binaryClassresultResolveImageInfo) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &resultResolveImageInfo{}
	return obj, doDecoderesultResolveImageInfo(d, obj)
}
func (*binaryClassresultResolveImageInfo) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecoderesultResolveImageInfo(d, obj.(*resultResolveImageInfo))
}
func (*binaryClassresultResolveImageInfo) Skip(d binary.Decoder) error {
	return doSkipresultResolveImageInfo(d)
}
func (*binaryClassresultResolveImageInfo) Schema() *schema.Class { return schemaresultResolveImageInfo }

var schemaresultResolveImageInfo = &schema.Class{
	TypeID: binaryIDresultResolveImageInfo,
	Name:   "resultResolveImageInfo",
	Fields: []schema.Field{
		schema.Field{Declared: "value", Type: &schema.Struct{Name: "ImageInfo"}},
	},
}

type binaryClassresultResolveMemoryInfo struct{}

func (*resultResolveMemoryInfo) Class() binary.Class {
	return (*binaryClassresultResolveMemoryInfo)(nil)
}
func doEncoderesultResolveMemoryInfo(e binary.Encoder, o *resultResolveMemoryInfo) error {
	if err := e.Value(&o.value); err != nil {
		return err
	}
	return nil
}
func doDecoderesultResolveMemoryInfo(d binary.Decoder, o *resultResolveMemoryInfo) error {
	if err := d.Value(&o.value); err != nil {
		return err
	}
	return nil
}
func doSkipresultResolveMemoryInfo(d binary.Decoder) error {
	if err := d.SkipValue((*MemoryInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassresultResolveMemoryInfo) ID() binary.ID      { return binaryIDresultResolveMemoryInfo }
func (*binaryClassresultResolveMemoryInfo) New() binary.Object { return &resultResolveMemoryInfo{} }
func (*binaryClassresultResolveMemoryInfo) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncoderesultResolveMemoryInfo(e, obj.(*resultResolveMemoryInfo))
}
func (*binaryClassresultResolveMemoryInfo) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &resultResolveMemoryInfo{}
	return obj, doDecoderesultResolveMemoryInfo(d, obj)
}
func (*binaryClassresultResolveMemoryInfo) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecoderesultResolveMemoryInfo(d, obj.(*resultResolveMemoryInfo))
}
func (*binaryClassresultResolveMemoryInfo) Skip(d binary.Decoder) error {
	return doSkipresultResolveMemoryInfo(d)
}
func (*binaryClassresultResolveMemoryInfo) Schema() *schema.Class {
	return schemaresultResolveMemoryInfo
}

var schemaresultResolveMemoryInfo = &schema.Class{
	TypeID: binaryIDresultResolveMemoryInfo,
	Name:   "resultResolveMemoryInfo",
	Fields: []schema.Field{
		schema.Field{Declared: "value", Type: &schema.Struct{Name: "MemoryInfo"}},
	},
}

type binaryClassresultResolveSchema struct{}

func (*resultResolveSchema) Class() binary.Class {
	return (*binaryClassresultResolveSchema)(nil)
}
func doEncoderesultResolveSchema(e binary.Encoder, o *resultResolveSchema) error {
	if err := e.Value(&o.value); err != nil {
		return err
	}
	return nil
}
func doDecoderesultResolveSchema(d binary.Decoder, o *resultResolveSchema) error {
	if err := d.Value(&o.value); err != nil {
		return err
	}
	return nil
}
func doSkipresultResolveSchema(d binary.Decoder) error {
	if err := d.SkipValue((*Schema)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassresultResolveSchema) ID() binary.ID      { return binaryIDresultResolveSchema }
func (*binaryClassresultResolveSchema) New() binary.Object { return &resultResolveSchema{} }
func (*binaryClassresultResolveSchema) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncoderesultResolveSchema(e, obj.(*resultResolveSchema))
}
func (*binaryClassresultResolveSchema) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &resultResolveSchema{}
	return obj, doDecoderesultResolveSchema(d, obj)
}
func (*binaryClassresultResolveSchema) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecoderesultResolveSchema(d, obj.(*resultResolveSchema))
}
func (*binaryClassresultResolveSchema) Skip(d binary.Decoder) error {
	return doSkipresultResolveSchema(d)
}
func (*binaryClassresultResolveSchema) Schema() *schema.Class { return schemaresultResolveSchema }

var schemaresultResolveSchema = &schema.Class{
	TypeID: binaryIDresultResolveSchema,
	Name:   "resultResolveSchema",
	Fields: []schema.Field{
		schema.Field{Declared: "value", Type: &schema.Struct{Name: "Schema"}},
	},
}

type binaryClassresultResolveTimingInfo struct{}

func (*resultResolveTimingInfo) Class() binary.Class {
	return (*binaryClassresultResolveTimingInfo)(nil)
}
func doEncoderesultResolveTimingInfo(e binary.Encoder, o *resultResolveTimingInfo) error {
	if err := e.Value(&o.value); err != nil {
		return err
	}
	return nil
}
func doDecoderesultResolveTimingInfo(d binary.Decoder, o *resultResolveTimingInfo) error {
	if err := d.Value(&o.value); err != nil {
		return err
	}
	return nil
}
func doSkipresultResolveTimingInfo(d binary.Decoder) error {
	if err := d.SkipValue((*TimingInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassresultResolveTimingInfo) ID() binary.ID      { return binaryIDresultResolveTimingInfo }
func (*binaryClassresultResolveTimingInfo) New() binary.Object { return &resultResolveTimingInfo{} }
func (*binaryClassresultResolveTimingInfo) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncoderesultResolveTimingInfo(e, obj.(*resultResolveTimingInfo))
}
func (*binaryClassresultResolveTimingInfo) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &resultResolveTimingInfo{}
	return obj, doDecoderesultResolveTimingInfo(d, obj)
}
func (*binaryClassresultResolveTimingInfo) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecoderesultResolveTimingInfo(d, obj.(*resultResolveTimingInfo))
}
func (*binaryClassresultResolveTimingInfo) Skip(d binary.Decoder) error {
	return doSkipresultResolveTimingInfo(d)
}
func (*binaryClassresultResolveTimingInfo) Schema() *schema.Class {
	return schemaresultResolveTimingInfo
}

var schemaresultResolveTimingInfo = &schema.Class{
	TypeID: binaryIDresultResolveTimingInfo,
	Name:   "resultResolveTimingInfo",
	Fields: []schema.Field{
		schema.Field{Declared: "value", Type: &schema.Struct{Name: "TimingInfo"}},
	},
}

const _ImageFormat_name = "RGBA8Float32"

var _ImageFormat_map = map[ImageFormat]string{
	0: _ImageFormat_name[0:5],
	1: _ImageFormat_name[5:12],
}

func (v ImageFormat) String() string {
	if s, ok := _ImageFormat_map[v]; ok {
		return s
	}
	return fmt.Sprintf("ImageFormat(%d)", v)
}

func (v *ImageFormat) Parse(s string) error {
	for k, t := range _ImageFormat_map {
		if s == t {
			*v = k
			return nil
		}
	}
	return fmt.Errorf("%s not in ImageFormat", s)
}

const _TimingMask_name = "TimingPerCommandTimingPerDrawCallTimingPerFrame"

var _TimingMask_map = map[TimingMask]string{
	1: _TimingMask_name[0:16],
	2: _TimingMask_name[16:33],
	4: _TimingMask_name[33:47],
}

func (v TimingMask) String() string {
	if s, ok := _TimingMask_map[v]; ok {
		return s
	}
	return fmt.Sprintf("TimingMask(%d)", v)
}

func (v *TimingMask) Parse(s string) error {
	for k, t := range _TimingMask_map {
		if s == t {
			*v = k
			return nil
		}
	}
	return fmt.Errorf("%s not in TimingMask", s)
}

const _TypeKind_name = "BoolS8U8S16U16S32U32F32S64U64F64StringEnumStructClassArrayStaticArrayMapPointerMemoryAnyID"

var _TypeKind_map = map[TypeKind]string{
	0:  _TypeKind_name[0:4],
	1:  _TypeKind_name[4:6],
	2:  _TypeKind_name[6:8],
	3:  _TypeKind_name[8:11],
	4:  _TypeKind_name[11:14],
	5:  _TypeKind_name[14:17],
	6:  _TypeKind_name[17:20],
	7:  _TypeKind_name[20:23],
	8:  _TypeKind_name[23:26],
	9:  _TypeKind_name[26:29],
	10: _TypeKind_name[29:32],
	11: _TypeKind_name[32:38],
	12: _TypeKind_name[38:42],
	14: _TypeKind_name[42:48],
	15: _TypeKind_name[48:53],
	16: _TypeKind_name[53:58],
	17: _TypeKind_name[58:69],
	18: _TypeKind_name[69:72],
	19: _TypeKind_name[72:79],
	20: _TypeKind_name[79:85],
	21: _TypeKind_name[85:88],
	22: _TypeKind_name[88:90],
}

func (v TypeKind) String() string {
	if s, ok := _TypeKind_map[v]; ok {
		return s
	}
	return fmt.Sprintf("TypeKind(%d)", v)
}

func (v *TypeKind) Parse(s string) error {
	for k, t := range _TypeKind_map {
		if s == t {
			*v = k
			return nil
		}
	}
	return fmt.Errorf("%s not in TypeKind", s)
}