////////////////////////////////////////////////////////////////////////////////
// Automatically generated file. Do not modify!
////////////////////////////////////////////////////////////////////////////////

package test

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

func init() {
	sc_CmdClone := schema.Of((*CmdClone)(nil).Class())
	sc_CmdClone.Metadata = append(sc_CmdClone.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdClone",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdMake := schema.Of((*CmdMake)(nil).Class())
	sc_CmdMake.Metadata = append(sc_CmdMake.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdMake",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdCopy := schema.Of((*CmdCopy)(nil).Class())
	sc_CmdCopy.Metadata = append(sc_CmdCopy.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdCopy",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdCharsliceToString := schema.Of((*CmdCharsliceToString)(nil).Class())
	sc_CmdCharsliceToString.Metadata = append(sc_CmdCharsliceToString.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdCharsliceToString",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdCharptrToString := schema.Of((*CmdCharptrToString)(nil).Class())
	sc_CmdCharptrToString.Metadata = append(sc_CmdCharptrToString.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdCharptrToString",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdSliceCasts := schema.Of((*CmdSliceCasts)(nil).Class())
	sc_CmdSliceCasts.Metadata = append(sc_CmdSliceCasts.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdSliceCasts",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdVoid := schema.Of((*CmdVoid)(nil).Class())
	sc_CmdVoid.Metadata = append(sc_CmdVoid.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdVoid",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdUnknownRet := schema.Of((*CmdUnknownRet)(nil).Class())
	sc_CmdUnknownRet.Metadata = append(sc_CmdUnknownRet.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdUnknownRet",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdUnknownWritePtr := schema.Of((*CmdUnknownWritePtr)(nil).Class())
	sc_CmdUnknownWritePtr.Metadata = append(sc_CmdUnknownWritePtr.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdUnknownWritePtr",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdUnknownWriteSlice := schema.Of((*CmdUnknownWriteSlice)(nil).Class())
	sc_CmdUnknownWriteSlice.Metadata = append(sc_CmdUnknownWriteSlice.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdUnknownWriteSlice",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdVoidU8 := schema.Of((*CmdVoidU8)(nil).Class())
	sc_CmdVoidU8.Metadata = append(sc_CmdVoidU8.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdVoidU8",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdVoidS8 := schema.Of((*CmdVoidS8)(nil).Class())
	sc_CmdVoidS8.Metadata = append(sc_CmdVoidS8.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdVoidS8",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdVoidU16 := schema.Of((*CmdVoidU16)(nil).Class())
	sc_CmdVoidU16.Metadata = append(sc_CmdVoidU16.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdVoidU16",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdVoidS16 := schema.Of((*CmdVoidS16)(nil).Class())
	sc_CmdVoidS16.Metadata = append(sc_CmdVoidS16.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdVoidS16",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdVoidF32 := schema.Of((*CmdVoidF32)(nil).Class())
	sc_CmdVoidF32.Metadata = append(sc_CmdVoidF32.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdVoidF32",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdVoidU32 := schema.Of((*CmdVoidU32)(nil).Class())
	sc_CmdVoidU32.Metadata = append(sc_CmdVoidU32.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdVoidU32",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdVoidS32 := schema.Of((*CmdVoidS32)(nil).Class())
	sc_CmdVoidS32.Metadata = append(sc_CmdVoidS32.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdVoidS32",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdVoidF64 := schema.Of((*CmdVoidF64)(nil).Class())
	sc_CmdVoidF64.Metadata = append(sc_CmdVoidF64.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdVoidF64",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdVoidU64 := schema.Of((*CmdVoidU64)(nil).Class())
	sc_CmdVoidU64.Metadata = append(sc_CmdVoidU64.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdVoidU64",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdVoidS64 := schema.Of((*CmdVoidS64)(nil).Class())
	sc_CmdVoidS64.Metadata = append(sc_CmdVoidS64.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdVoidS64",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdVoidBool := schema.Of((*CmdVoidBool)(nil).Class())
	sc_CmdVoidBool.Metadata = append(sc_CmdVoidBool.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdVoidBool",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdVoidString := schema.Of((*CmdVoidString)(nil).Class())
	sc_CmdVoidString.Metadata = append(sc_CmdVoidString.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdVoidString",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdVoid3Strings := schema.Of((*CmdVoid3Strings)(nil).Class())
	sc_CmdVoid3Strings.Metadata = append(sc_CmdVoid3Strings.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdVoid3Strings",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdVoid3InArrays := schema.Of((*CmdVoid3InArrays)(nil).Class())
	sc_CmdVoid3InArrays.Metadata = append(sc_CmdVoid3InArrays.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdVoid3InArrays",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdVoidInArrayOfPointers := schema.Of((*CmdVoidInArrayOfPointers)(nil).Class())
	sc_CmdVoidInArrayOfPointers.Metadata = append(sc_CmdVoidInArrayOfPointers.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdVoidInArrayOfPointers",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdVoidReadU8 := schema.Of((*CmdVoidReadU8)(nil).Class())
	sc_CmdVoidReadU8.Metadata = append(sc_CmdVoidReadU8.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdVoidReadU8",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdVoidReadS8 := schema.Of((*CmdVoidReadS8)(nil).Class())
	sc_CmdVoidReadS8.Metadata = append(sc_CmdVoidReadS8.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdVoidReadS8",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdVoidReadU16 := schema.Of((*CmdVoidReadU16)(nil).Class())
	sc_CmdVoidReadU16.Metadata = append(sc_CmdVoidReadU16.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdVoidReadU16",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdVoidReadS16 := schema.Of((*CmdVoidReadS16)(nil).Class())
	sc_CmdVoidReadS16.Metadata = append(sc_CmdVoidReadS16.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdVoidReadS16",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdVoidReadF32 := schema.Of((*CmdVoidReadF32)(nil).Class())
	sc_CmdVoidReadF32.Metadata = append(sc_CmdVoidReadF32.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdVoidReadF32",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdVoidReadU32 := schema.Of((*CmdVoidReadU32)(nil).Class())
	sc_CmdVoidReadU32.Metadata = append(sc_CmdVoidReadU32.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdVoidReadU32",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdVoidReadS32 := schema.Of((*CmdVoidReadS32)(nil).Class())
	sc_CmdVoidReadS32.Metadata = append(sc_CmdVoidReadS32.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdVoidReadS32",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdVoidReadF64 := schema.Of((*CmdVoidReadF64)(nil).Class())
	sc_CmdVoidReadF64.Metadata = append(sc_CmdVoidReadF64.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdVoidReadF64",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdVoidReadU64 := schema.Of((*CmdVoidReadU64)(nil).Class())
	sc_CmdVoidReadU64.Metadata = append(sc_CmdVoidReadU64.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdVoidReadU64",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdVoidReadS64 := schema.Of((*CmdVoidReadS64)(nil).Class())
	sc_CmdVoidReadS64.Metadata = append(sc_CmdVoidReadS64.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdVoidReadS64",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdVoidReadBool := schema.Of((*CmdVoidReadBool)(nil).Class())
	sc_CmdVoidReadBool.Metadata = append(sc_CmdVoidReadBool.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdVoidReadBool",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdVoidReadPtrs := schema.Of((*CmdVoidReadPtrs)(nil).Class())
	sc_CmdVoidReadPtrs.Metadata = append(sc_CmdVoidReadPtrs.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdVoidReadPtrs",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdVoidWriteU8 := schema.Of((*CmdVoidWriteU8)(nil).Class())
	sc_CmdVoidWriteU8.Metadata = append(sc_CmdVoidWriteU8.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdVoidWriteU8",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdVoidWriteS8 := schema.Of((*CmdVoidWriteS8)(nil).Class())
	sc_CmdVoidWriteS8.Metadata = append(sc_CmdVoidWriteS8.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdVoidWriteS8",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdVoidWriteU16 := schema.Of((*CmdVoidWriteU16)(nil).Class())
	sc_CmdVoidWriteU16.Metadata = append(sc_CmdVoidWriteU16.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdVoidWriteU16",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdVoidWriteS16 := schema.Of((*CmdVoidWriteS16)(nil).Class())
	sc_CmdVoidWriteS16.Metadata = append(sc_CmdVoidWriteS16.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdVoidWriteS16",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdVoidWriteF32 := schema.Of((*CmdVoidWriteF32)(nil).Class())
	sc_CmdVoidWriteF32.Metadata = append(sc_CmdVoidWriteF32.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdVoidWriteF32",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdVoidWriteU32 := schema.Of((*CmdVoidWriteU32)(nil).Class())
	sc_CmdVoidWriteU32.Metadata = append(sc_CmdVoidWriteU32.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdVoidWriteU32",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdVoidWriteS32 := schema.Of((*CmdVoidWriteS32)(nil).Class())
	sc_CmdVoidWriteS32.Metadata = append(sc_CmdVoidWriteS32.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdVoidWriteS32",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdVoidWriteF64 := schema.Of((*CmdVoidWriteF64)(nil).Class())
	sc_CmdVoidWriteF64.Metadata = append(sc_CmdVoidWriteF64.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdVoidWriteF64",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdVoidWriteU64 := schema.Of((*CmdVoidWriteU64)(nil).Class())
	sc_CmdVoidWriteU64.Metadata = append(sc_CmdVoidWriteU64.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdVoidWriteU64",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdVoidWriteS64 := schema.Of((*CmdVoidWriteS64)(nil).Class())
	sc_CmdVoidWriteS64.Metadata = append(sc_CmdVoidWriteS64.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdVoidWriteS64",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdVoidWriteBool := schema.Of((*CmdVoidWriteBool)(nil).Class())
	sc_CmdVoidWriteBool.Metadata = append(sc_CmdVoidWriteBool.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdVoidWriteBool",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdVoidWritePtrs := schema.Of((*CmdVoidWritePtrs)(nil).Class())
	sc_CmdVoidWritePtrs.Metadata = append(sc_CmdVoidWritePtrs.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdVoidWritePtrs",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdU8 := schema.Of((*CmdU8)(nil).Class())
	sc_CmdU8.Metadata = append(sc_CmdU8.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdU8",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdS8 := schema.Of((*CmdS8)(nil).Class())
	sc_CmdS8.Metadata = append(sc_CmdS8.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdS8",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdU16 := schema.Of((*CmdU16)(nil).Class())
	sc_CmdU16.Metadata = append(sc_CmdU16.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdU16",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdS16 := schema.Of((*CmdS16)(nil).Class())
	sc_CmdS16.Metadata = append(sc_CmdS16.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdS16",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdF32 := schema.Of((*CmdF32)(nil).Class())
	sc_CmdF32.Metadata = append(sc_CmdF32.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdF32",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdU32 := schema.Of((*CmdU32)(nil).Class())
	sc_CmdU32.Metadata = append(sc_CmdU32.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdU32",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdS32 := schema.Of((*CmdS32)(nil).Class())
	sc_CmdS32.Metadata = append(sc_CmdS32.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdS32",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdF64 := schema.Of((*CmdF64)(nil).Class())
	sc_CmdF64.Metadata = append(sc_CmdF64.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdF64",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdU64 := schema.Of((*CmdU64)(nil).Class())
	sc_CmdU64.Metadata = append(sc_CmdU64.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdU64",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdS64 := schema.Of((*CmdS64)(nil).Class())
	sc_CmdS64.Metadata = append(sc_CmdS64.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdS64",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdBool := schema.Of((*CmdBool)(nil).Class())
	sc_CmdBool.Metadata = append(sc_CmdBool.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdBool",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdString := schema.Of((*CmdString)(nil).Class())
	sc_CmdString.Metadata = append(sc_CmdString.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdString",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdPointer := schema.Of((*CmdPointer)(nil).Class())
	sc_CmdPointer.Metadata = append(sc_CmdPointer.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdPointer",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdVoid3Remapped := schema.Of((*CmdVoid3Remapped)(nil).Class())
	sc_CmdVoid3Remapped.Metadata = append(sc_CmdVoid3Remapped.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdVoid3Remapped",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdVoidInArrayOfRemapped := schema.Of((*CmdVoidInArrayOfRemapped)(nil).Class())
	sc_CmdVoidInArrayOfRemapped.Metadata = append(sc_CmdVoidInArrayOfRemapped.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdVoidInArrayOfRemapped",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdVoidOutArrayOfRemapped := schema.Of((*CmdVoidOutArrayOfRemapped)(nil).Class())
	sc_CmdVoidOutArrayOfRemapped.Metadata = append(sc_CmdVoidOutArrayOfRemapped.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdVoidOutArrayOfRemapped",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdVoidOutArrayOfUnknownRemapped := schema.Of((*CmdVoidOutArrayOfUnknownRemapped)(nil).Class())
	sc_CmdVoidOutArrayOfUnknownRemapped.Metadata = append(sc_CmdVoidOutArrayOfUnknownRemapped.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdVoidOutArrayOfUnknownRemapped",
		Flags:            0,
		DocumentationUrl: "[]",
	})

	sc_CmdRemapped := schema.Of((*CmdRemapped)(nil).Class())
	sc_CmdRemapped.Metadata = append(sc_CmdRemapped.Metadata, &atom.Metadata{
		API:              apiID,
		DisplayName:      "cmdRemapped",
		Flags:            0,
		DocumentationUrl: "[]",
	})
}