gfxapi/test/test_binary.go

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

package test

import (
	"android.googlesource.com/platform/tools/gpu/atom"
	"android.googlesource.com/platform/tools/gpu/binary"
	"android.googlesource.com/platform/tools/gpu/binary/registry"
	"android.googlesource.com/platform/tools/gpu/binary/schema"
	"android.googlesource.com/platform/tools/gpu/memory"
)

var Namespace = registry.NewNamespace()

func init() {
	registry.Global.AddFallbacks(Namespace)
	Namespace.Add((*SliceInfo)(nil).Class())
	Namespace.Add((*Boolˢ)(nil).Class())
	Namespace.Add((*Boolᵖ)(nil).Class())
	Namespace.Add((*Charˢ)(nil).Class())
	Namespace.Add((*Charᵖ)(nil).Class())
	Namespace.Add((*Charᵖˢ)(nil).Class())
	Namespace.Add((*Charᵖᵖ)(nil).Class())
	Namespace.Add((*CmdBool)(nil).Class())
	Namespace.Add((*CmdCharptrToString)(nil).Class())
	Namespace.Add((*CmdCharsliceToString)(nil).Class())
	Namespace.Add((*U8ᵖ)(nil).Class())
	Namespace.Add((*CmdClone)(nil).Class())
	Namespace.Add((*CmdCopy)(nil).Class())
	Namespace.Add((*CmdF32)(nil).Class())
	Namespace.Add((*CmdF64)(nil).Class())
	Namespace.Add((*CmdMake)(nil).Class())
	Namespace.Add((*Voidᵖ)(nil).Class())
	Namespace.Add((*CmdPointer)(nil).Class())
	Namespace.Add((*CmdRemapped)(nil).Class())
	Namespace.Add((*CmdS16)(nil).Class())
	Namespace.Add((*CmdS32)(nil).Class())
	Namespace.Add((*CmdS64)(nil).Class())
	Namespace.Add((*CmdS8)(nil).Class())
	Namespace.Add((*U16ᵖ)(nil).Class())
	Namespace.Add((*CmdSliceCasts)(nil).Class())
	Namespace.Add((*CmdString)(nil).Class())
	Namespace.Add((*CmdU16)(nil).Class())
	Namespace.Add((*CmdU32)(nil).Class())
	Namespace.Add((*CmdU64)(nil).Class())
	Namespace.Add((*CmdU8)(nil).Class())
	Namespace.Add((*CmdUnknownRet)(nil).Class())
	Namespace.Add((*Intᵖ)(nil).Class())
	Namespace.Add((*CmdUnknownWritePtr)(nil).Class())
	Namespace.Add((*CmdUnknownWriteSlice)(nil).Class())
	Namespace.Add((*CmdVoid)(nil).Class())
	Namespace.Add((*U32ᵖ)(nil).Class())
	Namespace.Add((*CmdVoid3InArrays)(nil).Class())
	Namespace.Add((*CmdVoid3Remapped)(nil).Class())
	Namespace.Add((*CmdVoid3Strings)(nil).Class())
	Namespace.Add((*CmdVoidBool)(nil).Class())
	Namespace.Add((*CmdVoidF32)(nil).Class())
	Namespace.Add((*CmdVoidF64)(nil).Class())
	Namespace.Add((*CmdVoidInArrayOfPointers)(nil).Class())
	Namespace.Add((*Remappedᵖ)(nil).Class())
	Namespace.Add((*CmdVoidInArrayOfRemapped)(nil).Class())
	Namespace.Add((*CmdVoidOutArrayOfRemapped)(nil).Class())
	Namespace.Add((*CmdVoidOutArrayOfUnknownRemapped)(nil).Class())
	Namespace.Add((*CmdVoidReadBool)(nil).Class())
	Namespace.Add((*F32ᵖ)(nil).Class())
	Namespace.Add((*CmdVoidReadF32)(nil).Class())
	Namespace.Add((*F64ᵖ)(nil).Class())
	Namespace.Add((*CmdVoidReadF64)(nil).Class())
	Namespace.Add((*CmdVoidReadPtrs)(nil).Class())
	Namespace.Add((*S16ᵖ)(nil).Class())
	Namespace.Add((*CmdVoidReadS16)(nil).Class())
	Namespace.Add((*S32ᵖ)(nil).Class())
	Namespace.Add((*CmdVoidReadS32)(nil).Class())
	Namespace.Add((*S64ᵖ)(nil).Class())
	Namespace.Add((*CmdVoidReadS64)(nil).Class())
	Namespace.Add((*S8ᵖ)(nil).Class())
	Namespace.Add((*CmdVoidReadS8)(nil).Class())
	Namespace.Add((*CmdVoidReadU16)(nil).Class())
	Namespace.Add((*CmdVoidReadU32)(nil).Class())
	Namespace.Add((*U64ᵖ)(nil).Class())
	Namespace.Add((*CmdVoidReadU64)(nil).Class())
	Namespace.Add((*CmdVoidReadU8)(nil).Class())
	Namespace.Add((*CmdVoidS16)(nil).Class())
	Namespace.Add((*CmdVoidS32)(nil).Class())
	Namespace.Add((*CmdVoidS64)(nil).Class())
	Namespace.Add((*CmdVoidS8)(nil).Class())
	Namespace.Add((*CmdVoidString)(nil).Class())
	Namespace.Add((*CmdVoidU16)(nil).Class())
	Namespace.Add((*CmdVoidU32)(nil).Class())
	Namespace.Add((*CmdVoidU64)(nil).Class())
	Namespace.Add((*CmdVoidU8)(nil).Class())
	Namespace.Add((*CmdVoidWriteBool)(nil).Class())
	Namespace.Add((*CmdVoidWriteF32)(nil).Class())
	Namespace.Add((*CmdVoidWriteF64)(nil).Class())
	Namespace.Add((*CmdVoidWritePtrs)(nil).Class())
	Namespace.Add((*CmdVoidWriteS16)(nil).Class())
	Namespace.Add((*CmdVoidWriteS32)(nil).Class())
	Namespace.Add((*CmdVoidWriteS64)(nil).Class())
	Namespace.Add((*CmdVoidWriteS8)(nil).Class())
	Namespace.Add((*CmdVoidWriteU16)(nil).Class())
	Namespace.Add((*CmdVoidWriteU32)(nil).Class())
	Namespace.Add((*CmdVoidWriteU64)(nil).Class())
	Namespace.Add((*CmdVoidWriteU8)(nil).Class())
	Namespace.Add((*F32ˢ)(nil).Class())
	Namespace.Add((*F64ˢ)(nil).Class())
	Namespace.Add((*Imported)(nil).Class())
	Namespace.Add((*Included)(nil).Class())
	Namespace.Add((*Intˢ)(nil).Class())
	Namespace.Add((*Remappedˢ)(nil).Class())
	Namespace.Add((*S16ˢ)(nil).Class())
	Namespace.Add((*S32ˢ)(nil).Class())
	Namespace.Add((*S64ˢ)(nil).Class())
	Namespace.Add((*S8ˢ)(nil).Class())
	Namespace.Add((*U8ˢ)(nil).Class())
	Namespace.Add((*U16ˢ)(nil).Class())
	Namespace.Add((*U32ˢ)(nil).Class())
	Namespace.Add((*State)(nil).Class())
	Namespace.Add((*Tester)(nil).Class())
	Namespace.Add((*U64ˢ)(nil).Class())
	Namespace.Add((*Voidˢ)(nil).Class())
}

var (
	binaryIDSliceInfo                        = binary.ID{0xc1, 0x74, 0x19, 0x7f, 0x7a, 0xa1, 0xff, 0x13, 0xf5, 0xbd, 0x4e, 0xdf, 0xb1, 0xf1, 0x33, 0x4c, 0x90, 0x61, 0x36, 0x81}
	binaryIDBoolˢ                            = binary.ID{0x58, 0x6d, 0x94, 0xd0, 0x00, 0x2c, 0x22, 0x1d, 0x5d, 0xe4, 0x4f, 0x2f, 0x30, 0x37, 0xe5, 0x19, 0x74, 0x24, 0x39, 0xcc}
	binaryIDBoolᵖ                            = binary.ID{0x4a, 0xb5, 0x98, 0x09, 0x3a, 0x64, 0xc9, 0x5e, 0x5b, 0xc2, 0x23, 0xe2, 0xb7, 0x57, 0xcb, 0xcc, 0x67, 0x5c, 0x85, 0xfc}
	binaryIDCharˢ                            = binary.ID{0x46, 0x24, 0x2f, 0x53, 0xb2, 0xd7, 0xb7, 0x6f, 0x1c, 0x7c, 0x46, 0xb3, 0xc9, 0x59, 0x57, 0x07, 0x58, 0x8f, 0x47, 0x57}
	binaryIDCharᵖ                            = binary.ID{0xf8, 0x4f, 0xaf, 0x05, 0x8b, 0xf7, 0x0e, 0xca, 0x21, 0x98, 0xde, 0xc0, 0xa9, 0xed, 0x5c, 0xf1, 0x60, 0x77, 0x7e, 0x7c}
	binaryIDCharᵖˢ                           = binary.ID{0xf1, 0x50, 0x6d, 0xd5, 0xb6, 0x11, 0x3c, 0x87, 0x89, 0xd2, 0x01, 0x60, 0x20, 0x37, 0x9a, 0xe9, 0x40, 0xc2, 0xa7, 0x6c}
	binaryIDCharᵖᵖ                           = binary.ID{0x45, 0x46, 0x22, 0x36, 0xf5, 0x05, 0xf5, 0xaa, 0x42, 0x7a, 0x86, 0x3d, 0xe0, 0xb2, 0x54, 0x9b, 0x08, 0xd5, 0xc2, 0x8b}
	binaryIDCmdBool                          = binary.ID{0x80, 0x77, 0xdf, 0x53, 0x3b, 0x89, 0xeb, 0x5f, 0x66, 0xfc, 0xe7, 0xd8, 0x38, 0x69, 0x06, 0x15, 0x7e, 0x0d, 0xcb, 0x23}
	binaryIDCmdCharptrToString               = binary.ID{0xdf, 0x31, 0x80, 0x37, 0xc7, 0x34, 0x4e, 0x03, 0xe2, 0xb9, 0x46, 0xc3, 0xe3, 0x1c, 0x71, 0xed, 0xe6, 0x40, 0xd9, 0x47}
	binaryIDCmdCharsliceToString             = binary.ID{0xfb, 0x14, 0x26, 0x02, 0x76, 0xf5, 0x73, 0x16, 0x1b, 0xbf, 0x84, 0xcb, 0xc4, 0xcc, 0x64, 0xe2, 0x42, 0x12, 0xe3, 0x91}
	binaryIDU8ᵖ                              = binary.ID{0xfe, 0x99, 0xc8, 0xb4, 0xdc, 0x6a, 0x4f, 0x51, 0x4e, 0xb1, 0x36, 0xd8, 0x6f, 0xe8, 0x39, 0x94, 0x0d, 0x9a, 0x27, 0x8f}
	binaryIDCmdClone                         = binary.ID{0xf5, 0xe7, 0xb0, 0xe1, 0x8f, 0x78, 0x0d, 0x00, 0xa4, 0x8f, 0x00, 0xdf, 0x40, 0x33, 0xbf, 0x99, 0xf7, 0xaf, 0xd9, 0x9d}
	binaryIDCmdCopy                          = binary.ID{0x7b, 0xb5, 0xeb, 0x22, 0xa4, 0xee, 0x4e, 0x5d, 0xed, 0xce, 0xc2, 0x1e, 0x47, 0x65, 0x8c, 0x7a, 0x77, 0x8f, 0xf4, 0x49}
	binaryIDCmdF32                           = binary.ID{0x52, 0x80, 0xf1, 0x18, 0x77, 0xaf, 0x25, 0x7f, 0x13, 0x7a, 0x5b, 0x34, 0x79, 0x84, 0x76, 0x61, 0x45, 0x5f, 0xca, 0xb1}
	binaryIDCmdF64                           = binary.ID{0x7a, 0xdc, 0xfc, 0x11, 0x05, 0x35, 0x69, 0xee, 0x47, 0x5b, 0x98, 0x9f, 0x38, 0x83, 0x2b, 0xa6, 0x1c, 0x31, 0x98, 0x89}
	binaryIDCmdMake                          = binary.ID{0x15, 0x38, 0x00, 0x1e, 0xc3, 0x22, 0xd3, 0xd8, 0x1e, 0xa5, 0x30, 0xd6, 0x50, 0x04, 0x98, 0xda, 0xb1, 0x18, 0x71, 0x12}
	binaryIDVoidᵖ                            = binary.ID{0x48, 0x39, 0x63, 0x6e, 0x20, 0xd9, 0x31, 0x86, 0xa2, 0x5a, 0xf0, 0x8e, 0xe8, 0x34, 0x3e, 0xa9, 0x60, 0x58, 0x8d, 0xef}
	binaryIDCmdPointer                       = binary.ID{0xf9, 0x00, 0xe9, 0xab, 0x79, 0x5c, 0x88, 0xb7, 0xb6, 0x4e, 0xaf, 0x04, 0x12, 0x0a, 0xf9, 0xa1, 0xa7, 0xd1, 0xb5, 0x8d}
	binaryIDCmdRemapped                      = binary.ID{0x22, 0x98, 0x76, 0xdd, 0x98, 0xda, 0x72, 0xbe, 0x68, 0xd6, 0x1e, 0xa7, 0x33, 0x03, 0xc0, 0xae, 0x76, 0xde, 0x7d, 0x96}
	binaryIDCmdS16                           = binary.ID{0xe8, 0x57, 0x2b, 0x7c, 0x6b, 0x9d, 0x63, 0x08, 0xd2, 0x27, 0x98, 0xd4, 0x9e, 0x5c, 0xd0, 0x7f, 0x9e, 0x7c, 0x96, 0x86}
	binaryIDCmdS32                           = binary.ID{0x08, 0xf9, 0xd9, 0x7a, 0x65, 0x69, 0x0e, 0x37, 0xa8, 0x82, 0x10, 0xf9, 0x68, 0xfb, 0x4a, 0xaa, 0x3a, 0x12, 0x59, 0xaa}
	binaryIDCmdS64                           = binary.ID{0x95, 0xcd, 0x41, 0x0e, 0x54, 0x5d, 0x34, 0x9f, 0xa5, 0x3f, 0x9a, 0x5d, 0x0f, 0xb6, 0x75, 0x6a, 0x30, 0xb3, 0x03, 0xcd}
	binaryIDCmdS8                            = binary.ID{0xa7, 0xb1, 0x9e, 0xdc, 0x20, 0x5a, 0x8e, 0x2c, 0x2d, 0x4f, 0xda, 0xe8, 0xd0, 0x8e, 0xc9, 0x89, 0x35, 0x68, 0x67, 0x67}
	binaryIDU16ᵖ                             = binary.ID{0x75, 0xd1, 0x9f, 0xf7, 0xce, 0xf8, 0xd2, 0x3d, 0xf3, 0x9e, 0xe7, 0xb1, 0x46, 0xdb, 0xc3, 0xc9, 0xac, 0xde, 0xe5, 0xf3}
	binaryIDCmdSliceCasts                    = binary.ID{0xe5, 0x7a, 0xfa, 0x50, 0xe7, 0xf5, 0x5a, 0x13, 0xd8, 0x71, 0xca, 0x37, 0x4a, 0x85, 0x1a, 0x88, 0x02, 0x0c, 0xd2, 0x12}
	binaryIDCmdString                        = binary.ID{0x76, 0x54, 0x94, 0xc8, 0x96, 0x02, 0xc5, 0x03, 0x45, 0xb6, 0x1a, 0xaa, 0x44, 0xd7, 0x0c, 0x2d, 0xb3, 0x8e, 0x89, 0x77}
	binaryIDCmdU16                           = binary.ID{0xbe, 0x5a, 0x77, 0xd3, 0xd8, 0x90, 0xb6, 0xed, 0xa1, 0x0d, 0xb6, 0xe7, 0xdf, 0x09, 0xf8, 0x5d, 0x5b, 0x0a, 0xed, 0x7a}
	binaryIDCmdU32                           = binary.ID{0x6f, 0xa9, 0x12, 0x58, 0x71, 0x99, 0x90, 0xa5, 0x2f, 0x44, 0xc6, 0x4d, 0x06, 0x12, 0x39, 0x7a, 0x11, 0xa9, 0x3f, 0x5b}
	binaryIDCmdU64                           = binary.ID{0xd1, 0x18, 0xc7, 0x32, 0xbc, 0x47, 0x41, 0x1e, 0x66, 0x25, 0xcb, 0x8c, 0x7f, 0xb4, 0xea, 0x40, 0x3c, 0xf5, 0x26, 0xa7}
	binaryIDCmdU8                            = binary.ID{0xd9, 0x12, 0x70, 0xc3, 0x2a, 0x8a, 0xd9, 0x18, 0x6a, 0x7f, 0x6b, 0x78, 0xf3, 0x3c, 0x25, 0x6b, 0x64, 0x1c, 0x34, 0x59}
	binaryIDCmdUnknownRet                    = binary.ID{0x81, 0x0d, 0x10, 0xd6, 0x99, 0xc6, 0x87, 0x5c, 0x7a, 0x6c, 0x0c, 0xb7, 0xb2, 0x94, 0xde, 0xac, 0x83, 0x1a, 0x51, 0x66}
	binaryIDIntᵖ                             = binary.ID{0xd4, 0xbf, 0xef, 0x00, 0xa2, 0x05, 0x60, 0x56, 0x38, 0x5e, 0xb3, 0xfe, 0xed, 0xcb, 0xfa, 0xb1, 0x75, 0x4a, 0xa9, 0xe2}
	binaryIDCmdUnknownWritePtr               = binary.ID{0x7c, 0x73, 0xd0, 0x88, 0x6d, 0x32, 0xaa, 0xaa, 0xd1, 0x0c, 0x40, 0x1f, 0xb4, 0x51, 0x8c, 0x92, 0x57, 0x29, 0xfb, 0x64}
	binaryIDCmdUnknownWriteSlice             = binary.ID{0xcd, 0x54, 0xda, 0x41, 0x77, 0xb4, 0x11, 0xda, 0xd2, 0xa2, 0x07, 0xa3, 0xa4, 0x09, 0x60, 0xb9, 0xcf, 0x79, 0x58, 0x45}
	binaryIDCmdVoid                          = binary.ID{0x2c, 0xee, 0x70, 0x13, 0xcb, 0xa0, 0x04, 0xc6, 0x11, 0xec, 0x73, 0xcb, 0xa9, 0xa2, 0x90, 0xcd, 0x6d, 0xa0, 0xf9, 0xee}
	binaryIDU32ᵖ                             = binary.ID{0x47, 0x5f, 0xfd, 0xa9, 0xf6, 0xcc, 0xba, 0xbc, 0x5b, 0x2a, 0x09, 0x7d, 0xba, 0x30, 0xd5, 0xcc, 0x84, 0xed, 0x08, 0x17}
	binaryIDCmdVoid3InArrays                 = binary.ID{0x48, 0xf3, 0x0c, 0x6e, 0x4e, 0xf4, 0xf0, 0x3c, 0x0f, 0x39, 0x60, 0x2e, 0xd6, 0xaa, 0xb1, 0x17, 0x52, 0xcd, 0x39, 0x22}
	binaryIDCmdVoid3Remapped                 = binary.ID{0xf1, 0x71, 0xe4, 0x75, 0x43, 0x55, 0xd7, 0x1e, 0xc0, 0xf2, 0x91, 0x7c, 0xd3, 0xdd, 0xce, 0xa2, 0xd4, 0x96, 0x4f, 0x10}
	binaryIDCmdVoid3Strings                  = binary.ID{0xb1, 0x4b, 0x88, 0x77, 0x9a, 0xef, 0x0b, 0xfc, 0x89, 0x45, 0xcb, 0x32, 0x64, 0xe3, 0x22, 0x0d, 0x4a, 0x5d, 0x1a, 0xde}
	binaryIDCmdVoidBool                      = binary.ID{0x7a, 0xbd, 0xdc, 0xa2, 0x3d, 0xcb, 0xe4, 0x70, 0xc0, 0x5a, 0xbe, 0xdd, 0x60, 0xb9, 0xb7, 0x25, 0xff, 0x64, 0xd7, 0x25}
	binaryIDCmdVoidF32                       = binary.ID{0x0c, 0x94, 0xea, 0xe1, 0x42, 0x48, 0x79, 0x78, 0x3d, 0x58, 0x8e, 0xe8, 0x4a, 0xa8, 0x98, 0xad, 0x6e, 0xa0, 0x2c, 0xdd}
	binaryIDCmdVoidF64                       = binary.ID{0x31, 0xd6, 0x0f, 0x82, 0x30, 0x87, 0x4e, 0x3c, 0x16, 0x92, 0x95, 0x86, 0xcf, 0x9e, 0xce, 0x87, 0xe7, 0x42, 0xe9, 0xce}
	binaryIDCmdVoidInArrayOfPointers         = binary.ID{0xfe, 0xbc, 0x8b, 0x57, 0xd5, 0xfd, 0xa2, 0xdc, 0x46, 0x9c, 0x5a, 0x3b, 0xc1, 0x9c, 0x09, 0xee, 0x38, 0x38, 0xaf, 0x3f}
	binaryIDRemappedᵖ                        = binary.ID{0x44, 0x09, 0x6e, 0x75, 0x9f, 0x3d, 0x69, 0x1b, 0xdb, 0xa6, 0x9a, 0x18, 0x64, 0x47, 0xec, 0xc5, 0xe0, 0x12, 0x56, 0x2d}
	binaryIDCmdVoidInArrayOfRemapped         = binary.ID{0x0f, 0x5a, 0x24, 0x88, 0xe9, 0x4f, 0xa6, 0x76, 0xfb, 0xf1, 0x57, 0xd6, 0xdb, 0x95, 0x90, 0x56, 0xe2, 0x26, 0x0f, 0xd6}
	binaryIDCmdVoidOutArrayOfRemapped        = binary.ID{0xc6, 0x57, 0xfb, 0xf5, 0x45, 0x1e, 0x87, 0xac, 0x6d, 0x51, 0x31, 0x70, 0xb7, 0x70, 0xca, 0xcf, 0xdd, 0xba, 0x9b, 0xa0}
	binaryIDCmdVoidOutArrayOfUnknownRemapped = binary.ID{0x7a, 0x99, 0x6a, 0x41, 0xd7, 0x91, 0x51, 0x79, 0xaa, 0xec, 0x9b, 0xe1, 0xca, 0x0f, 0x6a, 0x58, 0xa3, 0x0a, 0x44, 0xcc}
	binaryIDCmdVoidReadBool                  = binary.ID{0xe3, 0x72, 0xa1, 0x28, 0x51, 0x4e, 0x08, 0xac, 0xf6, 0xa1, 0x21, 0x8f, 0x7b, 0x7c, 0x1b, 0xd3, 0x7c, 0x2f, 0xcb, 0x43}
	binaryIDF32ᵖ                             = binary.ID{0x5e, 0xe1, 0xa3, 0xe0, 0x6b, 0x36, 0xd9, 0x6f, 0xc8, 0xb6, 0x8f, 0x32, 0xfb, 0x1f, 0x75, 0x96, 0x60, 0xdf, 0xbd, 0xb0}
	binaryIDCmdVoidReadF32                   = binary.ID{0x9f, 0xbf, 0x8b, 0x12, 0x64, 0x78, 0xea, 0x3a, 0xfd, 0x33, 0xb3, 0x4a, 0x72, 0xae, 0x82, 0x58, 0x56, 0xeb, 0x6c, 0x15}
	binaryIDF64ᵖ                             = binary.ID{0x3b, 0xcd, 0x00, 0x80, 0x97, 0x2b, 0x02, 0x64, 0x68, 0x3e, 0x05, 0x07, 0x2f, 0x7c, 0x30, 0xbb, 0xb3, 0xec, 0x81, 0xe0}
	binaryIDCmdVoidReadF64                   = binary.ID{0x76, 0x50, 0xaa, 0x83, 0x23, 0x22, 0xf5, 0xb4, 0xb7, 0xa8, 0xc6, 0xa9, 0x45, 0x2a, 0x54, 0xd1, 0xe5, 0x61, 0x04, 0xd0}
	binaryIDCmdVoidReadPtrs                  = binary.ID{0x42, 0x7f, 0x5e, 0x10, 0xa6, 0x0d, 0xdb, 0x58, 0x65, 0x6e, 0x07, 0x84, 0x54, 0xe1, 0x18, 0x17, 0x9f, 0x6e, 0x17, 0xdf}
	binaryIDS16ᵖ                             = binary.ID{0x03, 0x38, 0x3f, 0x5b, 0x98, 0x8e, 0x8b, 0x7a, 0x8e, 0xc2, 0x6c, 0xbc, 0xc6, 0x71, 0x54, 0x16, 0xca, 0xf0, 0x78, 0xb1}
	binaryIDCmdVoidReadS16                   = binary.ID{0xfc, 0x45, 0xde, 0x7b, 0xea, 0x09, 0x25, 0xcb, 0x5b, 0xa8, 0x7c, 0xbb, 0x18, 0xb9, 0xbe, 0x80, 0xb8, 0x10, 0x0c, 0xbb}
	binaryIDS32ᵖ                             = binary.ID{0xe2, 0x7a, 0x30, 0x4d, 0x8f, 0x67, 0x42, 0x48, 0xcf, 0x0d, 0x31, 0xc0, 0xf7, 0x81, 0x82, 0x52, 0xfd, 0xf0, 0x99, 0x4f}
	binaryIDCmdVoidReadS32                   = binary.ID{0x3c, 0xe0, 0x13, 0x74, 0xd1, 0x2b, 0x6b, 0xac, 0xda, 0x6a, 0x20, 0xf5, 0xf3, 0x65, 0xb3, 0xec, 0x2b, 0x69, 0x74, 0x66}
	binaryIDS64ᵖ                             = binary.ID{0x9f, 0x99, 0x25, 0xef, 0x80, 0x27, 0x29, 0x0a, 0xaa, 0xfc, 0x2d, 0xf9, 0xdc, 0x6f, 0x52, 0x2f, 0xda, 0x81, 0xd1, 0x35}
	binaryIDCmdVoidReadS64                   = binary.ID{0xb9, 0x0f, 0xa8, 0x30, 0x7e, 0xe2, 0x16, 0x18, 0x96, 0xf9, 0xb3, 0xa7, 0x34, 0xcb, 0xae, 0xe9, 0xcb, 0xdd, 0xaa, 0xcb}
	binaryIDS8ᵖ                              = binary.ID{0x11, 0xb9, 0xe6, 0x54, 0xbd, 0xa8, 0x97, 0xe4, 0x5b, 0x58, 0x4c, 0x8e, 0x95, 0x11, 0x55, 0x79, 0xfd, 0x99, 0x23, 0xef}
	binaryIDCmdVoidReadS8                    = binary.ID{0xc2, 0xe8, 0x40, 0xb9, 0x52, 0xe6, 0x15, 0xcc, 0xa4, 0x36, 0x25, 0x41, 0xbd, 0x51, 0x0b, 0xa3, 0xda, 0x06, 0x4f, 0x67}
	binaryIDCmdVoidReadU16                   = binary.ID{0x27, 0xdd, 0x62, 0x6e, 0x9c, 0xe9, 0xd1, 0x80, 0xe0, 0x36, 0x43, 0x92, 0xde, 0x6d, 0x8b, 0xbb, 0x54, 0xce, 0x3d, 0xc5}
	binaryIDCmdVoidReadU32                   = binary.ID{0x0c, 0xb1, 0x77, 0xb4, 0xa5, 0x94, 0xdc, 0xf4, 0xaa, 0x7a, 0x7c, 0xec, 0x20, 0x7a, 0x9f, 0x71, 0x6e, 0x5a, 0xa4, 0x1b}
	binaryIDU64ᵖ                             = binary.ID{0x8f, 0x01, 0x83, 0x87, 0xf1, 0xb2, 0x1c, 0x44, 0x85, 0xfb, 0xdc, 0x95, 0x57, 0xff, 0x85, 0x25, 0x0a, 0xc8, 0x38, 0xf7}
	binaryIDCmdVoidReadU64                   = binary.ID{0xc8, 0x5f, 0x76, 0xcd, 0x34, 0xdd, 0xdf, 0xd6, 0x22, 0xf3, 0xc9, 0x98, 0x66, 0xc6, 0x4f, 0x40, 0x66, 0xc6, 0x1e, 0xf4}
	binaryIDCmdVoidReadU8                    = binary.ID{0xcc, 0x0f, 0xa2, 0xea, 0x39, 0xe7, 0x92, 0x39, 0x91, 0xd2, 0xef, 0x30, 0xd3, 0x88, 0x5c, 0xf3, 0x9e, 0xcd, 0xae, 0x0b}
	binaryIDCmdVoidS16                       = binary.ID{0xa3, 0xc4, 0xdd, 0x66, 0xb1, 0xc1, 0x1c, 0xff, 0x19, 0xc1, 0xca, 0xe5, 0x4b, 0x2c, 0xf0, 0x7c, 0x0c, 0xe4, 0x6e, 0x1e}
	binaryIDCmdVoidS32                       = binary.ID{0xf5, 0xec, 0x9f, 0x45, 0x63, 0x9d, 0x52, 0xc9, 0xf0, 0xee, 0xd2, 0xdd, 0xfa, 0x2c, 0x23, 0x8f, 0x3d, 0x4d, 0xae, 0x59}
	binaryIDCmdVoidS64                       = binary.ID{0x59, 0x01, 0x30, 0xea, 0xcc, 0xef, 0xfb, 0x2d, 0x6f, 0xa0, 0xc7, 0xd7, 0xa1, 0xb1, 0xc1, 0x88, 0xe0, 0x07, 0xe7, 0xc2}
	binaryIDCmdVoidS8                        = binary.ID{0xfb, 0xbe, 0x03, 0x68, 0xcf, 0x75, 0xb8, 0xe5, 0x33, 0x85, 0x9e, 0xf8, 0xd7, 0x4b, 0x77, 0x19, 0x48, 0xd1, 0xcf, 0x0e}
	binaryIDCmdVoidString                    = binary.ID{0x1e, 0x22, 0x42, 0x97, 0xd4, 0x39, 0xd9, 0xa4, 0xb0, 0x3d, 0xab, 0xfe, 0x6a, 0xe0, 0x47, 0x07, 0x35, 0x5d, 0xdd, 0xdd}
	binaryIDCmdVoidU16                       = binary.ID{0x4a, 0x7a, 0xfa, 0xff, 0x54, 0xac, 0xdd, 0x40, 0x6d, 0x24, 0x1d, 0xd0, 0x67, 0x01, 0x64, 0xd4, 0xcd, 0x05, 0x23, 0x5a}
	binaryIDCmdVoidU32                       = binary.ID{0xf3, 0xc0, 0xa0, 0x77, 0x91, 0xbd, 0x8a, 0x65, 0xea, 0xa1, 0x5c, 0xa9, 0xe9, 0xb5, 0xa1, 0xaf, 0x04, 0xaf, 0x04, 0x94}
	binaryIDCmdVoidU64                       = binary.ID{0x24, 0x52, 0x3d, 0xb3, 0x1b, 0x21, 0x91, 0x44, 0xbf, 0x3d, 0x9d, 0xed, 0xa5, 0x9b, 0x26, 0xb6, 0x4b, 0xdf, 0x3c, 0x28}
	binaryIDCmdVoidU8                        = binary.ID{0xf3, 0x7c, 0xbb, 0x45, 0x0c, 0x89, 0xb5, 0x81, 0x17, 0xeb, 0x9c, 0x8c, 0x7c, 0xaa, 0x77, 0x22, 0x3b, 0x49, 0xf8, 0xf8}
	binaryIDCmdVoidWriteBool                 = binary.ID{0x07, 0xf0, 0x82, 0xc6, 0x81, 0xbd, 0x9b, 0x8c, 0x31, 0xec, 0xb8, 0x0c, 0x8d, 0xd5, 0xf3, 0x49, 0x36, 0x5e, 0xa2, 0x3a}
	binaryIDCmdVoidWriteF32                  = binary.ID{0xea, 0x88, 0xdd, 0x4c, 0xf8, 0xee, 0xe0, 0x06, 0xa9, 0x3e, 0x1d, 0xe1, 0xd2, 0xa7, 0x10, 0xe3, 0xff, 0x58, 0xb9, 0x89}
	binaryIDCmdVoidWriteF64                  = binary.ID{0xa7, 0x61, 0xe0, 0x2e, 0x06, 0x3d, 0x77, 0x3c, 0x5a, 0x8b, 0xda, 0x93, 0x3a, 0x2e, 0xd0, 0xe8, 0x3c, 0xf9, 0x81, 0xdf}
	binaryIDCmdVoidWritePtrs                 = binary.ID{0xdd, 0xf3, 0xc8, 0x3b, 0x54, 0x11, 0xf0, 0xf0, 0x90, 0xf9, 0x97, 0xff, 0xd9, 0xb5, 0x7e, 0x56, 0x28, 0x3a, 0x51, 0x4c}
	binaryIDCmdVoidWriteS16                  = binary.ID{0x0f, 0xe7, 0xea, 0x46, 0x08, 0x92, 0x57, 0x03, 0xef, 0x7b, 0x45, 0x7b, 0xde, 0x6c, 0xa7, 0x24, 0xa9, 0x74, 0xc5, 0x67}
	binaryIDCmdVoidWriteS32                  = binary.ID{0x51, 0x30, 0xfd, 0x79, 0xde, 0x83, 0xf7, 0x0b, 0x81, 0xf0, 0xd0, 0xd9, 0xdd, 0x68, 0x05, 0x45, 0x03, 0x11, 0x98, 0xd6}
	binaryIDCmdVoidWriteS64                  = binary.ID{0x97, 0x30, 0x8e, 0xf8, 0xd3, 0x02, 0x5a, 0x6f, 0xaa, 0xb3, 0x97, 0x0d, 0x19, 0x92, 0xb7, 0x4f, 0xd6, 0x13, 0x5e, 0x5e}
	binaryIDCmdVoidWriteS8                   = binary.ID{0x83, 0x14, 0x2a, 0x12, 0x17, 0xd8, 0x5f, 0xe8, 0x0b, 0x1f, 0x6e, 0x35, 0x3b, 0xc4, 0x3c, 0x61, 0x72, 0xc5, 0xb0, 0x5b}
	binaryIDCmdVoidWriteU16                  = binary.ID{0x5a, 0xd8, 0x81, 0x7f, 0x59, 0x0a, 0xb3, 0x4a, 0x1b, 0xc7, 0xe9, 0xb9, 0xca, 0x41, 0xf0, 0x9b, 0xac, 0x34, 0x4b, 0xb5}
	binaryIDCmdVoidWriteU32                  = binary.ID{0x38, 0x33, 0x9f, 0x07, 0x02, 0xa2, 0xc0, 0xaa, 0x5a, 0x0f, 0x7e, 0xff, 0x3b, 0xaf, 0xa3, 0xfa, 0x47, 0xe4, 0xde, 0x20}
	binaryIDCmdVoidWriteU64                  = binary.ID{0x72, 0x75, 0x15, 0x1a, 0x4f, 0x55, 0x04, 0x34, 0xc5, 0xe8, 0x1a, 0x0d, 0xe4, 0xea, 0x02, 0xd7, 0xc7, 0xdd, 0xf0, 0xfc}
	binaryIDCmdVoidWriteU8                   = binary.ID{0x95, 0xb5, 0x2c, 0x8d, 0x91, 0xe2, 0x72, 0xcf, 0x9c, 0x02, 0xf9, 0x02, 0x2a, 0x4e, 0x75, 0x1a, 0x41, 0xdb, 0x18, 0x49}
	binaryIDF32ˢ                             = binary.ID{0x54, 0x55, 0x98, 0x14, 0xf9, 0x77, 0x54, 0x5f, 0x90, 0x80, 0xb5, 0xb1, 0x2e, 0x8c, 0x31, 0xe6, 0xa4, 0x33, 0x5f, 0xf5}
	binaryIDF64ˢ                             = binary.ID{0x5d, 0x0f, 0x67, 0xb1, 0xc5, 0xc5, 0xa1, 0x95, 0x62, 0xf7, 0x9f, 0x9d, 0x1d, 0x4a, 0xb5, 0x46, 0x6c, 0x29, 0x55, 0x3e}
	binaryIDImported                         = binary.ID{0xdf, 0xef, 0xfd, 0x6d, 0x61, 0x4d, 0x78, 0xcf, 0x04, 0x14, 0xfb, 0xd3, 0x19, 0x00, 0x92, 0xa8, 0x23, 0xd1, 0x4a, 0xf4}
	binaryIDIncluded                         = binary.ID{0xc1, 0xa7, 0xc7, 0xd9, 0xf3, 0x7c, 0x57, 0xbc, 0x60, 0xb0, 0x48, 0x00, 0x29, 0xfa, 0x2f, 0x9c, 0xda, 0xf9, 0x49, 0x02}
	binaryIDIntˢ                             = binary.ID{0xc3, 0xee, 0xa2, 0x43, 0x6d, 0x9d, 0xe6, 0x4f, 0x53, 0x50, 0xb0, 0x74, 0x32, 0x1c, 0xae, 0xc6, 0xa4, 0x6e, 0x01, 0x36}
	binaryIDRemappedˢ                        = binary.ID{0xef, 0x06, 0x9d, 0x01, 0x03, 0x41, 0x17, 0xac, 0x8f, 0xa9, 0x11, 0xc7, 0xbb, 0xfe, 0x5b, 0xbc, 0x9b, 0xbc, 0xdb, 0xab}
	binaryIDS16ˢ                             = binary.ID{0x5c, 0xd3, 0x80, 0x31, 0x3b, 0x48, 0x76, 0x42, 0xda, 0xdf, 0x12, 0x48, 0x3f, 0x3f, 0x8f, 0xaf, 0xc0, 0x5c, 0x04, 0x87}
	binaryIDS32ˢ                             = binary.ID{0x8c, 0x2e, 0x40, 0x90, 0x28, 0x81, 0xef, 0x07, 0xba, 0xfa, 0x3f, 0x27, 0x2c, 0xae, 0x3c, 0xe0, 0x54, 0x71, 0x1c, 0x4d}
	binaryIDS64ˢ                             = binary.ID{0x07, 0xa9, 0x58, 0x7a, 0xb4, 0x74, 0xb3, 0x73, 0xaa, 0xe2, 0x9a, 0x60, 0xbc, 0x6f, 0x10, 0xe7, 0xd7, 0x3a, 0xd9, 0x37}
	binaryIDS8ˢ                              = binary.ID{0xaa, 0xcd, 0x0d, 0xd7, 0x77, 0x60, 0x96, 0xb2, 0x9f, 0x68, 0x10, 0x8b, 0xda, 0x1a, 0xf9, 0x94, 0xb7, 0xb2, 0x32, 0xae}
	binaryIDU8ˢ                              = binary.ID{0xdd, 0x14, 0x3c, 0xe6, 0xbc, 0xbc, 0xf7, 0xf8, 0xa9, 0xcc, 0x9a, 0x3c, 0x3a, 0x59, 0xe8, 0xc3, 0xd0, 0x10, 0x92, 0x30}
	binaryIDU16ˢ                             = binary.ID{0xc7, 0xa5, 0xcb, 0x47, 0x9e, 0x5c, 0xe6, 0x7f, 0x50, 0x83, 0xb2, 0x43, 0xc4, 0x84, 0xf7, 0x24, 0xa1, 0xdd, 0xda, 0xd9}
	binaryIDU32ˢ                             = binary.ID{0xe7, 0x11, 0xfe, 0xcf, 0x39, 0xfa, 0xde, 0x56, 0xbf, 0x84, 0xe2, 0x80, 0x70, 0xa2, 0xd5, 0xa8, 0xa2, 0xdc, 0xe8, 0xa9}
	binaryIDState                            = binary.ID{0x0d, 0xb7, 0xc3, 0xca, 0x19, 0x12, 0x61, 0x9f, 0x06, 0x86, 0xfa, 0x93, 0x64, 0xa8, 0x75, 0x17, 0x43, 0xeb, 0xcc, 0x81}
	binaryIDTester                           = binary.ID{0xbd, 0x19, 0x4d, 0xd3, 0x5a, 0x62, 0xbb, 0x36, 0x7d, 0x71, 0xc9, 0xf2, 0xfd, 0xc8, 0xb0, 0xc1, 0xc6, 0x2e, 0xe1, 0xd6}
	binaryIDU64ˢ                             = binary.ID{0x6a, 0x22, 0x1c, 0x24, 0x7b, 0x1c, 0xd2, 0x70, 0x0b, 0x08, 0xb6, 0x86, 0x94, 0x76, 0x5d, 0xe6, 0x9d, 0xa4, 0xf3, 0xb6}
	binaryIDVoidˢ                            = binary.ID{0x5a, 0x79, 0xba, 0x0c, 0xc5, 0xf5, 0x42, 0x43, 0xc3, 0x94, 0xc5, 0xa1, 0xa9, 0x73, 0xd6, 0x07, 0xb0, 0xd2, 0xb9, 0x34}
)

type binaryClassSliceInfo struct{}

func (*SliceInfo) Class() binary.Class {
	return (*binaryClassSliceInfo)(nil)
}
func doEncodeSliceInfo(e binary.Encoder, o *SliceInfo) error {
	if err := e.Value(&o.Root); err != nil {
		return err
	}
	if err := e.Uint64(o.Base); err != nil {
		return err
	}
	if err := e.Uint64(o.Count); err != nil {
		return err
	}
	return nil
}
func doDecodeSliceInfo(d binary.Decoder, o *SliceInfo) error {
	if err := d.Value(&o.Root); err != nil {
		return err
	}
	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.Count = uint64(obj)
	}
	return nil
}
func doSkipSliceInfo(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassSliceInfo) ID() binary.ID      { return binaryIDSliceInfo }
func (*binaryClassSliceInfo) New() binary.Object { return &SliceInfo{} }
func (*binaryClassSliceInfo) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeSliceInfo(e, obj.(*SliceInfo))
}
func (*binaryClassSliceInfo) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &SliceInfo{}
	return obj, doDecodeSliceInfo(d, obj)
}
func (*binaryClassSliceInfo) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeSliceInfo(d, obj.(*SliceInfo))
}
func (*binaryClassSliceInfo) Skip(d binary.Decoder) error { return doSkipSliceInfo(d) }
func (*binaryClassSliceInfo) Schema() *schema.Class       { return schemaSliceInfo }

var schemaSliceInfo = &schema.Class{
	TypeID:  binaryIDSliceInfo,
	Package: "test",
	Name:    "SliceInfo",
	Fields: []schema.Field{
		{Declared: "Root", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
		{Declared: "Base", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
		{Declared: "Count", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
	},
}

type binaryClassBoolˢ struct{}

func (*Boolˢ) Class() binary.Class {
	return (*binaryClassBoolˢ)(nil)
}
func doEncodeBoolˢ(e binary.Encoder, o *Boolˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeBoolˢ(d binary.Decoder, o *Boolˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipBoolˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassBoolˢ) ID() binary.ID      { return binaryIDBoolˢ }
func (*binaryClassBoolˢ) New() binary.Object { return &Boolˢ{} }
func (*binaryClassBoolˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeBoolˢ(e, obj.(*Boolˢ))
}
func (*binaryClassBoolˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Boolˢ{}
	return obj, doDecodeBoolˢ(d, obj)
}
func (*binaryClassBoolˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeBoolˢ(d, obj.(*Boolˢ))
}
func (*binaryClassBoolˢ) Skip(d binary.Decoder) error { return doSkipBoolˢ(d) }
func (*binaryClassBoolˢ) Schema() *schema.Class       { return schemaBoolˢ }

var schemaBoolˢ = &schema.Class{
	TypeID:  binaryIDBoolˢ,
	Package: "test",
	Name:    "Boolˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassBoolᵖ struct{}

func (*Boolᵖ) Class() binary.Class {
	return (*binaryClassBoolᵖ)(nil)
}
func doEncodeBoolᵖ(e binary.Encoder, o *Boolᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeBoolᵖ(d binary.Decoder, o *Boolᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipBoolᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassBoolᵖ) ID() binary.ID      { return binaryIDBoolᵖ }
func (*binaryClassBoolᵖ) New() binary.Object { return &Boolᵖ{} }
func (*binaryClassBoolᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeBoolᵖ(e, obj.(*Boolᵖ))
}
func (*binaryClassBoolᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Boolᵖ{}
	return obj, doDecodeBoolᵖ(d, obj)
}
func (*binaryClassBoolᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeBoolᵖ(d, obj.(*Boolᵖ))
}
func (*binaryClassBoolᵖ) Skip(d binary.Decoder) error { return doSkipBoolᵖ(d) }
func (*binaryClassBoolᵖ) Schema() *schema.Class       { return schemaBoolᵖ }

var schemaBoolᵖ = &schema.Class{
	TypeID:  binaryIDBoolᵖ,
	Package: "test",
	Name:    "Boolᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassCharˢ struct{}

func (*Charˢ) Class() binary.Class {
	return (*binaryClassCharˢ)(nil)
}
func doEncodeCharˢ(e binary.Encoder, o *Charˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeCharˢ(d binary.Decoder, o *Charˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipCharˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCharˢ) ID() binary.ID      { return binaryIDCharˢ }
func (*binaryClassCharˢ) New() binary.Object { return &Charˢ{} }
func (*binaryClassCharˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCharˢ(e, obj.(*Charˢ))
}
func (*binaryClassCharˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Charˢ{}
	return obj, doDecodeCharˢ(d, obj)
}
func (*binaryClassCharˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCharˢ(d, obj.(*Charˢ))
}
func (*binaryClassCharˢ) Skip(d binary.Decoder) error { return doSkipCharˢ(d) }
func (*binaryClassCharˢ) Schema() *schema.Class       { return schemaCharˢ }

var schemaCharˢ = &schema.Class{
	TypeID:  binaryIDCharˢ,
	Package: "test",
	Name:    "Charˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassCharᵖ struct{}

func (*Charᵖ) Class() binary.Class {
	return (*binaryClassCharᵖ)(nil)
}
func doEncodeCharᵖ(e binary.Encoder, o *Charᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeCharᵖ(d binary.Decoder, o *Charᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipCharᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCharᵖ) ID() binary.ID      { return binaryIDCharᵖ }
func (*binaryClassCharᵖ) New() binary.Object { return &Charᵖ{} }
func (*binaryClassCharᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCharᵖ(e, obj.(*Charᵖ))
}
func (*binaryClassCharᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Charᵖ{}
	return obj, doDecodeCharᵖ(d, obj)
}
func (*binaryClassCharᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCharᵖ(d, obj.(*Charᵖ))
}
func (*binaryClassCharᵖ) Skip(d binary.Decoder) error { return doSkipCharᵖ(d) }
func (*binaryClassCharᵖ) Schema() *schema.Class       { return schemaCharᵖ }

var schemaCharᵖ = &schema.Class{
	TypeID:  binaryIDCharᵖ,
	Package: "test",
	Name:    "Charᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassCharᵖˢ struct{}

func (*Charᵖˢ) Class() binary.Class {
	return (*binaryClassCharᵖˢ)(nil)
}
func doEncodeCharᵖˢ(e binary.Encoder, o *Charᵖˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeCharᵖˢ(d binary.Decoder, o *Charᵖˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipCharᵖˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCharᵖˢ) ID() binary.ID      { return binaryIDCharᵖˢ }
func (*binaryClassCharᵖˢ) New() binary.Object { return &Charᵖˢ{} }
func (*binaryClassCharᵖˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCharᵖˢ(e, obj.(*Charᵖˢ))
}
func (*binaryClassCharᵖˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Charᵖˢ{}
	return obj, doDecodeCharᵖˢ(d, obj)
}
func (*binaryClassCharᵖˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCharᵖˢ(d, obj.(*Charᵖˢ))
}
func (*binaryClassCharᵖˢ) Skip(d binary.Decoder) error { return doSkipCharᵖˢ(d) }
func (*binaryClassCharᵖˢ) Schema() *schema.Class       { return schemaCharᵖˢ }

var schemaCharᵖˢ = &schema.Class{
	TypeID:  binaryIDCharᵖˢ,
	Package: "test",
	Name:    "Charᵖˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassCharᵖᵖ struct{}

func (*Charᵖᵖ) Class() binary.Class {
	return (*binaryClassCharᵖᵖ)(nil)
}
func doEncodeCharᵖᵖ(e binary.Encoder, o *Charᵖᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeCharᵖᵖ(d binary.Decoder, o *Charᵖᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipCharᵖᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCharᵖᵖ) ID() binary.ID      { return binaryIDCharᵖᵖ }
func (*binaryClassCharᵖᵖ) New() binary.Object { return &Charᵖᵖ{} }
func (*binaryClassCharᵖᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCharᵖᵖ(e, obj.(*Charᵖᵖ))
}
func (*binaryClassCharᵖᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Charᵖᵖ{}
	return obj, doDecodeCharᵖᵖ(d, obj)
}
func (*binaryClassCharᵖᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCharᵖᵖ(d, obj.(*Charᵖᵖ))
}
func (*binaryClassCharᵖᵖ) Skip(d binary.Decoder) error { return doSkipCharᵖᵖ(d) }
func (*binaryClassCharᵖᵖ) Schema() *schema.Class       { return schemaCharᵖᵖ }

var schemaCharᵖᵖ = &schema.Class{
	TypeID:  binaryIDCharᵖᵖ,
	Package: "test",
	Name:    "Charᵖᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassCmdBool struct{}

func (*CmdBool) Class() binary.Class {
	return (*binaryClassCmdBool)(nil)
}
func doEncodeCmdBool(e binary.Encoder, o *CmdBool) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Bool(o.Result); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdBool(d binary.Decoder, o *CmdBool) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Bool(); err != nil {
		return err
	} else {
		o.Result = bool(obj)
	}
	return nil
}
func doSkipCmdBool(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Bool(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdBool) ID() binary.ID      { return binaryIDCmdBool }
func (*binaryClassCmdBool) New() binary.Object { return &CmdBool{} }
func (*binaryClassCmdBool) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdBool(e, obj.(*CmdBool))
}
func (*binaryClassCmdBool) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdBool{}
	return obj, doDecodeCmdBool(d, obj)
}
func (*binaryClassCmdBool) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdBool(d, obj.(*CmdBool))
}
func (*binaryClassCmdBool) Skip(d binary.Decoder) error { return doSkipCmdBool(d) }
func (*binaryClassCmdBool) Schema() *schema.Class       { return schemaCmdBool }

var schemaCmdBool = &schema.Class{
	TypeID:  binaryIDCmdBool,
	Package: "test",
	Name:    "CmdBool",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Result", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
	},
}

type binaryClassCmdCharptrToString struct{}

func (*CmdCharptrToString) Class() binary.Class {
	return (*binaryClassCmdCharptrToString)(nil)
}
func doEncodeCmdCharptrToString(e binary.Encoder, o *CmdCharptrToString) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.S); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdCharptrToString(d binary.Decoder, o *CmdCharptrToString) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.S); err != nil {
		return err
	}
	return nil
}
func doSkipCmdCharptrToString(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*Charᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdCharptrToString) ID() binary.ID      { return binaryIDCmdCharptrToString }
func (*binaryClassCmdCharptrToString) New() binary.Object { return &CmdCharptrToString{} }
func (*binaryClassCmdCharptrToString) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdCharptrToString(e, obj.(*CmdCharptrToString))
}
func (*binaryClassCmdCharptrToString) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdCharptrToString{}
	return obj, doDecodeCmdCharptrToString(d, obj)
}
func (*binaryClassCmdCharptrToString) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdCharptrToString(d, obj.(*CmdCharptrToString))
}
func (*binaryClassCmdCharptrToString) Skip(d binary.Decoder) error { return doSkipCmdCharptrToString(d) }
func (*binaryClassCmdCharptrToString) Schema() *schema.Class       { return schemaCmdCharptrToString }

var schemaCmdCharptrToString = &schema.Class{
	TypeID:  binaryIDCmdCharptrToString,
	Package: "test",
	Name:    "CmdCharptrToString",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "S", Type: &schema.Struct{Name: "Charᵖ", ID: (*Charᵖ)(nil).Class().ID()}},
	},
}

type binaryClassCmdCharsliceToString struct{}

func (*CmdCharsliceToString) Class() binary.Class {
	return (*binaryClassCmdCharsliceToString)(nil)
}
func doEncodeCmdCharsliceToString(e binary.Encoder, o *CmdCharsliceToString) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.S); err != nil {
		return err
	}
	if err := e.Uint32(o.Len); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdCharsliceToString(d binary.Decoder, o *CmdCharsliceToString) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.S); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Len = uint32(obj)
	}
	return nil
}
func doSkipCmdCharsliceToString(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*Charᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdCharsliceToString) ID() binary.ID      { return binaryIDCmdCharsliceToString }
func (*binaryClassCmdCharsliceToString) New() binary.Object { return &CmdCharsliceToString{} }
func (*binaryClassCmdCharsliceToString) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdCharsliceToString(e, obj.(*CmdCharsliceToString))
}
func (*binaryClassCmdCharsliceToString) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdCharsliceToString{}
	return obj, doDecodeCmdCharsliceToString(d, obj)
}
func (*binaryClassCmdCharsliceToString) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdCharsliceToString(d, obj.(*CmdCharsliceToString))
}
func (*binaryClassCmdCharsliceToString) Skip(d binary.Decoder) error {
	return doSkipCmdCharsliceToString(d)
}
func (*binaryClassCmdCharsliceToString) Schema() *schema.Class { return schemaCmdCharsliceToString }

var schemaCmdCharsliceToString = &schema.Class{
	TypeID:  binaryIDCmdCharsliceToString,
	Package: "test",
	Name:    "CmdCharsliceToString",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "S", Type: &schema.Struct{Name: "Charᵖ", ID: (*Charᵖ)(nil).Class().ID()}},
		{Declared: "Len", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
	},
}

type binaryClassU8ᵖ struct{}

func (*U8ᵖ) Class() binary.Class {
	return (*binaryClassU8ᵖ)(nil)
}
func doEncodeU8ᵖ(e binary.Encoder, o *U8ᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeU8ᵖ(d binary.Decoder, o *U8ᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipU8ᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassU8ᵖ) ID() binary.ID      { return binaryIDU8ᵖ }
func (*binaryClassU8ᵖ) New() binary.Object { return &U8ᵖ{} }
func (*binaryClassU8ᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeU8ᵖ(e, obj.(*U8ᵖ))
}
func (*binaryClassU8ᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &U8ᵖ{}
	return obj, doDecodeU8ᵖ(d, obj)
}
func (*binaryClassU8ᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeU8ᵖ(d, obj.(*U8ᵖ))
}
func (*binaryClassU8ᵖ) Skip(d binary.Decoder) error { return doSkipU8ᵖ(d) }
func (*binaryClassU8ᵖ) Schema() *schema.Class       { return schemaU8ᵖ }

var schemaU8ᵖ = &schema.Class{
	TypeID:  binaryIDU8ᵖ,
	Package: "test",
	Name:    "U8ᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassCmdClone struct{}

func (*CmdClone) Class() binary.Class {
	return (*binaryClassCmdClone)(nil)
}
func doEncodeCmdClone(e binary.Encoder, o *CmdClone) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.Src); err != nil {
		return err
	}
	if err := e.Uint32(o.Cnt); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdClone(d binary.Decoder, o *CmdClone) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.Src); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Cnt = uint32(obj)
	}
	return nil
}
func doSkipCmdClone(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*U8ᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdClone) ID() binary.ID      { return binaryIDCmdClone }
func (*binaryClassCmdClone) New() binary.Object { return &CmdClone{} }
func (*binaryClassCmdClone) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdClone(e, obj.(*CmdClone))
}
func (*binaryClassCmdClone) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdClone{}
	return obj, doDecodeCmdClone(d, obj)
}
func (*binaryClassCmdClone) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdClone(d, obj.(*CmdClone))
}
func (*binaryClassCmdClone) Skip(d binary.Decoder) error { return doSkipCmdClone(d) }
func (*binaryClassCmdClone) Schema() *schema.Class       { return schemaCmdClone }

var schemaCmdClone = &schema.Class{
	TypeID:  binaryIDCmdClone,
	Package: "test",
	Name:    "CmdClone",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Src", Type: &schema.Struct{Name: "U8ᵖ", ID: (*U8ᵖ)(nil).Class().ID()}},
		{Declared: "Cnt", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
	},
}

type binaryClassCmdCopy struct{}

func (*CmdCopy) Class() binary.Class {
	return (*binaryClassCmdCopy)(nil)
}
func doEncodeCmdCopy(e binary.Encoder, o *CmdCopy) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.Src); err != nil {
		return err
	}
	if err := e.Uint32(o.Cnt); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdCopy(d binary.Decoder, o *CmdCopy) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.Src); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Cnt = uint32(obj)
	}
	return nil
}
func doSkipCmdCopy(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*U8ᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdCopy) ID() binary.ID      { return binaryIDCmdCopy }
func (*binaryClassCmdCopy) New() binary.Object { return &CmdCopy{} }
func (*binaryClassCmdCopy) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdCopy(e, obj.(*CmdCopy))
}
func (*binaryClassCmdCopy) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdCopy{}
	return obj, doDecodeCmdCopy(d, obj)
}
func (*binaryClassCmdCopy) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdCopy(d, obj.(*CmdCopy))
}
func (*binaryClassCmdCopy) Skip(d binary.Decoder) error { return doSkipCmdCopy(d) }
func (*binaryClassCmdCopy) Schema() *schema.Class       { return schemaCmdCopy }

var schemaCmdCopy = &schema.Class{
	TypeID:  binaryIDCmdCopy,
	Package: "test",
	Name:    "CmdCopy",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Src", Type: &schema.Struct{Name: "U8ᵖ", ID: (*U8ᵖ)(nil).Class().ID()}},
		{Declared: "Cnt", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
	},
}

type binaryClassCmdF32 struct{}

func (*CmdF32) Class() binary.Class {
	return (*binaryClassCmdF32)(nil)
}
func doEncodeCmdF32(e binary.Encoder, o *CmdF32) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Float32(o.Result); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdF32(d binary.Decoder, o *CmdF32) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.Result = float32(obj)
	}
	return nil
}
func doSkipCmdF32(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdF32) ID() binary.ID      { return binaryIDCmdF32 }
func (*binaryClassCmdF32) New() binary.Object { return &CmdF32{} }
func (*binaryClassCmdF32) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdF32(e, obj.(*CmdF32))
}
func (*binaryClassCmdF32) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdF32{}
	return obj, doDecodeCmdF32(d, obj)
}
func (*binaryClassCmdF32) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdF32(d, obj.(*CmdF32))
}
func (*binaryClassCmdF32) Skip(d binary.Decoder) error { return doSkipCmdF32(d) }
func (*binaryClassCmdF32) Schema() *schema.Class       { return schemaCmdF32 }

var schemaCmdF32 = &schema.Class{
	TypeID:  binaryIDCmdF32,
	Package: "test",
	Name:    "CmdF32",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Result", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
	},
}

type binaryClassCmdF64 struct{}

func (*CmdF64) Class() binary.Class {
	return (*binaryClassCmdF64)(nil)
}
func doEncodeCmdF64(e binary.Encoder, o *CmdF64) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Float64(o.Result); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdF64(d binary.Decoder, o *CmdF64) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Float64(); err != nil {
		return err
	} else {
		o.Result = float64(obj)
	}
	return nil
}
func doSkipCmdF64(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Float64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdF64) ID() binary.ID      { return binaryIDCmdF64 }
func (*binaryClassCmdF64) New() binary.Object { return &CmdF64{} }
func (*binaryClassCmdF64) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdF64(e, obj.(*CmdF64))
}
func (*binaryClassCmdF64) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdF64{}
	return obj, doDecodeCmdF64(d, obj)
}
func (*binaryClassCmdF64) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdF64(d, obj.(*CmdF64))
}
func (*binaryClassCmdF64) Skip(d binary.Decoder) error { return doSkipCmdF64(d) }
func (*binaryClassCmdF64) Schema() *schema.Class       { return schemaCmdF64 }

var schemaCmdF64 = &schema.Class{
	TypeID:  binaryIDCmdF64,
	Package: "test",
	Name:    "CmdF64",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Result", Type: &schema.Primitive{Name: "float64", Method: schema.Float64}},
	},
}

type binaryClassCmdMake struct{}

func (*CmdMake) Class() binary.Class {
	return (*binaryClassCmdMake)(nil)
}
func doEncodeCmdMake(e binary.Encoder, o *CmdMake) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(o.Cnt); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdMake(d binary.Decoder, o *CmdMake) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Cnt = uint32(obj)
	}
	return nil
}
func doSkipCmdMake(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdMake) ID() binary.ID      { return binaryIDCmdMake }
func (*binaryClassCmdMake) New() binary.Object { return &CmdMake{} }
func (*binaryClassCmdMake) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdMake(e, obj.(*CmdMake))
}
func (*binaryClassCmdMake) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdMake{}
	return obj, doDecodeCmdMake(d, obj)
}
func (*binaryClassCmdMake) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdMake(d, obj.(*CmdMake))
}
func (*binaryClassCmdMake) Skip(d binary.Decoder) error { return doSkipCmdMake(d) }
func (*binaryClassCmdMake) Schema() *schema.Class       { return schemaCmdMake }

var schemaCmdMake = &schema.Class{
	TypeID:  binaryIDCmdMake,
	Package: "test",
	Name:    "CmdMake",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Cnt", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
	},
}

type binaryClassVoidᵖ struct{}

func (*Voidᵖ) Class() binary.Class {
	return (*binaryClassVoidᵖ)(nil)
}
func doEncodeVoidᵖ(e binary.Encoder, o *Voidᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeVoidᵖ(d binary.Decoder, o *Voidᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipVoidᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassVoidᵖ) ID() binary.ID      { return binaryIDVoidᵖ }
func (*binaryClassVoidᵖ) New() binary.Object { return &Voidᵖ{} }
func (*binaryClassVoidᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeVoidᵖ(e, obj.(*Voidᵖ))
}
func (*binaryClassVoidᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Voidᵖ{}
	return obj, doDecodeVoidᵖ(d, obj)
}
func (*binaryClassVoidᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeVoidᵖ(d, obj.(*Voidᵖ))
}
func (*binaryClassVoidᵖ) Skip(d binary.Decoder) error { return doSkipVoidᵖ(d) }
func (*binaryClassVoidᵖ) Schema() *schema.Class       { return schemaVoidᵖ }

var schemaVoidᵖ = &schema.Class{
	TypeID:  binaryIDVoidᵖ,
	Package: "test",
	Name:    "Voidᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassCmdPointer struct{}

func (*CmdPointer) Class() binary.Class {
	return (*binaryClassCmdPointer)(nil)
}
func doEncodeCmdPointer(e binary.Encoder, o *CmdPointer) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.Result); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdPointer(d binary.Decoder, o *CmdPointer) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.Result); err != nil {
		return err
	}
	return nil
}
func doSkipCmdPointer(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*Voidᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdPointer) ID() binary.ID      { return binaryIDCmdPointer }
func (*binaryClassCmdPointer) New() binary.Object { return &CmdPointer{} }
func (*binaryClassCmdPointer) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdPointer(e, obj.(*CmdPointer))
}
func (*binaryClassCmdPointer) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdPointer{}
	return obj, doDecodeCmdPointer(d, obj)
}
func (*binaryClassCmdPointer) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdPointer(d, obj.(*CmdPointer))
}
func (*binaryClassCmdPointer) Skip(d binary.Decoder) error { return doSkipCmdPointer(d) }
func (*binaryClassCmdPointer) Schema() *schema.Class       { return schemaCmdPointer }

var schemaCmdPointer = &schema.Class{
	TypeID:  binaryIDCmdPointer,
	Package: "test",
	Name:    "CmdPointer",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Result", Type: &schema.Struct{Name: "Voidᵖ", ID: (*Voidᵖ)(nil).Class().ID()}},
	},
}

type binaryClassCmdRemapped struct{}

func (*CmdRemapped) Class() binary.Class {
	return (*binaryClassCmdRemapped)(nil)
}
func doEncodeCmdRemapped(e binary.Encoder, o *CmdRemapped) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.Result)); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdRemapped(d binary.Decoder, o *CmdRemapped) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Result = remapped(obj)
	}
	return nil
}
func doSkipCmdRemapped(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdRemapped) ID() binary.ID      { return binaryIDCmdRemapped }
func (*binaryClassCmdRemapped) New() binary.Object { return &CmdRemapped{} }
func (*binaryClassCmdRemapped) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdRemapped(e, obj.(*CmdRemapped))
}
func (*binaryClassCmdRemapped) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdRemapped{}
	return obj, doDecodeCmdRemapped(d, obj)
}
func (*binaryClassCmdRemapped) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdRemapped(d, obj.(*CmdRemapped))
}
func (*binaryClassCmdRemapped) Skip(d binary.Decoder) error { return doSkipCmdRemapped(d) }
func (*binaryClassCmdRemapped) Schema() *schema.Class       { return schemaCmdRemapped }

var schemaCmdRemapped = &schema.Class{
	TypeID:  binaryIDCmdRemapped,
	Package: "test",
	Name:    "CmdRemapped",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Result", Type: &schema.Primitive{Name: "remapped", Method: schema.Uint32}},
	},
}

type binaryClassCmdS16 struct{}

func (*CmdS16) Class() binary.Class {
	return (*binaryClassCmdS16)(nil)
}
func doEncodeCmdS16(e binary.Encoder, o *CmdS16) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int16(o.Result); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdS16(d binary.Decoder, o *CmdS16) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int16(); err != nil {
		return err
	} else {
		o.Result = int16(obj)
	}
	return nil
}
func doSkipCmdS16(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int16(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdS16) ID() binary.ID      { return binaryIDCmdS16 }
func (*binaryClassCmdS16) New() binary.Object { return &CmdS16{} }
func (*binaryClassCmdS16) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdS16(e, obj.(*CmdS16))
}
func (*binaryClassCmdS16) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdS16{}
	return obj, doDecodeCmdS16(d, obj)
}
func (*binaryClassCmdS16) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdS16(d, obj.(*CmdS16))
}
func (*binaryClassCmdS16) Skip(d binary.Decoder) error { return doSkipCmdS16(d) }
func (*binaryClassCmdS16) Schema() *schema.Class       { return schemaCmdS16 }

var schemaCmdS16 = &schema.Class{
	TypeID:  binaryIDCmdS16,
	Package: "test",
	Name:    "CmdS16",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Result", Type: &schema.Primitive{Name: "int16", Method: schema.Int16}},
	},
}

type binaryClassCmdS32 struct{}

func (*CmdS32) Class() binary.Class {
	return (*binaryClassCmdS32)(nil)
}
func doEncodeCmdS32(e binary.Encoder, o *CmdS32) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(o.Result); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdS32(d binary.Decoder, o *CmdS32) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Result = int32(obj)
	}
	return nil
}
func doSkipCmdS32(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdS32) ID() binary.ID      { return binaryIDCmdS32 }
func (*binaryClassCmdS32) New() binary.Object { return &CmdS32{} }
func (*binaryClassCmdS32) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdS32(e, obj.(*CmdS32))
}
func (*binaryClassCmdS32) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdS32{}
	return obj, doDecodeCmdS32(d, obj)
}
func (*binaryClassCmdS32) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdS32(d, obj.(*CmdS32))
}
func (*binaryClassCmdS32) Skip(d binary.Decoder) error { return doSkipCmdS32(d) }
func (*binaryClassCmdS32) Schema() *schema.Class       { return schemaCmdS32 }

var schemaCmdS32 = &schema.Class{
	TypeID:  binaryIDCmdS32,
	Package: "test",
	Name:    "CmdS32",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Result", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
	},
}

type binaryClassCmdS64 struct{}

func (*CmdS64) Class() binary.Class {
	return (*binaryClassCmdS64)(nil)
}
func doEncodeCmdS64(e binary.Encoder, o *CmdS64) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int64(o.Result); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdS64(d binary.Decoder, o *CmdS64) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int64(); err != nil {
		return err
	} else {
		o.Result = int64(obj)
	}
	return nil
}
func doSkipCmdS64(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdS64) ID() binary.ID      { return binaryIDCmdS64 }
func (*binaryClassCmdS64) New() binary.Object { return &CmdS64{} }
func (*binaryClassCmdS64) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdS64(e, obj.(*CmdS64))
}
func (*binaryClassCmdS64) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdS64{}
	return obj, doDecodeCmdS64(d, obj)
}
func (*binaryClassCmdS64) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdS64(d, obj.(*CmdS64))
}
func (*binaryClassCmdS64) Skip(d binary.Decoder) error { return doSkipCmdS64(d) }
func (*binaryClassCmdS64) Schema() *schema.Class       { return schemaCmdS64 }

var schemaCmdS64 = &schema.Class{
	TypeID:  binaryIDCmdS64,
	Package: "test",
	Name:    "CmdS64",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Result", Type: &schema.Primitive{Name: "int64", Method: schema.Int64}},
	},
}

type binaryClassCmdS8 struct{}

func (*CmdS8) Class() binary.Class {
	return (*binaryClassCmdS8)(nil)
}
func doEncodeCmdS8(e binary.Encoder, o *CmdS8) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int8(o.Result); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdS8(d binary.Decoder, o *CmdS8) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int8(); err != nil {
		return err
	} else {
		o.Result = int8(obj)
	}
	return nil
}
func doSkipCmdS8(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdS8) ID() binary.ID      { return binaryIDCmdS8 }
func (*binaryClassCmdS8) New() binary.Object { return &CmdS8{} }
func (*binaryClassCmdS8) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdS8(e, obj.(*CmdS8))
}
func (*binaryClassCmdS8) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdS8{}
	return obj, doDecodeCmdS8(d, obj)
}
func (*binaryClassCmdS8) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdS8(d, obj.(*CmdS8))
}
func (*binaryClassCmdS8) Skip(d binary.Decoder) error { return doSkipCmdS8(d) }
func (*binaryClassCmdS8) Schema() *schema.Class       { return schemaCmdS8 }

var schemaCmdS8 = &schema.Class{
	TypeID:  binaryIDCmdS8,
	Package: "test",
	Name:    "CmdS8",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Result", Type: &schema.Primitive{Name: "int8", Method: schema.Int8}},
	},
}

type binaryClassU16ᵖ struct{}

func (*U16ᵖ) Class() binary.Class {
	return (*binaryClassU16ᵖ)(nil)
}
func doEncodeU16ᵖ(e binary.Encoder, o *U16ᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeU16ᵖ(d binary.Decoder, o *U16ᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipU16ᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassU16ᵖ) ID() binary.ID      { return binaryIDU16ᵖ }
func (*binaryClassU16ᵖ) New() binary.Object { return &U16ᵖ{} }
func (*binaryClassU16ᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeU16ᵖ(e, obj.(*U16ᵖ))
}
func (*binaryClassU16ᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &U16ᵖ{}
	return obj, doDecodeU16ᵖ(d, obj)
}
func (*binaryClassU16ᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeU16ᵖ(d, obj.(*U16ᵖ))
}
func (*binaryClassU16ᵖ) Skip(d binary.Decoder) error { return doSkipU16ᵖ(d) }
func (*binaryClassU16ᵖ) Schema() *schema.Class       { return schemaU16ᵖ }

var schemaU16ᵖ = &schema.Class{
	TypeID:  binaryIDU16ᵖ,
	Package: "test",
	Name:    "U16ᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassCmdSliceCasts struct{}

func (*CmdSliceCasts) Class() binary.Class {
	return (*binaryClassCmdSliceCasts)(nil)
}
func doEncodeCmdSliceCasts(e binary.Encoder, o *CmdSliceCasts) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.S); err != nil {
		return err
	}
	if err := e.Uint32(o.L); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdSliceCasts(d binary.Decoder, o *CmdSliceCasts) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.S); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.L = uint32(obj)
	}
	return nil
}
func doSkipCmdSliceCasts(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*U16ᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdSliceCasts) ID() binary.ID      { return binaryIDCmdSliceCasts }
func (*binaryClassCmdSliceCasts) New() binary.Object { return &CmdSliceCasts{} }
func (*binaryClassCmdSliceCasts) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdSliceCasts(e, obj.(*CmdSliceCasts))
}
func (*binaryClassCmdSliceCasts) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdSliceCasts{}
	return obj, doDecodeCmdSliceCasts(d, obj)
}
func (*binaryClassCmdSliceCasts) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdSliceCasts(d, obj.(*CmdSliceCasts))
}
func (*binaryClassCmdSliceCasts) Skip(d binary.Decoder) error { return doSkipCmdSliceCasts(d) }
func (*binaryClassCmdSliceCasts) Schema() *schema.Class       { return schemaCmdSliceCasts }

var schemaCmdSliceCasts = &schema.Class{
	TypeID:  binaryIDCmdSliceCasts,
	Package: "test",
	Name:    "CmdSliceCasts",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "S", Type: &schema.Struct{Name: "U16ᵖ", ID: (*U16ᵖ)(nil).Class().ID()}},
		{Declared: "L", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
	},
}

type binaryClassCmdString struct{}

func (*CmdString) Class() binary.Class {
	return (*binaryClassCmdString)(nil)
}
func doEncodeCmdString(e binary.Encoder, o *CmdString) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.String(o.Result); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdString(d binary.Decoder, o *CmdString) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.String(); err != nil {
		return err
	} else {
		o.Result = string(obj)
	}
	return nil
}
func doSkipCmdString(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipString(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdString) ID() binary.ID      { return binaryIDCmdString }
func (*binaryClassCmdString) New() binary.Object { return &CmdString{} }
func (*binaryClassCmdString) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdString(e, obj.(*CmdString))
}
func (*binaryClassCmdString) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdString{}
	return obj, doDecodeCmdString(d, obj)
}
func (*binaryClassCmdString) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdString(d, obj.(*CmdString))
}
func (*binaryClassCmdString) Skip(d binary.Decoder) error { return doSkipCmdString(d) }
func (*binaryClassCmdString) Schema() *schema.Class       { return schemaCmdString }

var schemaCmdString = &schema.Class{
	TypeID:  binaryIDCmdString,
	Package: "test",
	Name:    "CmdString",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Result", Type: &schema.Primitive{Name: "string", Method: schema.String}},
	},
}

type binaryClassCmdU16 struct{}

func (*CmdU16) Class() binary.Class {
	return (*binaryClassCmdU16)(nil)
}
func doEncodeCmdU16(e binary.Encoder, o *CmdU16) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint16(o.Result); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdU16(d binary.Decoder, o *CmdU16) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint16(); err != nil {
		return err
	} else {
		o.Result = uint16(obj)
	}
	return nil
}
func doSkipCmdU16(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint16(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdU16) ID() binary.ID      { return binaryIDCmdU16 }
func (*binaryClassCmdU16) New() binary.Object { return &CmdU16{} }
func (*binaryClassCmdU16) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdU16(e, obj.(*CmdU16))
}
func (*binaryClassCmdU16) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdU16{}
	return obj, doDecodeCmdU16(d, obj)
}
func (*binaryClassCmdU16) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdU16(d, obj.(*CmdU16))
}
func (*binaryClassCmdU16) Skip(d binary.Decoder) error { return doSkipCmdU16(d) }
func (*binaryClassCmdU16) Schema() *schema.Class       { return schemaCmdU16 }

var schemaCmdU16 = &schema.Class{
	TypeID:  binaryIDCmdU16,
	Package: "test",
	Name:    "CmdU16",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Result", Type: &schema.Primitive{Name: "uint16", Method: schema.Uint16}},
	},
}

type binaryClassCmdU32 struct{}

func (*CmdU32) Class() binary.Class {
	return (*binaryClassCmdU32)(nil)
}
func doEncodeCmdU32(e binary.Encoder, o *CmdU32) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(o.Result); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdU32(d binary.Decoder, o *CmdU32) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Result = uint32(obj)
	}
	return nil
}
func doSkipCmdU32(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdU32) ID() binary.ID      { return binaryIDCmdU32 }
func (*binaryClassCmdU32) New() binary.Object { return &CmdU32{} }
func (*binaryClassCmdU32) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdU32(e, obj.(*CmdU32))
}
func (*binaryClassCmdU32) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdU32{}
	return obj, doDecodeCmdU32(d, obj)
}
func (*binaryClassCmdU32) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdU32(d, obj.(*CmdU32))
}
func (*binaryClassCmdU32) Skip(d binary.Decoder) error { return doSkipCmdU32(d) }
func (*binaryClassCmdU32) Schema() *schema.Class       { return schemaCmdU32 }

var schemaCmdU32 = &schema.Class{
	TypeID:  binaryIDCmdU32,
	Package: "test",
	Name:    "CmdU32",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Result", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
	},
}

type binaryClassCmdU64 struct{}

func (*CmdU64) Class() binary.Class {
	return (*binaryClassCmdU64)(nil)
}
func doEncodeCmdU64(e binary.Encoder, o *CmdU64) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint64(o.Result); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdU64(d binary.Decoder, o *CmdU64) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.Result = uint64(obj)
	}
	return nil
}
func doSkipCmdU64(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdU64) ID() binary.ID      { return binaryIDCmdU64 }
func (*binaryClassCmdU64) New() binary.Object { return &CmdU64{} }
func (*binaryClassCmdU64) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdU64(e, obj.(*CmdU64))
}
func (*binaryClassCmdU64) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdU64{}
	return obj, doDecodeCmdU64(d, obj)
}
func (*binaryClassCmdU64) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdU64(d, obj.(*CmdU64))
}
func (*binaryClassCmdU64) Skip(d binary.Decoder) error { return doSkipCmdU64(d) }
func (*binaryClassCmdU64) Schema() *schema.Class       { return schemaCmdU64 }

var schemaCmdU64 = &schema.Class{
	TypeID:  binaryIDCmdU64,
	Package: "test",
	Name:    "CmdU64",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Result", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
	},
}

type binaryClassCmdU8 struct{}

func (*CmdU8) Class() binary.Class {
	return (*binaryClassCmdU8)(nil)
}
func doEncodeCmdU8(e binary.Encoder, o *CmdU8) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint8(o.Result); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdU8(d binary.Decoder, o *CmdU8) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.Result = uint8(obj)
	}
	return nil
}
func doSkipCmdU8(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdU8) ID() binary.ID      { return binaryIDCmdU8 }
func (*binaryClassCmdU8) New() binary.Object { return &CmdU8{} }
func (*binaryClassCmdU8) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdU8(e, obj.(*CmdU8))
}
func (*binaryClassCmdU8) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdU8{}
	return obj, doDecodeCmdU8(d, obj)
}
func (*binaryClassCmdU8) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdU8(d, obj.(*CmdU8))
}
func (*binaryClassCmdU8) Skip(d binary.Decoder) error { return doSkipCmdU8(d) }
func (*binaryClassCmdU8) Schema() *schema.Class       { return schemaCmdU8 }

var schemaCmdU8 = &schema.Class{
	TypeID:  binaryIDCmdU8,
	Package: "test",
	Name:    "CmdU8",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Result", Type: &schema.Primitive{Name: "uint8", Method: schema.Uint8}},
	},
}

type binaryClassCmdUnknownRet struct{}

func (*CmdUnknownRet) Class() binary.Class {
	return (*binaryClassCmdUnknownRet)(nil)
}
func doEncodeCmdUnknownRet(e binary.Encoder, o *CmdUnknownRet) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int64(o.Result); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdUnknownRet(d binary.Decoder, o *CmdUnknownRet) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int64(); err != nil {
		return err
	} else {
		o.Result = int64(obj)
	}
	return nil
}
func doSkipCmdUnknownRet(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdUnknownRet) ID() binary.ID      { return binaryIDCmdUnknownRet }
func (*binaryClassCmdUnknownRet) New() binary.Object { return &CmdUnknownRet{} }
func (*binaryClassCmdUnknownRet) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdUnknownRet(e, obj.(*CmdUnknownRet))
}
func (*binaryClassCmdUnknownRet) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdUnknownRet{}
	return obj, doDecodeCmdUnknownRet(d, obj)
}
func (*binaryClassCmdUnknownRet) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdUnknownRet(d, obj.(*CmdUnknownRet))
}
func (*binaryClassCmdUnknownRet) Skip(d binary.Decoder) error { return doSkipCmdUnknownRet(d) }
func (*binaryClassCmdUnknownRet) Schema() *schema.Class       { return schemaCmdUnknownRet }

var schemaCmdUnknownRet = &schema.Class{
	TypeID:  binaryIDCmdUnknownRet,
	Package: "test",
	Name:    "CmdUnknownRet",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "Result", Type: &schema.Primitive{Name: "int64", Method: schema.Int64}},
	},
}

type binaryClassIntᵖ struct{}

func (*Intᵖ) Class() binary.Class {
	return (*binaryClassIntᵖ)(nil)
}
func doEncodeIntᵖ(e binary.Encoder, o *Intᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeIntᵖ(d binary.Decoder, o *Intᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipIntᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassIntᵖ) ID() binary.ID      { return binaryIDIntᵖ }
func (*binaryClassIntᵖ) New() binary.Object { return &Intᵖ{} }
func (*binaryClassIntᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeIntᵖ(e, obj.(*Intᵖ))
}
func (*binaryClassIntᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Intᵖ{}
	return obj, doDecodeIntᵖ(d, obj)
}
func (*binaryClassIntᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeIntᵖ(d, obj.(*Intᵖ))
}
func (*binaryClassIntᵖ) Skip(d binary.Decoder) error { return doSkipIntᵖ(d) }
func (*binaryClassIntᵖ) Schema() *schema.Class       { return schemaIntᵖ }

var schemaIntᵖ = &schema.Class{
	TypeID:  binaryIDIntᵖ,
	Package: "test",
	Name:    "Intᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassCmdUnknownWritePtr struct{}

func (*CmdUnknownWritePtr) Class() binary.Class {
	return (*binaryClassCmdUnknownWritePtr)(nil)
}
func doEncodeCmdUnknownWritePtr(e binary.Encoder, o *CmdUnknownWritePtr) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.P); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdUnknownWritePtr(d binary.Decoder, o *CmdUnknownWritePtr) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.P); err != nil {
		return err
	}
	return nil
}
func doSkipCmdUnknownWritePtr(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*Intᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdUnknownWritePtr) ID() binary.ID      { return binaryIDCmdUnknownWritePtr }
func (*binaryClassCmdUnknownWritePtr) New() binary.Object { return &CmdUnknownWritePtr{} }
func (*binaryClassCmdUnknownWritePtr) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdUnknownWritePtr(e, obj.(*CmdUnknownWritePtr))
}
func (*binaryClassCmdUnknownWritePtr) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdUnknownWritePtr{}
	return obj, doDecodeCmdUnknownWritePtr(d, obj)
}
func (*binaryClassCmdUnknownWritePtr) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdUnknownWritePtr(d, obj.(*CmdUnknownWritePtr))
}
func (*binaryClassCmdUnknownWritePtr) Skip(d binary.Decoder) error { return doSkipCmdUnknownWritePtr(d) }
func (*binaryClassCmdUnknownWritePtr) Schema() *schema.Class       { return schemaCmdUnknownWritePtr }

var schemaCmdUnknownWritePtr = &schema.Class{
	TypeID:  binaryIDCmdUnknownWritePtr,
	Package: "test",
	Name:    "CmdUnknownWritePtr",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "P", Type: &schema.Struct{Name: "Intᵖ", ID: (*Intᵖ)(nil).Class().ID()}},
	},
}

type binaryClassCmdUnknownWriteSlice struct{}

func (*CmdUnknownWriteSlice) Class() binary.Class {
	return (*binaryClassCmdUnknownWriteSlice)(nil)
}
func doEncodeCmdUnknownWriteSlice(e binary.Encoder, o *CmdUnknownWriteSlice) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdUnknownWriteSlice(d binary.Decoder, o *CmdUnknownWriteSlice) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doSkipCmdUnknownWriteSlice(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*Intᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdUnknownWriteSlice) ID() binary.ID      { return binaryIDCmdUnknownWriteSlice }
func (*binaryClassCmdUnknownWriteSlice) New() binary.Object { return &CmdUnknownWriteSlice{} }
func (*binaryClassCmdUnknownWriteSlice) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdUnknownWriteSlice(e, obj.(*CmdUnknownWriteSlice))
}
func (*binaryClassCmdUnknownWriteSlice) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdUnknownWriteSlice{}
	return obj, doDecodeCmdUnknownWriteSlice(d, obj)
}
func (*binaryClassCmdUnknownWriteSlice) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdUnknownWriteSlice(d, obj.(*CmdUnknownWriteSlice))
}
func (*binaryClassCmdUnknownWriteSlice) Skip(d binary.Decoder) error {
	return doSkipCmdUnknownWriteSlice(d)
}
func (*binaryClassCmdUnknownWriteSlice) Schema() *schema.Class { return schemaCmdUnknownWriteSlice }

var schemaCmdUnknownWriteSlice = &schema.Class{
	TypeID:  binaryIDCmdUnknownWriteSlice,
	Package: "test",
	Name:    "CmdUnknownWriteSlice",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "A", Type: &schema.Struct{Name: "Intᵖ", ID: (*Intᵖ)(nil).Class().ID()}},
	},
}

type binaryClassCmdVoid struct{}

func (*CmdVoid) Class() binary.Class {
	return (*binaryClassCmdVoid)(nil)
}
func doEncodeCmdVoid(e binary.Encoder, o *CmdVoid) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdVoid(d binary.Decoder, o *CmdVoid) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	return nil
}
func doSkipCmdVoid(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdVoid) ID() binary.ID      { return binaryIDCmdVoid }
func (*binaryClassCmdVoid) New() binary.Object { return &CmdVoid{} }
func (*binaryClassCmdVoid) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdVoid(e, obj.(*CmdVoid))
}
func (*binaryClassCmdVoid) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdVoid{}
	return obj, doDecodeCmdVoid(d, obj)
}
func (*binaryClassCmdVoid) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdVoid(d, obj.(*CmdVoid))
}
func (*binaryClassCmdVoid) Skip(d binary.Decoder) error { return doSkipCmdVoid(d) }
func (*binaryClassCmdVoid) Schema() *schema.Class       { return schemaCmdVoid }

var schemaCmdVoid = &schema.Class{
	TypeID:  binaryIDCmdVoid,
	Package: "test",
	Name:    "CmdVoid",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
	},
}

type binaryClassU32ᵖ struct{}

func (*U32ᵖ) Class() binary.Class {
	return (*binaryClassU32ᵖ)(nil)
}
func doEncodeU32ᵖ(e binary.Encoder, o *U32ᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeU32ᵖ(d binary.Decoder, o *U32ᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipU32ᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassU32ᵖ) ID() binary.ID      { return binaryIDU32ᵖ }
func (*binaryClassU32ᵖ) New() binary.Object { return &U32ᵖ{} }
func (*binaryClassU32ᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeU32ᵖ(e, obj.(*U32ᵖ))
}
func (*binaryClassU32ᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &U32ᵖ{}
	return obj, doDecodeU32ᵖ(d, obj)
}
func (*binaryClassU32ᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeU32ᵖ(d, obj.(*U32ᵖ))
}
func (*binaryClassU32ᵖ) Skip(d binary.Decoder) error { return doSkipU32ᵖ(d) }
func (*binaryClassU32ᵖ) Schema() *schema.Class       { return schemaU32ᵖ }

var schemaU32ᵖ = &schema.Class{
	TypeID:  binaryIDU32ᵖ,
	Package: "test",
	Name:    "U32ᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassCmdVoid3InArrays struct{}

func (*CmdVoid3InArrays) Class() binary.Class {
	return (*binaryClassCmdVoid3InArrays)(nil)
}
func doEncodeCmdVoid3InArrays(e binary.Encoder, o *CmdVoid3InArrays) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.A); err != nil {
		return err
	}
	if err := e.Value(&o.B); err != nil {
		return err
	}
	if err := e.Value(&o.C); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdVoid3InArrays(d binary.Decoder, o *CmdVoid3InArrays) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.A); err != nil {
		return err
	}
	if err := d.Value(&o.B); err != nil {
		return err
	}
	if err := d.Value(&o.C); err != nil {
		return err
	}
	return nil
}
func doSkipCmdVoid3InArrays(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*U8ᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*U32ᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*Intᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdVoid3InArrays) ID() binary.ID      { return binaryIDCmdVoid3InArrays }
func (*binaryClassCmdVoid3InArrays) New() binary.Object { return &CmdVoid3InArrays{} }
func (*binaryClassCmdVoid3InArrays) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdVoid3InArrays(e, obj.(*CmdVoid3InArrays))
}
func (*binaryClassCmdVoid3InArrays) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdVoid3InArrays{}
	return obj, doDecodeCmdVoid3InArrays(d, obj)
}
func (*binaryClassCmdVoid3InArrays) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdVoid3InArrays(d, obj.(*CmdVoid3InArrays))
}
func (*binaryClassCmdVoid3InArrays) Skip(d binary.Decoder) error { return doSkipCmdVoid3InArrays(d) }
func (*binaryClassCmdVoid3InArrays) Schema() *schema.Class       { return schemaCmdVoid3InArrays }

var schemaCmdVoid3InArrays = &schema.Class{
	TypeID:  binaryIDCmdVoid3InArrays,
	Package: "test",
	Name:    "CmdVoid3InArrays",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "A", Type: &schema.Struct{Name: "U8ᵖ", ID: (*U8ᵖ)(nil).Class().ID()}},
		{Declared: "B", Type: &schema.Struct{Name: "U32ᵖ", ID: (*U32ᵖ)(nil).Class().ID()}},
		{Declared: "C", Type: &schema.Struct{Name: "Intᵖ", ID: (*Intᵖ)(nil).Class().ID()}},
	},
}

type binaryClassCmdVoid3Remapped struct{}

func (*CmdVoid3Remapped) Class() binary.Class {
	return (*binaryClassCmdVoid3Remapped)(nil)
}
func doEncodeCmdVoid3Remapped(e binary.Encoder, o *CmdVoid3Remapped) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.A)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.B)); err != nil {
		return err
	}
	if err := e.Uint32(uint32(o.C)); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdVoid3Remapped(d binary.Decoder, o *CmdVoid3Remapped) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.A = remapped(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.B = remapped(obj)
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.C = remapped(obj)
	}
	return nil
}
func doSkipCmdVoid3Remapped(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdVoid3Remapped) ID() binary.ID      { return binaryIDCmdVoid3Remapped }
func (*binaryClassCmdVoid3Remapped) New() binary.Object { return &CmdVoid3Remapped{} }
func (*binaryClassCmdVoid3Remapped) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdVoid3Remapped(e, obj.(*CmdVoid3Remapped))
}
func (*binaryClassCmdVoid3Remapped) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdVoid3Remapped{}
	return obj, doDecodeCmdVoid3Remapped(d, obj)
}
func (*binaryClassCmdVoid3Remapped) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdVoid3Remapped(d, obj.(*CmdVoid3Remapped))
}
func (*binaryClassCmdVoid3Remapped) Skip(d binary.Decoder) error { return doSkipCmdVoid3Remapped(d) }
func (*binaryClassCmdVoid3Remapped) Schema() *schema.Class       { return schemaCmdVoid3Remapped }

var schemaCmdVoid3Remapped = &schema.Class{
	TypeID:  binaryIDCmdVoid3Remapped,
	Package: "test",
	Name:    "CmdVoid3Remapped",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "A", Type: &schema.Primitive{Name: "remapped", Method: schema.Uint32}},
		{Declared: "B", Type: &schema.Primitive{Name: "remapped", Method: schema.Uint32}},
		{Declared: "C", Type: &schema.Primitive{Name: "remapped", Method: schema.Uint32}},
	},
}

type binaryClassCmdVoid3Strings struct{}

func (*CmdVoid3Strings) Class() binary.Class {
	return (*binaryClassCmdVoid3Strings)(nil)
}
func doEncodeCmdVoid3Strings(e binary.Encoder, o *CmdVoid3Strings) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.String(o.A); err != nil {
		return err
	}
	if err := e.String(o.B); err != nil {
		return err
	}
	if err := e.String(o.C); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdVoid3Strings(d binary.Decoder, o *CmdVoid3Strings) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.String(); err != nil {
		return err
	} else {
		o.A = string(obj)
	}
	if obj, err := d.String(); err != nil {
		return err
	} else {
		o.B = string(obj)
	}
	if obj, err := d.String(); err != nil {
		return err
	} else {
		o.C = string(obj)
	}
	return nil
}
func doSkipCmdVoid3Strings(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipString(); err != nil {
		return err
	}
	if err := d.SkipString(); err != nil {
		return err
	}
	if err := d.SkipString(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdVoid3Strings) ID() binary.ID      { return binaryIDCmdVoid3Strings }
func (*binaryClassCmdVoid3Strings) New() binary.Object { return &CmdVoid3Strings{} }
func (*binaryClassCmdVoid3Strings) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdVoid3Strings(e, obj.(*CmdVoid3Strings))
}
func (*binaryClassCmdVoid3Strings) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdVoid3Strings{}
	return obj, doDecodeCmdVoid3Strings(d, obj)
}
func (*binaryClassCmdVoid3Strings) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdVoid3Strings(d, obj.(*CmdVoid3Strings))
}
func (*binaryClassCmdVoid3Strings) Skip(d binary.Decoder) error { return doSkipCmdVoid3Strings(d) }
func (*binaryClassCmdVoid3Strings) Schema() *schema.Class       { return schemaCmdVoid3Strings }

var schemaCmdVoid3Strings = &schema.Class{
	TypeID:  binaryIDCmdVoid3Strings,
	Package: "test",
	Name:    "CmdVoid3Strings",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "A", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		{Declared: "B", Type: &schema.Primitive{Name: "string", Method: schema.String}},
		{Declared: "C", Type: &schema.Primitive{Name: "string", Method: schema.String}},
	},
}

type binaryClassCmdVoidBool struct{}

func (*CmdVoidBool) Class() binary.Class {
	return (*binaryClassCmdVoidBool)(nil)
}
func doEncodeCmdVoidBool(e binary.Encoder, o *CmdVoidBool) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Bool(o.A); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdVoidBool(d binary.Decoder, o *CmdVoidBool) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Bool(); err != nil {
		return err
	} else {
		o.A = bool(obj)
	}
	return nil
}
func doSkipCmdVoidBool(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Bool(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdVoidBool) ID() binary.ID      { return binaryIDCmdVoidBool }
func (*binaryClassCmdVoidBool) New() binary.Object { return &CmdVoidBool{} }
func (*binaryClassCmdVoidBool) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdVoidBool(e, obj.(*CmdVoidBool))
}
func (*binaryClassCmdVoidBool) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdVoidBool{}
	return obj, doDecodeCmdVoidBool(d, obj)
}
func (*binaryClassCmdVoidBool) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdVoidBool(d, obj.(*CmdVoidBool))
}
func (*binaryClassCmdVoidBool) Skip(d binary.Decoder) error { return doSkipCmdVoidBool(d) }
func (*binaryClassCmdVoidBool) Schema() *schema.Class       { return schemaCmdVoidBool }

var schemaCmdVoidBool = &schema.Class{
	TypeID:  binaryIDCmdVoidBool,
	Package: "test",
	Name:    "CmdVoidBool",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "A", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}},
	},
}

type binaryClassCmdVoidF32 struct{}

func (*CmdVoidF32) Class() binary.Class {
	return (*binaryClassCmdVoidF32)(nil)
}
func doEncodeCmdVoidF32(e binary.Encoder, o *CmdVoidF32) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Float32(o.A); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdVoidF32(d binary.Decoder, o *CmdVoidF32) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Float32(); err != nil {
		return err
	} else {
		o.A = float32(obj)
	}
	return nil
}
func doSkipCmdVoidF32(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Float32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdVoidF32) ID() binary.ID      { return binaryIDCmdVoidF32 }
func (*binaryClassCmdVoidF32) New() binary.Object { return &CmdVoidF32{} }
func (*binaryClassCmdVoidF32) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdVoidF32(e, obj.(*CmdVoidF32))
}
func (*binaryClassCmdVoidF32) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdVoidF32{}
	return obj, doDecodeCmdVoidF32(d, obj)
}
func (*binaryClassCmdVoidF32) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdVoidF32(d, obj.(*CmdVoidF32))
}
func (*binaryClassCmdVoidF32) Skip(d binary.Decoder) error { return doSkipCmdVoidF32(d) }
func (*binaryClassCmdVoidF32) Schema() *schema.Class       { return schemaCmdVoidF32 }

var schemaCmdVoidF32 = &schema.Class{
	TypeID:  binaryIDCmdVoidF32,
	Package: "test",
	Name:    "CmdVoidF32",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "A", Type: &schema.Primitive{Name: "float32", Method: schema.Float32}},
	},
}

type binaryClassCmdVoidF64 struct{}

func (*CmdVoidF64) Class() binary.Class {
	return (*binaryClassCmdVoidF64)(nil)
}
func doEncodeCmdVoidF64(e binary.Encoder, o *CmdVoidF64) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Float64(o.A); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdVoidF64(d binary.Decoder, o *CmdVoidF64) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Float64(); err != nil {
		return err
	} else {
		o.A = float64(obj)
	}
	return nil
}
func doSkipCmdVoidF64(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Float64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdVoidF64) ID() binary.ID      { return binaryIDCmdVoidF64 }
func (*binaryClassCmdVoidF64) New() binary.Object { return &CmdVoidF64{} }
func (*binaryClassCmdVoidF64) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdVoidF64(e, obj.(*CmdVoidF64))
}
func (*binaryClassCmdVoidF64) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdVoidF64{}
	return obj, doDecodeCmdVoidF64(d, obj)
}
func (*binaryClassCmdVoidF64) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdVoidF64(d, obj.(*CmdVoidF64))
}
func (*binaryClassCmdVoidF64) Skip(d binary.Decoder) error { return doSkipCmdVoidF64(d) }
func (*binaryClassCmdVoidF64) Schema() *schema.Class       { return schemaCmdVoidF64 }

var schemaCmdVoidF64 = &schema.Class{
	TypeID:  binaryIDCmdVoidF64,
	Package: "test",
	Name:    "CmdVoidF64",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "A", Type: &schema.Primitive{Name: "float64", Method: schema.Float64}},
	},
}

type binaryClassCmdVoidInArrayOfPointers struct{}

func (*CmdVoidInArrayOfPointers) Class() binary.Class {
	return (*binaryClassCmdVoidInArrayOfPointers)(nil)
}
func doEncodeCmdVoidInArrayOfPointers(e binary.Encoder, o *CmdVoidInArrayOfPointers) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.A); err != nil {
		return err
	}
	if err := e.Int32(o.Count); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdVoidInArrayOfPointers(d binary.Decoder, o *CmdVoidInArrayOfPointers) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.A); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.Count = int32(obj)
	}
	return nil
}
func doSkipCmdVoidInArrayOfPointers(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*Charᵖᵖ)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdVoidInArrayOfPointers) ID() binary.ID      { return binaryIDCmdVoidInArrayOfPointers }
func (*binaryClassCmdVoidInArrayOfPointers) New() binary.Object { return &CmdVoidInArrayOfPointers{} }
func (*binaryClassCmdVoidInArrayOfPointers) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdVoidInArrayOfPointers(e, obj.(*CmdVoidInArrayOfPointers))
}
func (*binaryClassCmdVoidInArrayOfPointers) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdVoidInArrayOfPointers{}
	return obj, doDecodeCmdVoidInArrayOfPointers(d, obj)
}
func (*binaryClassCmdVoidInArrayOfPointers) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdVoidInArrayOfPointers(d, obj.(*CmdVoidInArrayOfPointers))
}
func (*binaryClassCmdVoidInArrayOfPointers) Skip(d binary.Decoder) error {
	return doSkipCmdVoidInArrayOfPointers(d)
}
func (*binaryClassCmdVoidInArrayOfPointers) Schema() *schema.Class {
	return schemaCmdVoidInArrayOfPointers
}

var schemaCmdVoidInArrayOfPointers = &schema.Class{
	TypeID:  binaryIDCmdVoidInArrayOfPointers,
	Package: "test",
	Name:    "CmdVoidInArrayOfPointers",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "A", Type: &schema.Struct{Name: "Charᵖᵖ", ID: (*Charᵖᵖ)(nil).Class().ID()}},
		{Declared: "Count", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
	},
}

type binaryClassRemappedᵖ struct{}

func (*Remappedᵖ) Class() binary.Class {
	return (*binaryClassRemappedᵖ)(nil)
}
func doEncodeRemappedᵖ(e binary.Encoder, o *Remappedᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeRemappedᵖ(d binary.Decoder, o *Remappedᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipRemappedᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassRemappedᵖ) ID() binary.ID      { return binaryIDRemappedᵖ }
func (*binaryClassRemappedᵖ) New() binary.Object { return &Remappedᵖ{} }
func (*binaryClassRemappedᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeRemappedᵖ(e, obj.(*Remappedᵖ))
}
func (*binaryClassRemappedᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Remappedᵖ{}
	return obj, doDecodeRemappedᵖ(d, obj)
}
func (*binaryClassRemappedᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeRemappedᵖ(d, obj.(*Remappedᵖ))
}
func (*binaryClassRemappedᵖ) Skip(d binary.Decoder) error { return doSkipRemappedᵖ(d) }
func (*binaryClassRemappedᵖ) Schema() *schema.Class       { return schemaRemappedᵖ }

var schemaRemappedᵖ = &schema.Class{
	TypeID:  binaryIDRemappedᵖ,
	Package: "test",
	Name:    "Remappedᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassCmdVoidInArrayOfRemapped struct{}

func (*CmdVoidInArrayOfRemapped) Class() binary.Class {
	return (*binaryClassCmdVoidInArrayOfRemapped)(nil)
}
func doEncodeCmdVoidInArrayOfRemapped(e binary.Encoder, o *CmdVoidInArrayOfRemapped) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdVoidInArrayOfRemapped(d binary.Decoder, o *CmdVoidInArrayOfRemapped) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doSkipCmdVoidInArrayOfRemapped(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*Remappedᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdVoidInArrayOfRemapped) ID() binary.ID      { return binaryIDCmdVoidInArrayOfRemapped }
func (*binaryClassCmdVoidInArrayOfRemapped) New() binary.Object { return &CmdVoidInArrayOfRemapped{} }
func (*binaryClassCmdVoidInArrayOfRemapped) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdVoidInArrayOfRemapped(e, obj.(*CmdVoidInArrayOfRemapped))
}
func (*binaryClassCmdVoidInArrayOfRemapped) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdVoidInArrayOfRemapped{}
	return obj, doDecodeCmdVoidInArrayOfRemapped(d, obj)
}
func (*binaryClassCmdVoidInArrayOfRemapped) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdVoidInArrayOfRemapped(d, obj.(*CmdVoidInArrayOfRemapped))
}
func (*binaryClassCmdVoidInArrayOfRemapped) Skip(d binary.Decoder) error {
	return doSkipCmdVoidInArrayOfRemapped(d)
}
func (*binaryClassCmdVoidInArrayOfRemapped) Schema() *schema.Class {
	return schemaCmdVoidInArrayOfRemapped
}

var schemaCmdVoidInArrayOfRemapped = &schema.Class{
	TypeID:  binaryIDCmdVoidInArrayOfRemapped,
	Package: "test",
	Name:    "CmdVoidInArrayOfRemapped",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "A", Type: &schema.Struct{Name: "Remappedᵖ", ID: (*Remappedᵖ)(nil).Class().ID()}},
	},
}

type binaryClassCmdVoidOutArrayOfRemapped struct{}

func (*CmdVoidOutArrayOfRemapped) Class() binary.Class {
	return (*binaryClassCmdVoidOutArrayOfRemapped)(nil)
}
func doEncodeCmdVoidOutArrayOfRemapped(e binary.Encoder, o *CmdVoidOutArrayOfRemapped) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdVoidOutArrayOfRemapped(d binary.Decoder, o *CmdVoidOutArrayOfRemapped) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doSkipCmdVoidOutArrayOfRemapped(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*Remappedᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdVoidOutArrayOfRemapped) ID() binary.ID      { return binaryIDCmdVoidOutArrayOfRemapped }
func (*binaryClassCmdVoidOutArrayOfRemapped) New() binary.Object { return &CmdVoidOutArrayOfRemapped{} }
func (*binaryClassCmdVoidOutArrayOfRemapped) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdVoidOutArrayOfRemapped(e, obj.(*CmdVoidOutArrayOfRemapped))
}
func (*binaryClassCmdVoidOutArrayOfRemapped) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdVoidOutArrayOfRemapped{}
	return obj, doDecodeCmdVoidOutArrayOfRemapped(d, obj)
}
func (*binaryClassCmdVoidOutArrayOfRemapped) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdVoidOutArrayOfRemapped(d, obj.(*CmdVoidOutArrayOfRemapped))
}
func (*binaryClassCmdVoidOutArrayOfRemapped) Skip(d binary.Decoder) error {
	return doSkipCmdVoidOutArrayOfRemapped(d)
}
func (*binaryClassCmdVoidOutArrayOfRemapped) Schema() *schema.Class {
	return schemaCmdVoidOutArrayOfRemapped
}

var schemaCmdVoidOutArrayOfRemapped = &schema.Class{
	TypeID:  binaryIDCmdVoidOutArrayOfRemapped,
	Package: "test",
	Name:    "CmdVoidOutArrayOfRemapped",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "A", Type: &schema.Struct{Name: "Remappedᵖ", ID: (*Remappedᵖ)(nil).Class().ID()}},
	},
}

type binaryClassCmdVoidOutArrayOfUnknownRemapped struct{}

func (*CmdVoidOutArrayOfUnknownRemapped) Class() binary.Class {
	return (*binaryClassCmdVoidOutArrayOfUnknownRemapped)(nil)
}
func doEncodeCmdVoidOutArrayOfUnknownRemapped(e binary.Encoder, o *CmdVoidOutArrayOfUnknownRemapped) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdVoidOutArrayOfUnknownRemapped(d binary.Decoder, o *CmdVoidOutArrayOfUnknownRemapped) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doSkipCmdVoidOutArrayOfUnknownRemapped(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*Remappedᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdVoidOutArrayOfUnknownRemapped) ID() binary.ID {
	return binaryIDCmdVoidOutArrayOfUnknownRemapped
}
func (*binaryClassCmdVoidOutArrayOfUnknownRemapped) New() binary.Object {
	return &CmdVoidOutArrayOfUnknownRemapped{}
}
func (*binaryClassCmdVoidOutArrayOfUnknownRemapped) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdVoidOutArrayOfUnknownRemapped(e, obj.(*CmdVoidOutArrayOfUnknownRemapped))
}
func (*binaryClassCmdVoidOutArrayOfUnknownRemapped) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdVoidOutArrayOfUnknownRemapped{}
	return obj, doDecodeCmdVoidOutArrayOfUnknownRemapped(d, obj)
}
func (*binaryClassCmdVoidOutArrayOfUnknownRemapped) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdVoidOutArrayOfUnknownRemapped(d, obj.(*CmdVoidOutArrayOfUnknownRemapped))
}
func (*binaryClassCmdVoidOutArrayOfUnknownRemapped) Skip(d binary.Decoder) error {
	return doSkipCmdVoidOutArrayOfUnknownRemapped(d)
}
func (*binaryClassCmdVoidOutArrayOfUnknownRemapped) Schema() *schema.Class {
	return schemaCmdVoidOutArrayOfUnknownRemapped
}

var schemaCmdVoidOutArrayOfUnknownRemapped = &schema.Class{
	TypeID:  binaryIDCmdVoidOutArrayOfUnknownRemapped,
	Package: "test",
	Name:    "CmdVoidOutArrayOfUnknownRemapped",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "A", Type: &schema.Struct{Name: "Remappedᵖ", ID: (*Remappedᵖ)(nil).Class().ID()}},
	},
}

type binaryClassCmdVoidReadBool struct{}

func (*CmdVoidReadBool) Class() binary.Class {
	return (*binaryClassCmdVoidReadBool)(nil)
}
func doEncodeCmdVoidReadBool(e binary.Encoder, o *CmdVoidReadBool) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdVoidReadBool(d binary.Decoder, o *CmdVoidReadBool) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doSkipCmdVoidReadBool(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*Boolᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdVoidReadBool) ID() binary.ID      { return binaryIDCmdVoidReadBool }
func (*binaryClassCmdVoidReadBool) New() binary.Object { return &CmdVoidReadBool{} }
func (*binaryClassCmdVoidReadBool) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdVoidReadBool(e, obj.(*CmdVoidReadBool))
}
func (*binaryClassCmdVoidReadBool) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdVoidReadBool{}
	return obj, doDecodeCmdVoidReadBool(d, obj)
}
func (*binaryClassCmdVoidReadBool) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdVoidReadBool(d, obj.(*CmdVoidReadBool))
}
func (*binaryClassCmdVoidReadBool) Skip(d binary.Decoder) error { return doSkipCmdVoidReadBool(d) }
func (*binaryClassCmdVoidReadBool) Schema() *schema.Class       { return schemaCmdVoidReadBool }

var schemaCmdVoidReadBool = &schema.Class{
	TypeID:  binaryIDCmdVoidReadBool,
	Package: "test",
	Name:    "CmdVoidReadBool",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "A", Type: &schema.Struct{Name: "Boolᵖ", ID: (*Boolᵖ)(nil).Class().ID()}},
	},
}

type binaryClassF32ᵖ struct{}

func (*F32ᵖ) Class() binary.Class {
	return (*binaryClassF32ᵖ)(nil)
}
func doEncodeF32ᵖ(e binary.Encoder, o *F32ᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeF32ᵖ(d binary.Decoder, o *F32ᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipF32ᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassF32ᵖ) ID() binary.ID      { return binaryIDF32ᵖ }
func (*binaryClassF32ᵖ) New() binary.Object { return &F32ᵖ{} }
func (*binaryClassF32ᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeF32ᵖ(e, obj.(*F32ᵖ))
}
func (*binaryClassF32ᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &F32ᵖ{}
	return obj, doDecodeF32ᵖ(d, obj)
}
func (*binaryClassF32ᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeF32ᵖ(d, obj.(*F32ᵖ))
}
func (*binaryClassF32ᵖ) Skip(d binary.Decoder) error { return doSkipF32ᵖ(d) }
func (*binaryClassF32ᵖ) Schema() *schema.Class       { return schemaF32ᵖ }

var schemaF32ᵖ = &schema.Class{
	TypeID:  binaryIDF32ᵖ,
	Package: "test",
	Name:    "F32ᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassCmdVoidReadF32 struct{}

func (*CmdVoidReadF32) Class() binary.Class {
	return (*binaryClassCmdVoidReadF32)(nil)
}
func doEncodeCmdVoidReadF32(e binary.Encoder, o *CmdVoidReadF32) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdVoidReadF32(d binary.Decoder, o *CmdVoidReadF32) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doSkipCmdVoidReadF32(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*F32ᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdVoidReadF32) ID() binary.ID      { return binaryIDCmdVoidReadF32 }
func (*binaryClassCmdVoidReadF32) New() binary.Object { return &CmdVoidReadF32{} }
func (*binaryClassCmdVoidReadF32) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdVoidReadF32(e, obj.(*CmdVoidReadF32))
}
func (*binaryClassCmdVoidReadF32) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdVoidReadF32{}
	return obj, doDecodeCmdVoidReadF32(d, obj)
}
func (*binaryClassCmdVoidReadF32) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdVoidReadF32(d, obj.(*CmdVoidReadF32))
}
func (*binaryClassCmdVoidReadF32) Skip(d binary.Decoder) error { return doSkipCmdVoidReadF32(d) }
func (*binaryClassCmdVoidReadF32) Schema() *schema.Class       { return schemaCmdVoidReadF32 }

var schemaCmdVoidReadF32 = &schema.Class{
	TypeID:  binaryIDCmdVoidReadF32,
	Package: "test",
	Name:    "CmdVoidReadF32",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "A", Type: &schema.Struct{Name: "F32ᵖ", ID: (*F32ᵖ)(nil).Class().ID()}},
	},
}

type binaryClassF64ᵖ struct{}

func (*F64ᵖ) Class() binary.Class {
	return (*binaryClassF64ᵖ)(nil)
}
func doEncodeF64ᵖ(e binary.Encoder, o *F64ᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeF64ᵖ(d binary.Decoder, o *F64ᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipF64ᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassF64ᵖ) ID() binary.ID      { return binaryIDF64ᵖ }
func (*binaryClassF64ᵖ) New() binary.Object { return &F64ᵖ{} }
func (*binaryClassF64ᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeF64ᵖ(e, obj.(*F64ᵖ))
}
func (*binaryClassF64ᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &F64ᵖ{}
	return obj, doDecodeF64ᵖ(d, obj)
}
func (*binaryClassF64ᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeF64ᵖ(d, obj.(*F64ᵖ))
}
func (*binaryClassF64ᵖ) Skip(d binary.Decoder) error { return doSkipF64ᵖ(d) }
func (*binaryClassF64ᵖ) Schema() *schema.Class       { return schemaF64ᵖ }

var schemaF64ᵖ = &schema.Class{
	TypeID:  binaryIDF64ᵖ,
	Package: "test",
	Name:    "F64ᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassCmdVoidReadF64 struct{}

func (*CmdVoidReadF64) Class() binary.Class {
	return (*binaryClassCmdVoidReadF64)(nil)
}
func doEncodeCmdVoidReadF64(e binary.Encoder, o *CmdVoidReadF64) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdVoidReadF64(d binary.Decoder, o *CmdVoidReadF64) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doSkipCmdVoidReadF64(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*F64ᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdVoidReadF64) ID() binary.ID      { return binaryIDCmdVoidReadF64 }
func (*binaryClassCmdVoidReadF64) New() binary.Object { return &CmdVoidReadF64{} }
func (*binaryClassCmdVoidReadF64) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdVoidReadF64(e, obj.(*CmdVoidReadF64))
}
func (*binaryClassCmdVoidReadF64) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdVoidReadF64{}
	return obj, doDecodeCmdVoidReadF64(d, obj)
}
func (*binaryClassCmdVoidReadF64) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdVoidReadF64(d, obj.(*CmdVoidReadF64))
}
func (*binaryClassCmdVoidReadF64) Skip(d binary.Decoder) error { return doSkipCmdVoidReadF64(d) }
func (*binaryClassCmdVoidReadF64) Schema() *schema.Class       { return schemaCmdVoidReadF64 }

var schemaCmdVoidReadF64 = &schema.Class{
	TypeID:  binaryIDCmdVoidReadF64,
	Package: "test",
	Name:    "CmdVoidReadF64",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "A", Type: &schema.Struct{Name: "F64ᵖ", ID: (*F64ᵖ)(nil).Class().ID()}},
	},
}

type binaryClassCmdVoidReadPtrs struct{}

func (*CmdVoidReadPtrs) Class() binary.Class {
	return (*binaryClassCmdVoidReadPtrs)(nil)
}
func doEncodeCmdVoidReadPtrs(e binary.Encoder, o *CmdVoidReadPtrs) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.A); err != nil {
		return err
	}
	if err := e.Value(&o.B); err != nil {
		return err
	}
	if err := e.Value(&o.C); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdVoidReadPtrs(d binary.Decoder, o *CmdVoidReadPtrs) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.A); err != nil {
		return err
	}
	if err := d.Value(&o.B); err != nil {
		return err
	}
	if err := d.Value(&o.C); err != nil {
		return err
	}
	return nil
}
func doSkipCmdVoidReadPtrs(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*F32ᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*U16ᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*Boolᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdVoidReadPtrs) ID() binary.ID      { return binaryIDCmdVoidReadPtrs }
func (*binaryClassCmdVoidReadPtrs) New() binary.Object { return &CmdVoidReadPtrs{} }
func (*binaryClassCmdVoidReadPtrs) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdVoidReadPtrs(e, obj.(*CmdVoidReadPtrs))
}
func (*binaryClassCmdVoidReadPtrs) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdVoidReadPtrs{}
	return obj, doDecodeCmdVoidReadPtrs(d, obj)
}
func (*binaryClassCmdVoidReadPtrs) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdVoidReadPtrs(d, obj.(*CmdVoidReadPtrs))
}
func (*binaryClassCmdVoidReadPtrs) Skip(d binary.Decoder) error { return doSkipCmdVoidReadPtrs(d) }
func (*binaryClassCmdVoidReadPtrs) Schema() *schema.Class       { return schemaCmdVoidReadPtrs }

var schemaCmdVoidReadPtrs = &schema.Class{
	TypeID:  binaryIDCmdVoidReadPtrs,
	Package: "test",
	Name:    "CmdVoidReadPtrs",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "A", Type: &schema.Struct{Name: "F32ᵖ", ID: (*F32ᵖ)(nil).Class().ID()}},
		{Declared: "B", Type: &schema.Struct{Name: "U16ᵖ", ID: (*U16ᵖ)(nil).Class().ID()}},
		{Declared: "C", Type: &schema.Struct{Name: "Boolᵖ", ID: (*Boolᵖ)(nil).Class().ID()}},
	},
}

type binaryClassS16ᵖ struct{}

func (*S16ᵖ) Class() binary.Class {
	return (*binaryClassS16ᵖ)(nil)
}
func doEncodeS16ᵖ(e binary.Encoder, o *S16ᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeS16ᵖ(d binary.Decoder, o *S16ᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipS16ᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassS16ᵖ) ID() binary.ID      { return binaryIDS16ᵖ }
func (*binaryClassS16ᵖ) New() binary.Object { return &S16ᵖ{} }
func (*binaryClassS16ᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeS16ᵖ(e, obj.(*S16ᵖ))
}
func (*binaryClassS16ᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &S16ᵖ{}
	return obj, doDecodeS16ᵖ(d, obj)
}
func (*binaryClassS16ᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeS16ᵖ(d, obj.(*S16ᵖ))
}
func (*binaryClassS16ᵖ) Skip(d binary.Decoder) error { return doSkipS16ᵖ(d) }
func (*binaryClassS16ᵖ) Schema() *schema.Class       { return schemaS16ᵖ }

var schemaS16ᵖ = &schema.Class{
	TypeID:  binaryIDS16ᵖ,
	Package: "test",
	Name:    "S16ᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassCmdVoidReadS16 struct{}

func (*CmdVoidReadS16) Class() binary.Class {
	return (*binaryClassCmdVoidReadS16)(nil)
}
func doEncodeCmdVoidReadS16(e binary.Encoder, o *CmdVoidReadS16) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdVoidReadS16(d binary.Decoder, o *CmdVoidReadS16) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doSkipCmdVoidReadS16(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*S16ᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdVoidReadS16) ID() binary.ID      { return binaryIDCmdVoidReadS16 }
func (*binaryClassCmdVoidReadS16) New() binary.Object { return &CmdVoidReadS16{} }
func (*binaryClassCmdVoidReadS16) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdVoidReadS16(e, obj.(*CmdVoidReadS16))
}
func (*binaryClassCmdVoidReadS16) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdVoidReadS16{}
	return obj, doDecodeCmdVoidReadS16(d, obj)
}
func (*binaryClassCmdVoidReadS16) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdVoidReadS16(d, obj.(*CmdVoidReadS16))
}
func (*binaryClassCmdVoidReadS16) Skip(d binary.Decoder) error { return doSkipCmdVoidReadS16(d) }
func (*binaryClassCmdVoidReadS16) Schema() *schema.Class       { return schemaCmdVoidReadS16 }

var schemaCmdVoidReadS16 = &schema.Class{
	TypeID:  binaryIDCmdVoidReadS16,
	Package: "test",
	Name:    "CmdVoidReadS16",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "A", Type: &schema.Struct{Name: "S16ᵖ", ID: (*S16ᵖ)(nil).Class().ID()}},
	},
}

type binaryClassS32ᵖ struct{}

func (*S32ᵖ) Class() binary.Class {
	return (*binaryClassS32ᵖ)(nil)
}
func doEncodeS32ᵖ(e binary.Encoder, o *S32ᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeS32ᵖ(d binary.Decoder, o *S32ᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipS32ᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassS32ᵖ) ID() binary.ID      { return binaryIDS32ᵖ }
func (*binaryClassS32ᵖ) New() binary.Object { return &S32ᵖ{} }
func (*binaryClassS32ᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeS32ᵖ(e, obj.(*S32ᵖ))
}
func (*binaryClassS32ᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &S32ᵖ{}
	return obj, doDecodeS32ᵖ(d, obj)
}
func (*binaryClassS32ᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeS32ᵖ(d, obj.(*S32ᵖ))
}
func (*binaryClassS32ᵖ) Skip(d binary.Decoder) error { return doSkipS32ᵖ(d) }
func (*binaryClassS32ᵖ) Schema() *schema.Class       { return schemaS32ᵖ }

var schemaS32ᵖ = &schema.Class{
	TypeID:  binaryIDS32ᵖ,
	Package: "test",
	Name:    "S32ᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassCmdVoidReadS32 struct{}

func (*CmdVoidReadS32) Class() binary.Class {
	return (*binaryClassCmdVoidReadS32)(nil)
}
func doEncodeCmdVoidReadS32(e binary.Encoder, o *CmdVoidReadS32) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdVoidReadS32(d binary.Decoder, o *CmdVoidReadS32) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doSkipCmdVoidReadS32(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*S32ᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdVoidReadS32) ID() binary.ID      { return binaryIDCmdVoidReadS32 }
func (*binaryClassCmdVoidReadS32) New() binary.Object { return &CmdVoidReadS32{} }
func (*binaryClassCmdVoidReadS32) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdVoidReadS32(e, obj.(*CmdVoidReadS32))
}
func (*binaryClassCmdVoidReadS32) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdVoidReadS32{}
	return obj, doDecodeCmdVoidReadS32(d, obj)
}
func (*binaryClassCmdVoidReadS32) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdVoidReadS32(d, obj.(*CmdVoidReadS32))
}
func (*binaryClassCmdVoidReadS32) Skip(d binary.Decoder) error { return doSkipCmdVoidReadS32(d) }
func (*binaryClassCmdVoidReadS32) Schema() *schema.Class       { return schemaCmdVoidReadS32 }

var schemaCmdVoidReadS32 = &schema.Class{
	TypeID:  binaryIDCmdVoidReadS32,
	Package: "test",
	Name:    "CmdVoidReadS32",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "A", Type: &schema.Struct{Name: "S32ᵖ", ID: (*S32ᵖ)(nil).Class().ID()}},
	},
}

type binaryClassS64ᵖ struct{}

func (*S64ᵖ) Class() binary.Class {
	return (*binaryClassS64ᵖ)(nil)
}
func doEncodeS64ᵖ(e binary.Encoder, o *S64ᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeS64ᵖ(d binary.Decoder, o *S64ᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipS64ᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassS64ᵖ) ID() binary.ID      { return binaryIDS64ᵖ }
func (*binaryClassS64ᵖ) New() binary.Object { return &S64ᵖ{} }
func (*binaryClassS64ᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeS64ᵖ(e, obj.(*S64ᵖ))
}
func (*binaryClassS64ᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &S64ᵖ{}
	return obj, doDecodeS64ᵖ(d, obj)
}
func (*binaryClassS64ᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeS64ᵖ(d, obj.(*S64ᵖ))
}
func (*binaryClassS64ᵖ) Skip(d binary.Decoder) error { return doSkipS64ᵖ(d) }
func (*binaryClassS64ᵖ) Schema() *schema.Class       { return schemaS64ᵖ }

var schemaS64ᵖ = &schema.Class{
	TypeID:  binaryIDS64ᵖ,
	Package: "test",
	Name:    "S64ᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassCmdVoidReadS64 struct{}

func (*CmdVoidReadS64) Class() binary.Class {
	return (*binaryClassCmdVoidReadS64)(nil)
}
func doEncodeCmdVoidReadS64(e binary.Encoder, o *CmdVoidReadS64) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdVoidReadS64(d binary.Decoder, o *CmdVoidReadS64) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doSkipCmdVoidReadS64(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*S64ᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdVoidReadS64) ID() binary.ID      { return binaryIDCmdVoidReadS64 }
func (*binaryClassCmdVoidReadS64) New() binary.Object { return &CmdVoidReadS64{} }
func (*binaryClassCmdVoidReadS64) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdVoidReadS64(e, obj.(*CmdVoidReadS64))
}
func (*binaryClassCmdVoidReadS64) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdVoidReadS64{}
	return obj, doDecodeCmdVoidReadS64(d, obj)
}
func (*binaryClassCmdVoidReadS64) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdVoidReadS64(d, obj.(*CmdVoidReadS64))
}
func (*binaryClassCmdVoidReadS64) Skip(d binary.Decoder) error { return doSkipCmdVoidReadS64(d) }
func (*binaryClassCmdVoidReadS64) Schema() *schema.Class       { return schemaCmdVoidReadS64 }

var schemaCmdVoidReadS64 = &schema.Class{
	TypeID:  binaryIDCmdVoidReadS64,
	Package: "test",
	Name:    "CmdVoidReadS64",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "A", Type: &schema.Struct{Name: "S64ᵖ", ID: (*S64ᵖ)(nil).Class().ID()}},
	},
}

type binaryClassS8ᵖ struct{}

func (*S8ᵖ) Class() binary.Class {
	return (*binaryClassS8ᵖ)(nil)
}
func doEncodeS8ᵖ(e binary.Encoder, o *S8ᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeS8ᵖ(d binary.Decoder, o *S8ᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipS8ᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassS8ᵖ) ID() binary.ID      { return binaryIDS8ᵖ }
func (*binaryClassS8ᵖ) New() binary.Object { return &S8ᵖ{} }
func (*binaryClassS8ᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeS8ᵖ(e, obj.(*S8ᵖ))
}
func (*binaryClassS8ᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &S8ᵖ{}
	return obj, doDecodeS8ᵖ(d, obj)
}
func (*binaryClassS8ᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeS8ᵖ(d, obj.(*S8ᵖ))
}
func (*binaryClassS8ᵖ) Skip(d binary.Decoder) error { return doSkipS8ᵖ(d) }
func (*binaryClassS8ᵖ) Schema() *schema.Class       { return schemaS8ᵖ }

var schemaS8ᵖ = &schema.Class{
	TypeID:  binaryIDS8ᵖ,
	Package: "test",
	Name:    "S8ᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassCmdVoidReadS8 struct{}

func (*CmdVoidReadS8) Class() binary.Class {
	return (*binaryClassCmdVoidReadS8)(nil)
}
func doEncodeCmdVoidReadS8(e binary.Encoder, o *CmdVoidReadS8) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdVoidReadS8(d binary.Decoder, o *CmdVoidReadS8) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doSkipCmdVoidReadS8(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*S8ᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdVoidReadS8) ID() binary.ID      { return binaryIDCmdVoidReadS8 }
func (*binaryClassCmdVoidReadS8) New() binary.Object { return &CmdVoidReadS8{} }
func (*binaryClassCmdVoidReadS8) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdVoidReadS8(e, obj.(*CmdVoidReadS8))
}
func (*binaryClassCmdVoidReadS8) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdVoidReadS8{}
	return obj, doDecodeCmdVoidReadS8(d, obj)
}
func (*binaryClassCmdVoidReadS8) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdVoidReadS8(d, obj.(*CmdVoidReadS8))
}
func (*binaryClassCmdVoidReadS8) Skip(d binary.Decoder) error { return doSkipCmdVoidReadS8(d) }
func (*binaryClassCmdVoidReadS8) Schema() *schema.Class       { return schemaCmdVoidReadS8 }

var schemaCmdVoidReadS8 = &schema.Class{
	TypeID:  binaryIDCmdVoidReadS8,
	Package: "test",
	Name:    "CmdVoidReadS8",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "A", Type: &schema.Struct{Name: "S8ᵖ", ID: (*S8ᵖ)(nil).Class().ID()}},
	},
}

type binaryClassCmdVoidReadU16 struct{}

func (*CmdVoidReadU16) Class() binary.Class {
	return (*binaryClassCmdVoidReadU16)(nil)
}
func doEncodeCmdVoidReadU16(e binary.Encoder, o *CmdVoidReadU16) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdVoidReadU16(d binary.Decoder, o *CmdVoidReadU16) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doSkipCmdVoidReadU16(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*U16ᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdVoidReadU16) ID() binary.ID      { return binaryIDCmdVoidReadU16 }
func (*binaryClassCmdVoidReadU16) New() binary.Object { return &CmdVoidReadU16{} }
func (*binaryClassCmdVoidReadU16) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdVoidReadU16(e, obj.(*CmdVoidReadU16))
}
func (*binaryClassCmdVoidReadU16) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdVoidReadU16{}
	return obj, doDecodeCmdVoidReadU16(d, obj)
}
func (*binaryClassCmdVoidReadU16) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdVoidReadU16(d, obj.(*CmdVoidReadU16))
}
func (*binaryClassCmdVoidReadU16) Skip(d binary.Decoder) error { return doSkipCmdVoidReadU16(d) }
func (*binaryClassCmdVoidReadU16) Schema() *schema.Class       { return schemaCmdVoidReadU16 }

var schemaCmdVoidReadU16 = &schema.Class{
	TypeID:  binaryIDCmdVoidReadU16,
	Package: "test",
	Name:    "CmdVoidReadU16",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "A", Type: &schema.Struct{Name: "U16ᵖ", ID: (*U16ᵖ)(nil).Class().ID()}},
	},
}

type binaryClassCmdVoidReadU32 struct{}

func (*CmdVoidReadU32) Class() binary.Class {
	return (*binaryClassCmdVoidReadU32)(nil)
}
func doEncodeCmdVoidReadU32(e binary.Encoder, o *CmdVoidReadU32) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdVoidReadU32(d binary.Decoder, o *CmdVoidReadU32) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doSkipCmdVoidReadU32(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*U32ᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdVoidReadU32) ID() binary.ID      { return binaryIDCmdVoidReadU32 }
func (*binaryClassCmdVoidReadU32) New() binary.Object { return &CmdVoidReadU32{} }
func (*binaryClassCmdVoidReadU32) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdVoidReadU32(e, obj.(*CmdVoidReadU32))
}
func (*binaryClassCmdVoidReadU32) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdVoidReadU32{}
	return obj, doDecodeCmdVoidReadU32(d, obj)
}
func (*binaryClassCmdVoidReadU32) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdVoidReadU32(d, obj.(*CmdVoidReadU32))
}
func (*binaryClassCmdVoidReadU32) Skip(d binary.Decoder) error { return doSkipCmdVoidReadU32(d) }
func (*binaryClassCmdVoidReadU32) Schema() *schema.Class       { return schemaCmdVoidReadU32 }

var schemaCmdVoidReadU32 = &schema.Class{
	TypeID:  binaryIDCmdVoidReadU32,
	Package: "test",
	Name:    "CmdVoidReadU32",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "A", Type: &schema.Struct{Name: "U32ᵖ", ID: (*U32ᵖ)(nil).Class().ID()}},
	},
}

type binaryClassU64ᵖ struct{}

func (*U64ᵖ) Class() binary.Class {
	return (*binaryClassU64ᵖ)(nil)
}
func doEncodeU64ᵖ(e binary.Encoder, o *U64ᵖ) error {
	if err := e.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doDecodeU64ᵖ(d binary.Decoder, o *U64ᵖ) error {
	if err := d.Value(&o.Pointer); err != nil {
		return err
	}
	return nil
}
func doSkipU64ᵖ(d binary.Decoder) error {
	if err := d.SkipValue((*memory.Pointer)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassU64ᵖ) ID() binary.ID      { return binaryIDU64ᵖ }
func (*binaryClassU64ᵖ) New() binary.Object { return &U64ᵖ{} }
func (*binaryClassU64ᵖ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeU64ᵖ(e, obj.(*U64ᵖ))
}
func (*binaryClassU64ᵖ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &U64ᵖ{}
	return obj, doDecodeU64ᵖ(d, obj)
}
func (*binaryClassU64ᵖ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeU64ᵖ(d, obj.(*U64ᵖ))
}
func (*binaryClassU64ᵖ) Skip(d binary.Decoder) error { return doSkipU64ᵖ(d) }
func (*binaryClassU64ᵖ) Schema() *schema.Class       { return schemaU64ᵖ }

var schemaU64ᵖ = &schema.Class{
	TypeID:  binaryIDU64ᵖ,
	Package: "test",
	Name:    "U64ᵖ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "memory.Pointer", ID: (*memory.Pointer)(nil).Class().ID()}},
	},
}

type binaryClassCmdVoidReadU64 struct{}

func (*CmdVoidReadU64) Class() binary.Class {
	return (*binaryClassCmdVoidReadU64)(nil)
}
func doEncodeCmdVoidReadU64(e binary.Encoder, o *CmdVoidReadU64) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdVoidReadU64(d binary.Decoder, o *CmdVoidReadU64) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doSkipCmdVoidReadU64(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*U64ᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdVoidReadU64) ID() binary.ID      { return binaryIDCmdVoidReadU64 }
func (*binaryClassCmdVoidReadU64) New() binary.Object { return &CmdVoidReadU64{} }
func (*binaryClassCmdVoidReadU64) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdVoidReadU64(e, obj.(*CmdVoidReadU64))
}
func (*binaryClassCmdVoidReadU64) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdVoidReadU64{}
	return obj, doDecodeCmdVoidReadU64(d, obj)
}
func (*binaryClassCmdVoidReadU64) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdVoidReadU64(d, obj.(*CmdVoidReadU64))
}
func (*binaryClassCmdVoidReadU64) Skip(d binary.Decoder) error { return doSkipCmdVoidReadU64(d) }
func (*binaryClassCmdVoidReadU64) Schema() *schema.Class       { return schemaCmdVoidReadU64 }

var schemaCmdVoidReadU64 = &schema.Class{
	TypeID:  binaryIDCmdVoidReadU64,
	Package: "test",
	Name:    "CmdVoidReadU64",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "A", Type: &schema.Struct{Name: "U64ᵖ", ID: (*U64ᵖ)(nil).Class().ID()}},
	},
}

type binaryClassCmdVoidReadU8 struct{}

func (*CmdVoidReadU8) Class() binary.Class {
	return (*binaryClassCmdVoidReadU8)(nil)
}
func doEncodeCmdVoidReadU8(e binary.Encoder, o *CmdVoidReadU8) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdVoidReadU8(d binary.Decoder, o *CmdVoidReadU8) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doSkipCmdVoidReadU8(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*U8ᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdVoidReadU8) ID() binary.ID      { return binaryIDCmdVoidReadU8 }
func (*binaryClassCmdVoidReadU8) New() binary.Object { return &CmdVoidReadU8{} }
func (*binaryClassCmdVoidReadU8) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdVoidReadU8(e, obj.(*CmdVoidReadU8))
}
func (*binaryClassCmdVoidReadU8) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdVoidReadU8{}
	return obj, doDecodeCmdVoidReadU8(d, obj)
}
func (*binaryClassCmdVoidReadU8) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdVoidReadU8(d, obj.(*CmdVoidReadU8))
}
func (*binaryClassCmdVoidReadU8) Skip(d binary.Decoder) error { return doSkipCmdVoidReadU8(d) }
func (*binaryClassCmdVoidReadU8) Schema() *schema.Class       { return schemaCmdVoidReadU8 }

var schemaCmdVoidReadU8 = &schema.Class{
	TypeID:  binaryIDCmdVoidReadU8,
	Package: "test",
	Name:    "CmdVoidReadU8",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "A", Type: &schema.Struct{Name: "U8ᵖ", ID: (*U8ᵖ)(nil).Class().ID()}},
	},
}

type binaryClassCmdVoidS16 struct{}

func (*CmdVoidS16) Class() binary.Class {
	return (*binaryClassCmdVoidS16)(nil)
}
func doEncodeCmdVoidS16(e binary.Encoder, o *CmdVoidS16) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int16(o.A); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdVoidS16(d binary.Decoder, o *CmdVoidS16) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int16(); err != nil {
		return err
	} else {
		o.A = int16(obj)
	}
	return nil
}
func doSkipCmdVoidS16(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int16(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdVoidS16) ID() binary.ID      { return binaryIDCmdVoidS16 }
func (*binaryClassCmdVoidS16) New() binary.Object { return &CmdVoidS16{} }
func (*binaryClassCmdVoidS16) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdVoidS16(e, obj.(*CmdVoidS16))
}
func (*binaryClassCmdVoidS16) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdVoidS16{}
	return obj, doDecodeCmdVoidS16(d, obj)
}
func (*binaryClassCmdVoidS16) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdVoidS16(d, obj.(*CmdVoidS16))
}
func (*binaryClassCmdVoidS16) Skip(d binary.Decoder) error { return doSkipCmdVoidS16(d) }
func (*binaryClassCmdVoidS16) Schema() *schema.Class       { return schemaCmdVoidS16 }

var schemaCmdVoidS16 = &schema.Class{
	TypeID:  binaryIDCmdVoidS16,
	Package: "test",
	Name:    "CmdVoidS16",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "A", Type: &schema.Primitive{Name: "int16", Method: schema.Int16}},
	},
}

type binaryClassCmdVoidS32 struct{}

func (*CmdVoidS32) Class() binary.Class {
	return (*binaryClassCmdVoidS32)(nil)
}
func doEncodeCmdVoidS32(e binary.Encoder, o *CmdVoidS32) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int32(o.A); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdVoidS32(d binary.Decoder, o *CmdVoidS32) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int32(); err != nil {
		return err
	} else {
		o.A = int32(obj)
	}
	return nil
}
func doSkipCmdVoidS32(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdVoidS32) ID() binary.ID      { return binaryIDCmdVoidS32 }
func (*binaryClassCmdVoidS32) New() binary.Object { return &CmdVoidS32{} }
func (*binaryClassCmdVoidS32) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdVoidS32(e, obj.(*CmdVoidS32))
}
func (*binaryClassCmdVoidS32) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdVoidS32{}
	return obj, doDecodeCmdVoidS32(d, obj)
}
func (*binaryClassCmdVoidS32) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdVoidS32(d, obj.(*CmdVoidS32))
}
func (*binaryClassCmdVoidS32) Skip(d binary.Decoder) error { return doSkipCmdVoidS32(d) }
func (*binaryClassCmdVoidS32) Schema() *schema.Class       { return schemaCmdVoidS32 }

var schemaCmdVoidS32 = &schema.Class{
	TypeID:  binaryIDCmdVoidS32,
	Package: "test",
	Name:    "CmdVoidS32",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "A", Type: &schema.Primitive{Name: "int32", Method: schema.Int32}},
	},
}

type binaryClassCmdVoidS64 struct{}

func (*CmdVoidS64) Class() binary.Class {
	return (*binaryClassCmdVoidS64)(nil)
}
func doEncodeCmdVoidS64(e binary.Encoder, o *CmdVoidS64) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int64(o.A); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdVoidS64(d binary.Decoder, o *CmdVoidS64) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int64(); err != nil {
		return err
	} else {
		o.A = int64(obj)
	}
	return nil
}
func doSkipCmdVoidS64(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdVoidS64) ID() binary.ID      { return binaryIDCmdVoidS64 }
func (*binaryClassCmdVoidS64) New() binary.Object { return &CmdVoidS64{} }
func (*binaryClassCmdVoidS64) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdVoidS64(e, obj.(*CmdVoidS64))
}
func (*binaryClassCmdVoidS64) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdVoidS64{}
	return obj, doDecodeCmdVoidS64(d, obj)
}
func (*binaryClassCmdVoidS64) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdVoidS64(d, obj.(*CmdVoidS64))
}
func (*binaryClassCmdVoidS64) Skip(d binary.Decoder) error { return doSkipCmdVoidS64(d) }
func (*binaryClassCmdVoidS64) Schema() *schema.Class       { return schemaCmdVoidS64 }

var schemaCmdVoidS64 = &schema.Class{
	TypeID:  binaryIDCmdVoidS64,
	Package: "test",
	Name:    "CmdVoidS64",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "A", Type: &schema.Primitive{Name: "int64", Method: schema.Int64}},
	},
}

type binaryClassCmdVoidS8 struct{}

func (*CmdVoidS8) Class() binary.Class {
	return (*binaryClassCmdVoidS8)(nil)
}
func doEncodeCmdVoidS8(e binary.Encoder, o *CmdVoidS8) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Int8(o.A); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdVoidS8(d binary.Decoder, o *CmdVoidS8) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Int8(); err != nil {
		return err
	} else {
		o.A = int8(obj)
	}
	return nil
}
func doSkipCmdVoidS8(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Int8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdVoidS8) ID() binary.ID      { return binaryIDCmdVoidS8 }
func (*binaryClassCmdVoidS8) New() binary.Object { return &CmdVoidS8{} }
func (*binaryClassCmdVoidS8) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdVoidS8(e, obj.(*CmdVoidS8))
}
func (*binaryClassCmdVoidS8) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdVoidS8{}
	return obj, doDecodeCmdVoidS8(d, obj)
}
func (*binaryClassCmdVoidS8) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdVoidS8(d, obj.(*CmdVoidS8))
}
func (*binaryClassCmdVoidS8) Skip(d binary.Decoder) error { return doSkipCmdVoidS8(d) }
func (*binaryClassCmdVoidS8) Schema() *schema.Class       { return schemaCmdVoidS8 }

var schemaCmdVoidS8 = &schema.Class{
	TypeID:  binaryIDCmdVoidS8,
	Package: "test",
	Name:    "CmdVoidS8",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "A", Type: &schema.Primitive{Name: "int8", Method: schema.Int8}},
	},
}

type binaryClassCmdVoidString struct{}

func (*CmdVoidString) Class() binary.Class {
	return (*binaryClassCmdVoidString)(nil)
}
func doEncodeCmdVoidString(e binary.Encoder, o *CmdVoidString) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.String(o.A); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdVoidString(d binary.Decoder, o *CmdVoidString) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.String(); err != nil {
		return err
	} else {
		o.A = string(obj)
	}
	return nil
}
func doSkipCmdVoidString(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipString(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdVoidString) ID() binary.ID      { return binaryIDCmdVoidString }
func (*binaryClassCmdVoidString) New() binary.Object { return &CmdVoidString{} }
func (*binaryClassCmdVoidString) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdVoidString(e, obj.(*CmdVoidString))
}
func (*binaryClassCmdVoidString) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdVoidString{}
	return obj, doDecodeCmdVoidString(d, obj)
}
func (*binaryClassCmdVoidString) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdVoidString(d, obj.(*CmdVoidString))
}
func (*binaryClassCmdVoidString) Skip(d binary.Decoder) error { return doSkipCmdVoidString(d) }
func (*binaryClassCmdVoidString) Schema() *schema.Class       { return schemaCmdVoidString }

var schemaCmdVoidString = &schema.Class{
	TypeID:  binaryIDCmdVoidString,
	Package: "test",
	Name:    "CmdVoidString",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "A", Type: &schema.Primitive{Name: "string", Method: schema.String}},
	},
}

type binaryClassCmdVoidU16 struct{}

func (*CmdVoidU16) Class() binary.Class {
	return (*binaryClassCmdVoidU16)(nil)
}
func doEncodeCmdVoidU16(e binary.Encoder, o *CmdVoidU16) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint16(o.A); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdVoidU16(d binary.Decoder, o *CmdVoidU16) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint16(); err != nil {
		return err
	} else {
		o.A = uint16(obj)
	}
	return nil
}
func doSkipCmdVoidU16(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint16(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdVoidU16) ID() binary.ID      { return binaryIDCmdVoidU16 }
func (*binaryClassCmdVoidU16) New() binary.Object { return &CmdVoidU16{} }
func (*binaryClassCmdVoidU16) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdVoidU16(e, obj.(*CmdVoidU16))
}
func (*binaryClassCmdVoidU16) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdVoidU16{}
	return obj, doDecodeCmdVoidU16(d, obj)
}
func (*binaryClassCmdVoidU16) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdVoidU16(d, obj.(*CmdVoidU16))
}
func (*binaryClassCmdVoidU16) Skip(d binary.Decoder) error { return doSkipCmdVoidU16(d) }
func (*binaryClassCmdVoidU16) Schema() *schema.Class       { return schemaCmdVoidU16 }

var schemaCmdVoidU16 = &schema.Class{
	TypeID:  binaryIDCmdVoidU16,
	Package: "test",
	Name:    "CmdVoidU16",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "A", Type: &schema.Primitive{Name: "uint16", Method: schema.Uint16}},
	},
}

type binaryClassCmdVoidU32 struct{}

func (*CmdVoidU32) Class() binary.Class {
	return (*binaryClassCmdVoidU32)(nil)
}
func doEncodeCmdVoidU32(e binary.Encoder, o *CmdVoidU32) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint32(o.A); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdVoidU32(d binary.Decoder, o *CmdVoidU32) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.A = uint32(obj)
	}
	return nil
}
func doSkipCmdVoidU32(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdVoidU32) ID() binary.ID      { return binaryIDCmdVoidU32 }
func (*binaryClassCmdVoidU32) New() binary.Object { return &CmdVoidU32{} }
func (*binaryClassCmdVoidU32) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdVoidU32(e, obj.(*CmdVoidU32))
}
func (*binaryClassCmdVoidU32) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdVoidU32{}
	return obj, doDecodeCmdVoidU32(d, obj)
}
func (*binaryClassCmdVoidU32) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdVoidU32(d, obj.(*CmdVoidU32))
}
func (*binaryClassCmdVoidU32) Skip(d binary.Decoder) error { return doSkipCmdVoidU32(d) }
func (*binaryClassCmdVoidU32) Schema() *schema.Class       { return schemaCmdVoidU32 }

var schemaCmdVoidU32 = &schema.Class{
	TypeID:  binaryIDCmdVoidU32,
	Package: "test",
	Name:    "CmdVoidU32",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "A", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
	},
}

type binaryClassCmdVoidU64 struct{}

func (*CmdVoidU64) Class() binary.Class {
	return (*binaryClassCmdVoidU64)(nil)
}
func doEncodeCmdVoidU64(e binary.Encoder, o *CmdVoidU64) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint64(o.A); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdVoidU64(d binary.Decoder, o *CmdVoidU64) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.A = uint64(obj)
	}
	return nil
}
func doSkipCmdVoidU64(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint64(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdVoidU64) ID() binary.ID      { return binaryIDCmdVoidU64 }
func (*binaryClassCmdVoidU64) New() binary.Object { return &CmdVoidU64{} }
func (*binaryClassCmdVoidU64) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdVoidU64(e, obj.(*CmdVoidU64))
}
func (*binaryClassCmdVoidU64) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdVoidU64{}
	return obj, doDecodeCmdVoidU64(d, obj)
}
func (*binaryClassCmdVoidU64) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdVoidU64(d, obj.(*CmdVoidU64))
}
func (*binaryClassCmdVoidU64) Skip(d binary.Decoder) error { return doSkipCmdVoidU64(d) }
func (*binaryClassCmdVoidU64) Schema() *schema.Class       { return schemaCmdVoidU64 }

var schemaCmdVoidU64 = &schema.Class{
	TypeID:  binaryIDCmdVoidU64,
	Package: "test",
	Name:    "CmdVoidU64",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "A", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}},
	},
}

type binaryClassCmdVoidU8 struct{}

func (*CmdVoidU8) Class() binary.Class {
	return (*binaryClassCmdVoidU8)(nil)
}
func doEncodeCmdVoidU8(e binary.Encoder, o *CmdVoidU8) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Uint8(o.A); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdVoidU8(d binary.Decoder, o *CmdVoidU8) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if obj, err := d.Uint8(); err != nil {
		return err
	} else {
		o.A = uint8(obj)
	}
	return nil
}
func doSkipCmdVoidU8(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if _, err := d.Uint8(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdVoidU8) ID() binary.ID      { return binaryIDCmdVoidU8 }
func (*binaryClassCmdVoidU8) New() binary.Object { return &CmdVoidU8{} }
func (*binaryClassCmdVoidU8) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdVoidU8(e, obj.(*CmdVoidU8))
}
func (*binaryClassCmdVoidU8) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdVoidU8{}
	return obj, doDecodeCmdVoidU8(d, obj)
}
func (*binaryClassCmdVoidU8) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdVoidU8(d, obj.(*CmdVoidU8))
}
func (*binaryClassCmdVoidU8) Skip(d binary.Decoder) error { return doSkipCmdVoidU8(d) }
func (*binaryClassCmdVoidU8) Schema() *schema.Class       { return schemaCmdVoidU8 }

var schemaCmdVoidU8 = &schema.Class{
	TypeID:  binaryIDCmdVoidU8,
	Package: "test",
	Name:    "CmdVoidU8",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "A", Type: &schema.Primitive{Name: "uint8", Method: schema.Uint8}},
	},
}

type binaryClassCmdVoidWriteBool struct{}

func (*CmdVoidWriteBool) Class() binary.Class {
	return (*binaryClassCmdVoidWriteBool)(nil)
}
func doEncodeCmdVoidWriteBool(e binary.Encoder, o *CmdVoidWriteBool) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdVoidWriteBool(d binary.Decoder, o *CmdVoidWriteBool) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doSkipCmdVoidWriteBool(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*Boolᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdVoidWriteBool) ID() binary.ID      { return binaryIDCmdVoidWriteBool }
func (*binaryClassCmdVoidWriteBool) New() binary.Object { return &CmdVoidWriteBool{} }
func (*binaryClassCmdVoidWriteBool) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdVoidWriteBool(e, obj.(*CmdVoidWriteBool))
}
func (*binaryClassCmdVoidWriteBool) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdVoidWriteBool{}
	return obj, doDecodeCmdVoidWriteBool(d, obj)
}
func (*binaryClassCmdVoidWriteBool) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdVoidWriteBool(d, obj.(*CmdVoidWriteBool))
}
func (*binaryClassCmdVoidWriteBool) Skip(d binary.Decoder) error { return doSkipCmdVoidWriteBool(d) }
func (*binaryClassCmdVoidWriteBool) Schema() *schema.Class       { return schemaCmdVoidWriteBool }

var schemaCmdVoidWriteBool = &schema.Class{
	TypeID:  binaryIDCmdVoidWriteBool,
	Package: "test",
	Name:    "CmdVoidWriteBool",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "A", Type: &schema.Struct{Name: "Boolᵖ", ID: (*Boolᵖ)(nil).Class().ID()}},
	},
}

type binaryClassCmdVoidWriteF32 struct{}

func (*CmdVoidWriteF32) Class() binary.Class {
	return (*binaryClassCmdVoidWriteF32)(nil)
}
func doEncodeCmdVoidWriteF32(e binary.Encoder, o *CmdVoidWriteF32) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdVoidWriteF32(d binary.Decoder, o *CmdVoidWriteF32) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doSkipCmdVoidWriteF32(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*F32ᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdVoidWriteF32) ID() binary.ID      { return binaryIDCmdVoidWriteF32 }
func (*binaryClassCmdVoidWriteF32) New() binary.Object { return &CmdVoidWriteF32{} }
func (*binaryClassCmdVoidWriteF32) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdVoidWriteF32(e, obj.(*CmdVoidWriteF32))
}
func (*binaryClassCmdVoidWriteF32) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdVoidWriteF32{}
	return obj, doDecodeCmdVoidWriteF32(d, obj)
}
func (*binaryClassCmdVoidWriteF32) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdVoidWriteF32(d, obj.(*CmdVoidWriteF32))
}
func (*binaryClassCmdVoidWriteF32) Skip(d binary.Decoder) error { return doSkipCmdVoidWriteF32(d) }
func (*binaryClassCmdVoidWriteF32) Schema() *schema.Class       { return schemaCmdVoidWriteF32 }

var schemaCmdVoidWriteF32 = &schema.Class{
	TypeID:  binaryIDCmdVoidWriteF32,
	Package: "test",
	Name:    "CmdVoidWriteF32",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "A", Type: &schema.Struct{Name: "F32ᵖ", ID: (*F32ᵖ)(nil).Class().ID()}},
	},
}

type binaryClassCmdVoidWriteF64 struct{}

func (*CmdVoidWriteF64) Class() binary.Class {
	return (*binaryClassCmdVoidWriteF64)(nil)
}
func doEncodeCmdVoidWriteF64(e binary.Encoder, o *CmdVoidWriteF64) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdVoidWriteF64(d binary.Decoder, o *CmdVoidWriteF64) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doSkipCmdVoidWriteF64(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*F64ᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdVoidWriteF64) ID() binary.ID      { return binaryIDCmdVoidWriteF64 }
func (*binaryClassCmdVoidWriteF64) New() binary.Object { return &CmdVoidWriteF64{} }
func (*binaryClassCmdVoidWriteF64) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdVoidWriteF64(e, obj.(*CmdVoidWriteF64))
}
func (*binaryClassCmdVoidWriteF64) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdVoidWriteF64{}
	return obj, doDecodeCmdVoidWriteF64(d, obj)
}
func (*binaryClassCmdVoidWriteF64) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdVoidWriteF64(d, obj.(*CmdVoidWriteF64))
}
func (*binaryClassCmdVoidWriteF64) Skip(d binary.Decoder) error { return doSkipCmdVoidWriteF64(d) }
func (*binaryClassCmdVoidWriteF64) Schema() *schema.Class       { return schemaCmdVoidWriteF64 }

var schemaCmdVoidWriteF64 = &schema.Class{
	TypeID:  binaryIDCmdVoidWriteF64,
	Package: "test",
	Name:    "CmdVoidWriteF64",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "A", Type: &schema.Struct{Name: "F64ᵖ", ID: (*F64ᵖ)(nil).Class().ID()}},
	},
}

type binaryClassCmdVoidWritePtrs struct{}

func (*CmdVoidWritePtrs) Class() binary.Class {
	return (*binaryClassCmdVoidWritePtrs)(nil)
}
func doEncodeCmdVoidWritePtrs(e binary.Encoder, o *CmdVoidWritePtrs) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.A); err != nil {
		return err
	}
	if err := e.Value(&o.B); err != nil {
		return err
	}
	if err := e.Value(&o.C); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdVoidWritePtrs(d binary.Decoder, o *CmdVoidWritePtrs) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.A); err != nil {
		return err
	}
	if err := d.Value(&o.B); err != nil {
		return err
	}
	if err := d.Value(&o.C); err != nil {
		return err
	}
	return nil
}
func doSkipCmdVoidWritePtrs(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*F32ᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*U16ᵖ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*Boolᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdVoidWritePtrs) ID() binary.ID      { return binaryIDCmdVoidWritePtrs }
func (*binaryClassCmdVoidWritePtrs) New() binary.Object { return &CmdVoidWritePtrs{} }
func (*binaryClassCmdVoidWritePtrs) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdVoidWritePtrs(e, obj.(*CmdVoidWritePtrs))
}
func (*binaryClassCmdVoidWritePtrs) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdVoidWritePtrs{}
	return obj, doDecodeCmdVoidWritePtrs(d, obj)
}
func (*binaryClassCmdVoidWritePtrs) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdVoidWritePtrs(d, obj.(*CmdVoidWritePtrs))
}
func (*binaryClassCmdVoidWritePtrs) Skip(d binary.Decoder) error { return doSkipCmdVoidWritePtrs(d) }
func (*binaryClassCmdVoidWritePtrs) Schema() *schema.Class       { return schemaCmdVoidWritePtrs }

var schemaCmdVoidWritePtrs = &schema.Class{
	TypeID:  binaryIDCmdVoidWritePtrs,
	Package: "test",
	Name:    "CmdVoidWritePtrs",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "A", Type: &schema.Struct{Name: "F32ᵖ", ID: (*F32ᵖ)(nil).Class().ID()}},
		{Declared: "B", Type: &schema.Struct{Name: "U16ᵖ", ID: (*U16ᵖ)(nil).Class().ID()}},
		{Declared: "C", Type: &schema.Struct{Name: "Boolᵖ", ID: (*Boolᵖ)(nil).Class().ID()}},
	},
}

type binaryClassCmdVoidWriteS16 struct{}

func (*CmdVoidWriteS16) Class() binary.Class {
	return (*binaryClassCmdVoidWriteS16)(nil)
}
func doEncodeCmdVoidWriteS16(e binary.Encoder, o *CmdVoidWriteS16) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdVoidWriteS16(d binary.Decoder, o *CmdVoidWriteS16) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doSkipCmdVoidWriteS16(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*S16ᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdVoidWriteS16) ID() binary.ID      { return binaryIDCmdVoidWriteS16 }
func (*binaryClassCmdVoidWriteS16) New() binary.Object { return &CmdVoidWriteS16{} }
func (*binaryClassCmdVoidWriteS16) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdVoidWriteS16(e, obj.(*CmdVoidWriteS16))
}
func (*binaryClassCmdVoidWriteS16) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdVoidWriteS16{}
	return obj, doDecodeCmdVoidWriteS16(d, obj)
}
func (*binaryClassCmdVoidWriteS16) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdVoidWriteS16(d, obj.(*CmdVoidWriteS16))
}
func (*binaryClassCmdVoidWriteS16) Skip(d binary.Decoder) error { return doSkipCmdVoidWriteS16(d) }
func (*binaryClassCmdVoidWriteS16) Schema() *schema.Class       { return schemaCmdVoidWriteS16 }

var schemaCmdVoidWriteS16 = &schema.Class{
	TypeID:  binaryIDCmdVoidWriteS16,
	Package: "test",
	Name:    "CmdVoidWriteS16",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "A", Type: &schema.Struct{Name: "S16ᵖ", ID: (*S16ᵖ)(nil).Class().ID()}},
	},
}

type binaryClassCmdVoidWriteS32 struct{}

func (*CmdVoidWriteS32) Class() binary.Class {
	return (*binaryClassCmdVoidWriteS32)(nil)
}
func doEncodeCmdVoidWriteS32(e binary.Encoder, o *CmdVoidWriteS32) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdVoidWriteS32(d binary.Decoder, o *CmdVoidWriteS32) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doSkipCmdVoidWriteS32(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*S32ᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdVoidWriteS32) ID() binary.ID      { return binaryIDCmdVoidWriteS32 }
func (*binaryClassCmdVoidWriteS32) New() binary.Object { return &CmdVoidWriteS32{} }
func (*binaryClassCmdVoidWriteS32) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdVoidWriteS32(e, obj.(*CmdVoidWriteS32))
}
func (*binaryClassCmdVoidWriteS32) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdVoidWriteS32{}
	return obj, doDecodeCmdVoidWriteS32(d, obj)
}
func (*binaryClassCmdVoidWriteS32) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdVoidWriteS32(d, obj.(*CmdVoidWriteS32))
}
func (*binaryClassCmdVoidWriteS32) Skip(d binary.Decoder) error { return doSkipCmdVoidWriteS32(d) }
func (*binaryClassCmdVoidWriteS32) Schema() *schema.Class       { return schemaCmdVoidWriteS32 }

var schemaCmdVoidWriteS32 = &schema.Class{
	TypeID:  binaryIDCmdVoidWriteS32,
	Package: "test",
	Name:    "CmdVoidWriteS32",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "A", Type: &schema.Struct{Name: "S32ᵖ", ID: (*S32ᵖ)(nil).Class().ID()}},
	},
}

type binaryClassCmdVoidWriteS64 struct{}

func (*CmdVoidWriteS64) Class() binary.Class {
	return (*binaryClassCmdVoidWriteS64)(nil)
}
func doEncodeCmdVoidWriteS64(e binary.Encoder, o *CmdVoidWriteS64) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdVoidWriteS64(d binary.Decoder, o *CmdVoidWriteS64) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doSkipCmdVoidWriteS64(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*S64ᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdVoidWriteS64) ID() binary.ID      { return binaryIDCmdVoidWriteS64 }
func (*binaryClassCmdVoidWriteS64) New() binary.Object { return &CmdVoidWriteS64{} }
func (*binaryClassCmdVoidWriteS64) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdVoidWriteS64(e, obj.(*CmdVoidWriteS64))
}
func (*binaryClassCmdVoidWriteS64) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdVoidWriteS64{}
	return obj, doDecodeCmdVoidWriteS64(d, obj)
}
func (*binaryClassCmdVoidWriteS64) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdVoidWriteS64(d, obj.(*CmdVoidWriteS64))
}
func (*binaryClassCmdVoidWriteS64) Skip(d binary.Decoder) error { return doSkipCmdVoidWriteS64(d) }
func (*binaryClassCmdVoidWriteS64) Schema() *schema.Class       { return schemaCmdVoidWriteS64 }

var schemaCmdVoidWriteS64 = &schema.Class{
	TypeID:  binaryIDCmdVoidWriteS64,
	Package: "test",
	Name:    "CmdVoidWriteS64",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "A", Type: &schema.Struct{Name: "S64ᵖ", ID: (*S64ᵖ)(nil).Class().ID()}},
	},
}

type binaryClassCmdVoidWriteS8 struct{}

func (*CmdVoidWriteS8) Class() binary.Class {
	return (*binaryClassCmdVoidWriteS8)(nil)
}
func doEncodeCmdVoidWriteS8(e binary.Encoder, o *CmdVoidWriteS8) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdVoidWriteS8(d binary.Decoder, o *CmdVoidWriteS8) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doSkipCmdVoidWriteS8(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*S8ᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdVoidWriteS8) ID() binary.ID      { return binaryIDCmdVoidWriteS8 }
func (*binaryClassCmdVoidWriteS8) New() binary.Object { return &CmdVoidWriteS8{} }
func (*binaryClassCmdVoidWriteS8) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdVoidWriteS8(e, obj.(*CmdVoidWriteS8))
}
func (*binaryClassCmdVoidWriteS8) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdVoidWriteS8{}
	return obj, doDecodeCmdVoidWriteS8(d, obj)
}
func (*binaryClassCmdVoidWriteS8) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdVoidWriteS8(d, obj.(*CmdVoidWriteS8))
}
func (*binaryClassCmdVoidWriteS8) Skip(d binary.Decoder) error { return doSkipCmdVoidWriteS8(d) }
func (*binaryClassCmdVoidWriteS8) Schema() *schema.Class       { return schemaCmdVoidWriteS8 }

var schemaCmdVoidWriteS8 = &schema.Class{
	TypeID:  binaryIDCmdVoidWriteS8,
	Package: "test",
	Name:    "CmdVoidWriteS8",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "A", Type: &schema.Struct{Name: "S8ᵖ", ID: (*S8ᵖ)(nil).Class().ID()}},
	},
}

type binaryClassCmdVoidWriteU16 struct{}

func (*CmdVoidWriteU16) Class() binary.Class {
	return (*binaryClassCmdVoidWriteU16)(nil)
}
func doEncodeCmdVoidWriteU16(e binary.Encoder, o *CmdVoidWriteU16) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdVoidWriteU16(d binary.Decoder, o *CmdVoidWriteU16) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doSkipCmdVoidWriteU16(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*U16ᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdVoidWriteU16) ID() binary.ID      { return binaryIDCmdVoidWriteU16 }
func (*binaryClassCmdVoidWriteU16) New() binary.Object { return &CmdVoidWriteU16{} }
func (*binaryClassCmdVoidWriteU16) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdVoidWriteU16(e, obj.(*CmdVoidWriteU16))
}
func (*binaryClassCmdVoidWriteU16) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdVoidWriteU16{}
	return obj, doDecodeCmdVoidWriteU16(d, obj)
}
func (*binaryClassCmdVoidWriteU16) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdVoidWriteU16(d, obj.(*CmdVoidWriteU16))
}
func (*binaryClassCmdVoidWriteU16) Skip(d binary.Decoder) error { return doSkipCmdVoidWriteU16(d) }
func (*binaryClassCmdVoidWriteU16) Schema() *schema.Class       { return schemaCmdVoidWriteU16 }

var schemaCmdVoidWriteU16 = &schema.Class{
	TypeID:  binaryIDCmdVoidWriteU16,
	Package: "test",
	Name:    "CmdVoidWriteU16",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "A", Type: &schema.Struct{Name: "U16ᵖ", ID: (*U16ᵖ)(nil).Class().ID()}},
	},
}

type binaryClassCmdVoidWriteU32 struct{}

func (*CmdVoidWriteU32) Class() binary.Class {
	return (*binaryClassCmdVoidWriteU32)(nil)
}
func doEncodeCmdVoidWriteU32(e binary.Encoder, o *CmdVoidWriteU32) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdVoidWriteU32(d binary.Decoder, o *CmdVoidWriteU32) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doSkipCmdVoidWriteU32(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*U32ᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdVoidWriteU32) ID() binary.ID      { return binaryIDCmdVoidWriteU32 }
func (*binaryClassCmdVoidWriteU32) New() binary.Object { return &CmdVoidWriteU32{} }
func (*binaryClassCmdVoidWriteU32) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdVoidWriteU32(e, obj.(*CmdVoidWriteU32))
}
func (*binaryClassCmdVoidWriteU32) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdVoidWriteU32{}
	return obj, doDecodeCmdVoidWriteU32(d, obj)
}
func (*binaryClassCmdVoidWriteU32) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdVoidWriteU32(d, obj.(*CmdVoidWriteU32))
}
func (*binaryClassCmdVoidWriteU32) Skip(d binary.Decoder) error { return doSkipCmdVoidWriteU32(d) }
func (*binaryClassCmdVoidWriteU32) Schema() *schema.Class       { return schemaCmdVoidWriteU32 }

var schemaCmdVoidWriteU32 = &schema.Class{
	TypeID:  binaryIDCmdVoidWriteU32,
	Package: "test",
	Name:    "CmdVoidWriteU32",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "A", Type: &schema.Struct{Name: "U32ᵖ", ID: (*U32ᵖ)(nil).Class().ID()}},
	},
}

type binaryClassCmdVoidWriteU64 struct{}

func (*CmdVoidWriteU64) Class() binary.Class {
	return (*binaryClassCmdVoidWriteU64)(nil)
}
func doEncodeCmdVoidWriteU64(e binary.Encoder, o *CmdVoidWriteU64) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdVoidWriteU64(d binary.Decoder, o *CmdVoidWriteU64) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doSkipCmdVoidWriteU64(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*U64ᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdVoidWriteU64) ID() binary.ID      { return binaryIDCmdVoidWriteU64 }
func (*binaryClassCmdVoidWriteU64) New() binary.Object { return &CmdVoidWriteU64{} }
func (*binaryClassCmdVoidWriteU64) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdVoidWriteU64(e, obj.(*CmdVoidWriteU64))
}
func (*binaryClassCmdVoidWriteU64) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdVoidWriteU64{}
	return obj, doDecodeCmdVoidWriteU64(d, obj)
}
func (*binaryClassCmdVoidWriteU64) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdVoidWriteU64(d, obj.(*CmdVoidWriteU64))
}
func (*binaryClassCmdVoidWriteU64) Skip(d binary.Decoder) error { return doSkipCmdVoidWriteU64(d) }
func (*binaryClassCmdVoidWriteU64) Schema() *schema.Class       { return schemaCmdVoidWriteU64 }

var schemaCmdVoidWriteU64 = &schema.Class{
	TypeID:  binaryIDCmdVoidWriteU64,
	Package: "test",
	Name:    "CmdVoidWriteU64",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "A", Type: &schema.Struct{Name: "U64ᵖ", ID: (*U64ᵖ)(nil).Class().ID()}},
	},
}

type binaryClassCmdVoidWriteU8 struct{}

func (*CmdVoidWriteU8) Class() binary.Class {
	return (*binaryClassCmdVoidWriteU8)(nil)
}
func doEncodeCmdVoidWriteU8(e binary.Encoder, o *CmdVoidWriteU8) error {
	if err := e.Value(&o.observations); err != nil {
		return err
	}
	if err := e.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doDecodeCmdVoidWriteU8(d binary.Decoder, o *CmdVoidWriteU8) error {
	if err := d.Value(&o.observations); err != nil {
		return err
	}
	if err := d.Value(&o.A); err != nil {
		return err
	}
	return nil
}
func doSkipCmdVoidWriteU8(d binary.Decoder) error {
	if err := d.SkipValue((*atom.Observations)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*U8ᵖ)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassCmdVoidWriteU8) ID() binary.ID      { return binaryIDCmdVoidWriteU8 }
func (*binaryClassCmdVoidWriteU8) New() binary.Object { return &CmdVoidWriteU8{} }
func (*binaryClassCmdVoidWriteU8) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeCmdVoidWriteU8(e, obj.(*CmdVoidWriteU8))
}
func (*binaryClassCmdVoidWriteU8) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &CmdVoidWriteU8{}
	return obj, doDecodeCmdVoidWriteU8(d, obj)
}
func (*binaryClassCmdVoidWriteU8) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeCmdVoidWriteU8(d, obj.(*CmdVoidWriteU8))
}
func (*binaryClassCmdVoidWriteU8) Skip(d binary.Decoder) error { return doSkipCmdVoidWriteU8(d) }
func (*binaryClassCmdVoidWriteU8) Schema() *schema.Class       { return schemaCmdVoidWriteU8 }

var schemaCmdVoidWriteU8 = &schema.Class{
	TypeID:  binaryIDCmdVoidWriteU8,
	Package: "test",
	Name:    "CmdVoidWriteU8",
	Fields: []schema.Field{
		{Declared: "observations", Type: &schema.Struct{Name: "atom.Observations", ID: (*atom.Observations)(nil).Class().ID()}},
		{Declared: "A", Type: &schema.Struct{Name: "U8ᵖ", ID: (*U8ᵖ)(nil).Class().ID()}},
	},
}

type binaryClassF32ˢ struct{}

func (*F32ˢ) Class() binary.Class {
	return (*binaryClassF32ˢ)(nil)
}
func doEncodeF32ˢ(e binary.Encoder, o *F32ˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeF32ˢ(d binary.Decoder, o *F32ˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipF32ˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassF32ˢ) ID() binary.ID      { return binaryIDF32ˢ }
func (*binaryClassF32ˢ) New() binary.Object { return &F32ˢ{} }
func (*binaryClassF32ˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeF32ˢ(e, obj.(*F32ˢ))
}
func (*binaryClassF32ˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &F32ˢ{}
	return obj, doDecodeF32ˢ(d, obj)
}
func (*binaryClassF32ˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeF32ˢ(d, obj.(*F32ˢ))
}
func (*binaryClassF32ˢ) Skip(d binary.Decoder) error { return doSkipF32ˢ(d) }
func (*binaryClassF32ˢ) Schema() *schema.Class       { return schemaF32ˢ }

var schemaF32ˢ = &schema.Class{
	TypeID:  binaryIDF32ˢ,
	Package: "test",
	Name:    "F32ˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassF64ˢ struct{}

func (*F64ˢ) Class() binary.Class {
	return (*binaryClassF64ˢ)(nil)
}
func doEncodeF64ˢ(e binary.Encoder, o *F64ˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeF64ˢ(d binary.Decoder, o *F64ˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipF64ˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassF64ˢ) ID() binary.ID      { return binaryIDF64ˢ }
func (*binaryClassF64ˢ) New() binary.Object { return &F64ˢ{} }
func (*binaryClassF64ˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeF64ˢ(e, obj.(*F64ˢ))
}
func (*binaryClassF64ˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &F64ˢ{}
	return obj, doDecodeF64ˢ(d, obj)
}
func (*binaryClassF64ˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeF64ˢ(d, obj.(*F64ˢ))
}
func (*binaryClassF64ˢ) Skip(d binary.Decoder) error { return doSkipF64ˢ(d) }
func (*binaryClassF64ˢ) Schema() *schema.Class       { return schemaF64ˢ }

var schemaF64ˢ = &schema.Class{
	TypeID:  binaryIDF64ˢ,
	Package: "test",
	Name:    "F64ˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassImported struct{}

func (*Imported) Class() binary.Class {
	return (*binaryClassImported)(nil)
}
func doEncodeImported(e binary.Encoder, o *Imported) error {
	if err := e.Uint32(o.Value); err != nil {
		return err
	}
	return nil
}
func doDecodeImported(d binary.Decoder, o *Imported) error {
	if obj, err := d.Uint32(); err != nil {
		return err
	} else {
		o.Value = uint32(obj)
	}
	return nil
}
func doSkipImported(d binary.Decoder) error {
	if _, err := d.Uint32(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassImported) ID() binary.ID      { return binaryIDImported }
func (*binaryClassImported) New() binary.Object { return &Imported{} }
func (*binaryClassImported) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeImported(e, obj.(*Imported))
}
func (*binaryClassImported) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Imported{}
	return obj, doDecodeImported(d, obj)
}
func (*binaryClassImported) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeImported(d, obj.(*Imported))
}
func (*binaryClassImported) Skip(d binary.Decoder) error { return doSkipImported(d) }
func (*binaryClassImported) Schema() *schema.Class       { return schemaImported }

var schemaImported = &schema.Class{
	TypeID:  binaryIDImported,
	Package: "test",
	Name:    "Imported",
	Fields: []schema.Field{
		{Declared: "Value", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}},
	},
}

type binaryClassIncluded struct{}

func (*Included) Class() binary.Class {
	return (*binaryClassIncluded)(nil)
}
func doEncodeIncluded(e binary.Encoder, o *Included) error {
	if err := e.Uint64(uint64(o.CreatedAt)); err != nil {
		return err
	}
	if err := e.String(o.S); err != nil {
		return err
	}
	return nil
}
func doDecodeIncluded(d binary.Decoder, o *Included) error {
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.CreatedAt = atom.ID(obj)
	}
	if obj, err := d.String(); err != nil {
		return err
	} else {
		o.S = string(obj)
	}
	return nil
}
func doSkipIncluded(d binary.Decoder) error {
	if _, err := d.Uint64(); err != nil {
		return err
	}
	if err := d.SkipString(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassIncluded) ID() binary.ID      { return binaryIDIncluded }
func (*binaryClassIncluded) New() binary.Object { return &Included{} }
func (*binaryClassIncluded) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeIncluded(e, obj.(*Included))
}
func (*binaryClassIncluded) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Included{}
	return obj, doDecodeIncluded(d, obj)
}
func (*binaryClassIncluded) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeIncluded(d, obj.(*Included))
}
func (*binaryClassIncluded) Skip(d binary.Decoder) error { return doSkipIncluded(d) }
func (*binaryClassIncluded) Schema() *schema.Class       { return schemaIncluded }

var schemaIncluded = &schema.Class{
	TypeID:  binaryIDIncluded,
	Package: "test",
	Name:    "Included",
	Fields: []schema.Field{
		{Declared: "CreatedAt", Type: &schema.Primitive{Name: "atom.ID", Method: schema.Uint64}},
		{Declared: "S", Type: &schema.Primitive{Name: "string", Method: schema.String}},
	},
}

type binaryClassIntˢ struct{}

func (*Intˢ) Class() binary.Class {
	return (*binaryClassIntˢ)(nil)
}
func doEncodeIntˢ(e binary.Encoder, o *Intˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeIntˢ(d binary.Decoder, o *Intˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipIntˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassIntˢ) ID() binary.ID      { return binaryIDIntˢ }
func (*binaryClassIntˢ) New() binary.Object { return &Intˢ{} }
func (*binaryClassIntˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeIntˢ(e, obj.(*Intˢ))
}
func (*binaryClassIntˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Intˢ{}
	return obj, doDecodeIntˢ(d, obj)
}
func (*binaryClassIntˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeIntˢ(d, obj.(*Intˢ))
}
func (*binaryClassIntˢ) Skip(d binary.Decoder) error { return doSkipIntˢ(d) }
func (*binaryClassIntˢ) Schema() *schema.Class       { return schemaIntˢ }

var schemaIntˢ = &schema.Class{
	TypeID:  binaryIDIntˢ,
	Package: "test",
	Name:    "Intˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassRemappedˢ struct{}

func (*Remappedˢ) Class() binary.Class {
	return (*binaryClassRemappedˢ)(nil)
}
func doEncodeRemappedˢ(e binary.Encoder, o *Remappedˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeRemappedˢ(d binary.Decoder, o *Remappedˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipRemappedˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassRemappedˢ) ID() binary.ID      { return binaryIDRemappedˢ }
func (*binaryClassRemappedˢ) New() binary.Object { return &Remappedˢ{} }
func (*binaryClassRemappedˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeRemappedˢ(e, obj.(*Remappedˢ))
}
func (*binaryClassRemappedˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Remappedˢ{}
	return obj, doDecodeRemappedˢ(d, obj)
}
func (*binaryClassRemappedˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeRemappedˢ(d, obj.(*Remappedˢ))
}
func (*binaryClassRemappedˢ) Skip(d binary.Decoder) error { return doSkipRemappedˢ(d) }
func (*binaryClassRemappedˢ) Schema() *schema.Class       { return schemaRemappedˢ }

var schemaRemappedˢ = &schema.Class{
	TypeID:  binaryIDRemappedˢ,
	Package: "test",
	Name:    "Remappedˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassS16ˢ struct{}

func (*S16ˢ) Class() binary.Class {
	return (*binaryClassS16ˢ)(nil)
}
func doEncodeS16ˢ(e binary.Encoder, o *S16ˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeS16ˢ(d binary.Decoder, o *S16ˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipS16ˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassS16ˢ) ID() binary.ID      { return binaryIDS16ˢ }
func (*binaryClassS16ˢ) New() binary.Object { return &S16ˢ{} }
func (*binaryClassS16ˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeS16ˢ(e, obj.(*S16ˢ))
}
func (*binaryClassS16ˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &S16ˢ{}
	return obj, doDecodeS16ˢ(d, obj)
}
func (*binaryClassS16ˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeS16ˢ(d, obj.(*S16ˢ))
}
func (*binaryClassS16ˢ) Skip(d binary.Decoder) error { return doSkipS16ˢ(d) }
func (*binaryClassS16ˢ) Schema() *schema.Class       { return schemaS16ˢ }

var schemaS16ˢ = &schema.Class{
	TypeID:  binaryIDS16ˢ,
	Package: "test",
	Name:    "S16ˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassS32ˢ struct{}

func (*S32ˢ) Class() binary.Class {
	return (*binaryClassS32ˢ)(nil)
}
func doEncodeS32ˢ(e binary.Encoder, o *S32ˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeS32ˢ(d binary.Decoder, o *S32ˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipS32ˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassS32ˢ) ID() binary.ID      { return binaryIDS32ˢ }
func (*binaryClassS32ˢ) New() binary.Object { return &S32ˢ{} }
func (*binaryClassS32ˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeS32ˢ(e, obj.(*S32ˢ))
}
func (*binaryClassS32ˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &S32ˢ{}
	return obj, doDecodeS32ˢ(d, obj)
}
func (*binaryClassS32ˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeS32ˢ(d, obj.(*S32ˢ))
}
func (*binaryClassS32ˢ) Skip(d binary.Decoder) error { return doSkipS32ˢ(d) }
func (*binaryClassS32ˢ) Schema() *schema.Class       { return schemaS32ˢ }

var schemaS32ˢ = &schema.Class{
	TypeID:  binaryIDS32ˢ,
	Package: "test",
	Name:    "S32ˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassS64ˢ struct{}

func (*S64ˢ) Class() binary.Class {
	return (*binaryClassS64ˢ)(nil)
}
func doEncodeS64ˢ(e binary.Encoder, o *S64ˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeS64ˢ(d binary.Decoder, o *S64ˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipS64ˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassS64ˢ) ID() binary.ID      { return binaryIDS64ˢ }
func (*binaryClassS64ˢ) New() binary.Object { return &S64ˢ{} }
func (*binaryClassS64ˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeS64ˢ(e, obj.(*S64ˢ))
}
func (*binaryClassS64ˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &S64ˢ{}
	return obj, doDecodeS64ˢ(d, obj)
}
func (*binaryClassS64ˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeS64ˢ(d, obj.(*S64ˢ))
}
func (*binaryClassS64ˢ) Skip(d binary.Decoder) error { return doSkipS64ˢ(d) }
func (*binaryClassS64ˢ) Schema() *schema.Class       { return schemaS64ˢ }

var schemaS64ˢ = &schema.Class{
	TypeID:  binaryIDS64ˢ,
	Package: "test",
	Name:    "S64ˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassS8ˢ struct{}

func (*S8ˢ) Class() binary.Class {
	return (*binaryClassS8ˢ)(nil)
}
func doEncodeS8ˢ(e binary.Encoder, o *S8ˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeS8ˢ(d binary.Decoder, o *S8ˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipS8ˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassS8ˢ) ID() binary.ID      { return binaryIDS8ˢ }
func (*binaryClassS8ˢ) New() binary.Object { return &S8ˢ{} }
func (*binaryClassS8ˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeS8ˢ(e, obj.(*S8ˢ))
}
func (*binaryClassS8ˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &S8ˢ{}
	return obj, doDecodeS8ˢ(d, obj)
}
func (*binaryClassS8ˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeS8ˢ(d, obj.(*S8ˢ))
}
func (*binaryClassS8ˢ) Skip(d binary.Decoder) error { return doSkipS8ˢ(d) }
func (*binaryClassS8ˢ) Schema() *schema.Class       { return schemaS8ˢ }

var schemaS8ˢ = &schema.Class{
	TypeID:  binaryIDS8ˢ,
	Package: "test",
	Name:    "S8ˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassU8ˢ struct{}

func (*U8ˢ) Class() binary.Class {
	return (*binaryClassU8ˢ)(nil)
}
func doEncodeU8ˢ(e binary.Encoder, o *U8ˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeU8ˢ(d binary.Decoder, o *U8ˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipU8ˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassU8ˢ) ID() binary.ID      { return binaryIDU8ˢ }
func (*binaryClassU8ˢ) New() binary.Object { return &U8ˢ{} }
func (*binaryClassU8ˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeU8ˢ(e, obj.(*U8ˢ))
}
func (*binaryClassU8ˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &U8ˢ{}
	return obj, doDecodeU8ˢ(d, obj)
}
func (*binaryClassU8ˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeU8ˢ(d, obj.(*U8ˢ))
}
func (*binaryClassU8ˢ) Skip(d binary.Decoder) error { return doSkipU8ˢ(d) }
func (*binaryClassU8ˢ) Schema() *schema.Class       { return schemaU8ˢ }

var schemaU8ˢ = &schema.Class{
	TypeID:  binaryIDU8ˢ,
	Package: "test",
	Name:    "U8ˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassU16ˢ struct{}

func (*U16ˢ) Class() binary.Class {
	return (*binaryClassU16ˢ)(nil)
}
func doEncodeU16ˢ(e binary.Encoder, o *U16ˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeU16ˢ(d binary.Decoder, o *U16ˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipU16ˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassU16ˢ) ID() binary.ID      { return binaryIDU16ˢ }
func (*binaryClassU16ˢ) New() binary.Object { return &U16ˢ{} }
func (*binaryClassU16ˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeU16ˢ(e, obj.(*U16ˢ))
}
func (*binaryClassU16ˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &U16ˢ{}
	return obj, doDecodeU16ˢ(d, obj)
}
func (*binaryClassU16ˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeU16ˢ(d, obj.(*U16ˢ))
}
func (*binaryClassU16ˢ) Skip(d binary.Decoder) error { return doSkipU16ˢ(d) }
func (*binaryClassU16ˢ) Schema() *schema.Class       { return schemaU16ˢ }

var schemaU16ˢ = &schema.Class{
	TypeID:  binaryIDU16ˢ,
	Package: "test",
	Name:    "U16ˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassU32ˢ struct{}

func (*U32ˢ) Class() binary.Class {
	return (*binaryClassU32ˢ)(nil)
}
func doEncodeU32ˢ(e binary.Encoder, o *U32ˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeU32ˢ(d binary.Decoder, o *U32ˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipU32ˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassU32ˢ) ID() binary.ID      { return binaryIDU32ˢ }
func (*binaryClassU32ˢ) New() binary.Object { return &U32ˢ{} }
func (*binaryClassU32ˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeU32ˢ(e, obj.(*U32ˢ))
}
func (*binaryClassU32ˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &U32ˢ{}
	return obj, doDecodeU32ˢ(d, obj)
}
func (*binaryClassU32ˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeU32ˢ(d, obj.(*U32ˢ))
}
func (*binaryClassU32ˢ) Skip(d binary.Decoder) error { return doSkipU32ˢ(d) }
func (*binaryClassU32ˢ) Schema() *schema.Class       { return schemaU32ˢ }

var schemaU32ˢ = &schema.Class{
	TypeID:  binaryIDU32ˢ,
	Package: "test",
	Name:    "U32ˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassState struct{}

func (*State) Class() binary.Class {
	return (*binaryClassState)(nil)
}
func doEncodeState(e binary.Encoder, o *State) error {
	if err := e.Value(&o.U8s); err != nil {
		return err
	}
	if err := e.Value(&o.U16s); err != nil {
		return err
	}
	if err := e.Value(&o.U32s); err != nil {
		return err
	}
	if err := e.Value(&o.Ints); err != nil {
		return err
	}
	if err := e.String(o.Str); err != nil {
		return err
	}
	return nil
}
func doDecodeState(d binary.Decoder, o *State) error {
	if err := d.Value(&o.U8s); err != nil {
		return err
	}
	if err := d.Value(&o.U16s); err != nil {
		return err
	}
	if err := d.Value(&o.U32s); err != nil {
		return err
	}
	if err := d.Value(&o.Ints); err != nil {
		return err
	}
	if obj, err := d.String(); err != nil {
		return err
	} else {
		o.Str = string(obj)
	}
	return nil
}
func doSkipState(d binary.Decoder) error {
	if err := d.SkipValue((*U8ˢ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*U16ˢ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*U32ˢ)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*Intˢ)(nil)); err != nil {
		return err
	}
	if err := d.SkipString(); err != nil {
		return err
	}
	return nil
}
func (*binaryClassState) ID() binary.ID      { return binaryIDState }
func (*binaryClassState) New() binary.Object { return &State{} }
func (*binaryClassState) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeState(e, obj.(*State))
}
func (*binaryClassState) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &State{}
	return obj, doDecodeState(d, obj)
}
func (*binaryClassState) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeState(d, obj.(*State))
}
func (*binaryClassState) Skip(d binary.Decoder) error { return doSkipState(d) }
func (*binaryClassState) Schema() *schema.Class       { return schemaState }

var schemaState = &schema.Class{
	TypeID:  binaryIDState,
	Package: "test",
	Name:    "State",
	Fields: []schema.Field{
		{Declared: "U8s", Type: &schema.Struct{Name: "U8ˢ", ID: (*U8ˢ)(nil).Class().ID()}},
		{Declared: "U16s", Type: &schema.Struct{Name: "U16ˢ", ID: (*U16ˢ)(nil).Class().ID()}},
		{Declared: "U32s", Type: &schema.Struct{Name: "U32ˢ", ID: (*U32ˢ)(nil).Class().ID()}},
		{Declared: "Ints", Type: &schema.Struct{Name: "Intˢ", ID: (*Intˢ)(nil).Class().ID()}},
		{Declared: "Str", Type: &schema.Primitive{Name: "string", Method: schema.String}},
	},
}

type binaryClassTester struct{}

func (*Tester) Class() binary.Class {
	return (*binaryClassTester)(nil)
}
func doEncodeTester(e binary.Encoder, o *Tester) error {
	if err := e.Uint64(uint64(o.CreatedAt)); err != nil {
		return err
	}
	if err := e.Value(&o.A); err != nil {
		return err
	}
	if err := e.Value(&o.B); err != nil {
		return err
	}
	return nil
}
func doDecodeTester(d binary.Decoder, o *Tester) error {
	if obj, err := d.Uint64(); err != nil {
		return err
	} else {
		o.CreatedAt = atom.ID(obj)
	}
	if err := d.Value(&o.A); err != nil {
		return err
	}
	if err := d.Value(&o.B); err != nil {
		return err
	}
	return nil
}
func doSkipTester(d binary.Decoder) error {
	if _, err := d.Uint64(); err != nil {
		return err
	}
	if err := d.SkipValue((*Imported)(nil)); err != nil {
		return err
	}
	if err := d.SkipValue((*Included)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassTester) ID() binary.ID      { return binaryIDTester }
func (*binaryClassTester) New() binary.Object { return &Tester{} }
func (*binaryClassTester) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeTester(e, obj.(*Tester))
}
func (*binaryClassTester) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Tester{}
	return obj, doDecodeTester(d, obj)
}
func (*binaryClassTester) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeTester(d, obj.(*Tester))
}
func (*binaryClassTester) Skip(d binary.Decoder) error { return doSkipTester(d) }
func (*binaryClassTester) Schema() *schema.Class       { return schemaTester }

var schemaTester = &schema.Class{
	TypeID:  binaryIDTester,
	Package: "test",
	Name:    "Tester",
	Fields: []schema.Field{
		{Declared: "CreatedAt", Type: &schema.Primitive{Name: "atom.ID", Method: schema.Uint64}},
		{Declared: "A", Type: &schema.Struct{Name: "Imported", ID: (*Imported)(nil).Class().ID()}},
		{Declared: "B", Type: &schema.Struct{Name: "Included", ID: (*Included)(nil).Class().ID()}},
	},
}

type binaryClassU64ˢ struct{}

func (*U64ˢ) Class() binary.Class {
	return (*binaryClassU64ˢ)(nil)
}
func doEncodeU64ˢ(e binary.Encoder, o *U64ˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeU64ˢ(d binary.Decoder, o *U64ˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipU64ˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassU64ˢ) ID() binary.ID      { return binaryIDU64ˢ }
func (*binaryClassU64ˢ) New() binary.Object { return &U64ˢ{} }
func (*binaryClassU64ˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeU64ˢ(e, obj.(*U64ˢ))
}
func (*binaryClassU64ˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &U64ˢ{}
	return obj, doDecodeU64ˢ(d, obj)
}
func (*binaryClassU64ˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeU64ˢ(d, obj.(*U64ˢ))
}
func (*binaryClassU64ˢ) Skip(d binary.Decoder) error { return doSkipU64ˢ(d) }
func (*binaryClassU64ˢ) Schema() *schema.Class       { return schemaU64ˢ }

var schemaU64ˢ = &schema.Class{
	TypeID:  binaryIDU64ˢ,
	Package: "test",
	Name:    "U64ˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}

type binaryClassVoidˢ struct{}

func (*Voidˢ) Class() binary.Class {
	return (*binaryClassVoidˢ)(nil)
}
func doEncodeVoidˢ(e binary.Encoder, o *Voidˢ) error {
	if err := e.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doDecodeVoidˢ(d binary.Decoder, o *Voidˢ) error {
	if err := d.Value(&o.SliceInfo); err != nil {
		return err
	}
	return nil
}
func doSkipVoidˢ(d binary.Decoder) error {
	if err := d.SkipValue((*SliceInfo)(nil)); err != nil {
		return err
	}
	return nil
}
func (*binaryClassVoidˢ) ID() binary.ID      { return binaryIDVoidˢ }
func (*binaryClassVoidˢ) New() binary.Object { return &Voidˢ{} }
func (*binaryClassVoidˢ) Encode(e binary.Encoder, obj binary.Object) error {
	return doEncodeVoidˢ(e, obj.(*Voidˢ))
}
func (*binaryClassVoidˢ) Decode(d binary.Decoder) (binary.Object, error) {
	obj := &Voidˢ{}
	return obj, doDecodeVoidˢ(d, obj)
}
func (*binaryClassVoidˢ) DecodeTo(d binary.Decoder, obj binary.Object) error {
	return doDecodeVoidˢ(d, obj.(*Voidˢ))
}
func (*binaryClassVoidˢ) Skip(d binary.Decoder) error { return doSkipVoidˢ(d) }
func (*binaryClassVoidˢ) Schema() *schema.Class       { return schemaVoidˢ }

var schemaVoidˢ = &schema.Class{
	TypeID:  binaryIDVoidˢ,
	Package: "test",
	Name:    "Voidˢ",
	Fields: []schema.Field{
		{Declared: "", Type: &schema.Struct{Name: "SliceInfo", ID: (*SliceInfo)(nil).Class().ID()}},
	},
}