text: # automatically generated by the FlatBuffers compiler, do not modify
  
  # namespace: Example
  
  import flatbuffers
  from flatbuffers.compat import import_numpy
  np = import_numpy()
  
  # Composite components of Monster color.
  class Color(object):
      Red = 1
      # \brief color Green
      # Green is bit_flag with value (1u << 1)
      Green = 2
      # \brief color Blue (1u << 3)
      Blue = 8
  
  
  class Race(object):
      None_ = -1
      Human = 0
      Dwarf = 1
      Elf = 2
  
  
  class Any(object):
      NONE = 0
      Monster = 1
      TestSimpleTableWithEnum = 2
      MyGame_Example2_Monster = 3
  
  def AnyCreator(unionType, table):
      from flatbuffers.table import Table
      if not isinstance(table, Table):
          return None
      if unionType == Any().Monster:
          return MonsterT.InitFromBuf(table.Bytes, table.Pos)
      if unionType == Any().TestSimpleTableWithEnum:
          return TestSimpleTableWithEnumT.InitFromBuf(table.Bytes, table.Pos)
      if unionType == Any().MyGame_Example2_Monster:
          return MonsterT.InitFromBuf(table.Bytes, table.Pos)
      return None
  
  
  class AnyUniqueAliases(object):
      NONE = 0
      M = 1
      TS = 2
      M2 = 3
  
  def AnyUniqueAliasesCreator(unionType, table):
      from flatbuffers.table import Table
      if not isinstance(table, Table):
          return None
      if unionType == AnyUniqueAliases().M:
          return MonsterT.InitFromBuf(table.Bytes, table.Pos)
      if unionType == AnyUniqueAliases().TS:
          return TestSimpleTableWithEnumT.InitFromBuf(table.Bytes, table.Pos)
      if unionType == AnyUniqueAliases().M2:
          return MonsterT.InitFromBuf(table.Bytes, table.Pos)
      return None
  
  
  class AnyAmbiguousAliases(object):
      NONE = 0
      M1 = 1
      M2 = 2
      M3 = 3
  
  def AnyAmbiguousAliasesCreator(unionType, table):
      from flatbuffers.table import Table
      if not isinstance(table, Table):
          return None
      if unionType == AnyAmbiguousAliases().M1:
          return MonsterT.InitFromBuf(table.Bytes, table.Pos)
      if unionType == AnyAmbiguousAliases().M2:
          return MonsterT.InitFromBuf(table.Bytes, table.Pos)
      if unionType == AnyAmbiguousAliases().M3:
          return MonsterT.InitFromBuf(table.Bytes, table.Pos)
      return None
  
  
  class InParentNamespace(object):
      __slots__ = ['_tab']
  
      @classmethod
      def GetRootAs(cls, buf, offset=0):
          n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
          x = InParentNamespace()
          x.Init(buf, n + offset)
          return x
  
      @classmethod
      def GetRootAsInParentNamespace(cls, buf, offset=0):
          """This method is deprecated. Please switch to GetRootAs."""
          return cls.GetRootAs(buf, offset)
      @classmethod
      def InParentNamespaceBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
          return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x4F\x4E\x53", size_prefixed=size_prefixed)
  
      # InParentNamespace
      def Init(self, buf, pos):
          self._tab = flatbuffers.table.Table(buf, pos)
  
  def InParentNamespaceStart(builder): builder.StartObject(0)
  def InParentNamespaceEnd(builder): return builder.EndObject()
  
  
  class InParentNamespaceT(object):
  
      # InParentNamespaceT
      def __init__(self):
          pass
  
      @classmethod
      def InitFromBuf(cls, buf, pos):
          inParentNamespace = InParentNamespace()
          inParentNamespace.Init(buf, pos)
          return cls.InitFromObj(inParentNamespace)
  
      @classmethod
      def InitFromObj(cls, inParentNamespace):
          x = InParentNamespaceT()
          x._UnPack(inParentNamespace)
          return x
  
      # InParentNamespaceT
      def _UnPack(self, inParentNamespace):
          if inParentNamespace is None:
              return
  
      # InParentNamespaceT
      def Pack(self, builder):
          InParentNamespaceStart(builder)
          inParentNamespace = InParentNamespaceEnd(builder)
          return inParentNamespace
  
  
  class Monster(object):
      __slots__ = ['_tab']
  
      @classmethod
      def GetRootAs(cls, buf, offset=0):
          n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
          x = Monster()
          x.Init(buf, n + offset)
          return x
  
      @classmethod
      def GetRootAsMonster(cls, buf, offset=0):
          """This method is deprecated. Please switch to GetRootAs."""
          return cls.GetRootAs(buf, offset)
      @classmethod
      def MonsterBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
          return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x4F\x4E\x53", size_prefixed=size_prefixed)
  
      # Monster
      def Init(self, buf, pos):
          self._tab = flatbuffers.table.Table(buf, pos)
  
  def MonsterStart(builder): builder.StartObject(0)
  def MonsterEnd(builder): return builder.EndObject()
  
  
  class MonsterT(object):
  
      # MonsterT
      def __init__(self):
          pass
  
      @classmethod
      def InitFromBuf(cls, buf, pos):
          monster = Monster()
          monster.Init(buf, pos)
          return cls.InitFromObj(monster)
  
      @classmethod
      def InitFromObj(cls, monster):
          x = MonsterT()
          x._UnPack(monster)
          return x
  
      # MonsterT
      def _UnPack(self, monster):
          if monster is None:
              return
  
      # MonsterT
      def Pack(self, builder):
          MonsterStart(builder)
          monster = MonsterEnd(builder)
          return monster
  
  
  class Test(object):
      __slots__ = ['_tab']
  
      @classmethod
      def SizeOf(cls):
          return 4
  
      # Test
      def Init(self, buf, pos):
          self._tab = flatbuffers.table.Table(buf, pos)
  
      # Test
      def A(self): return self._tab.Get(flatbuffers.number_types.Int16Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(0))
      # Test
      def B(self): return self._tab.Get(flatbuffers.number_types.Int8Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(2))
  
  def CreateTest(builder, a, b):
      builder.Prep(2, 4)
      builder.Pad(1)
      builder.PrependInt8(b)
      builder.PrependInt16(a)
      return builder.Offset()
  
  
  class TestT(object):
  
      # TestT
      def __init__(self):
          self.a = 0  # type: int
          self.b = 0  # type: int
  
      @classmethod
      def InitFromBuf(cls, buf, pos):
          test = Test()
          test.Init(buf, pos)
          return cls.InitFromObj(test)
  
      @classmethod
      def InitFromObj(cls, test):
          x = TestT()
          x._UnPack(test)
          return x
  
      # TestT
      def _UnPack(self, test):
          if test is None:
              return
          self.a = test.A()
          self.b = test.B()
  
      # TestT
      def Pack(self, builder):
          return CreateTest(builder, self.a, self.b)
  
  
  class TestSimpleTableWithEnum(object):
      __slots__ = ['_tab']
  
      @classmethod
      def GetRootAs(cls, buf, offset=0):
          n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
          x = TestSimpleTableWithEnum()
          x.Init(buf, n + offset)
          return x
  
      @classmethod
      def GetRootAsTestSimpleTableWithEnum(cls, buf, offset=0):
          """This method is deprecated. Please switch to GetRootAs."""
          return cls.GetRootAs(buf, offset)
      @classmethod
      def TestSimpleTableWithEnumBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
          return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x4F\x4E\x53", size_prefixed=size_prefixed)
  
      # TestSimpleTableWithEnum
      def Init(self, buf, pos):
          self._tab = flatbuffers.table.Table(buf, pos)
  
      # TestSimpleTableWithEnum
      def Color(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
          if o != 0:
              return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
          return 2
  
  def TestSimpleTableWithEnumStart(builder): builder.StartObject(1)
  def TestSimpleTableWithEnumAddColor(builder, color): builder.PrependUint8Slot(0, color, 2)
  def TestSimpleTableWithEnumEnd(builder): return builder.EndObject()
  
  
  class TestSimpleTableWithEnumT(object):
  
      # TestSimpleTableWithEnumT
      def __init__(self):
          self.color = 2  # type: int
  
      @classmethod
      def InitFromBuf(cls, buf, pos):
          testSimpleTableWithEnum = TestSimpleTableWithEnum()
          testSimpleTableWithEnum.Init(buf, pos)
          return cls.InitFromObj(testSimpleTableWithEnum)
  
      @classmethod
      def InitFromObj(cls, testSimpleTableWithEnum):
          x = TestSimpleTableWithEnumT()
          x._UnPack(testSimpleTableWithEnum)
          return x
  
      # TestSimpleTableWithEnumT
      def _UnPack(self, testSimpleTableWithEnum):
          if testSimpleTableWithEnum is None:
              return
          self.color = testSimpleTableWithEnum.Color()
  
      # TestSimpleTableWithEnumT
      def Pack(self, builder):
          TestSimpleTableWithEnumStart(builder)
          TestSimpleTableWithEnumAddColor(builder, self.color)
          testSimpleTableWithEnum = TestSimpleTableWithEnumEnd(builder)
          return testSimpleTableWithEnum
  
  
  class Vec3(object):
      __slots__ = ['_tab']
  
      @classmethod
      def SizeOf(cls):
          return 32
  
      # Vec3
      def Init(self, buf, pos):
          self._tab = flatbuffers.table.Table(buf, pos)
  
      # Vec3
      def X(self): return self._tab.Get(flatbuffers.number_types.Float32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(0))
      # Vec3
      def Y(self): return self._tab.Get(flatbuffers.number_types.Float32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(4))
      # Vec3
      def Z(self): return self._tab.Get(flatbuffers.number_types.Float32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(8))
      # Vec3
      def Test1(self): return self._tab.Get(flatbuffers.number_types.Float64Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(16))
      # Vec3
      def Test2(self): return self._tab.Get(flatbuffers.number_types.Uint8Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(24))
      # Vec3
      def Test3(self, obj):
          obj.Init(self._tab.Bytes, self._tab.Pos + 26)
          return obj
  
  
  def CreateVec3(builder, x, y, z, test1, test2, test3_a, test3_b):
      builder.Prep(8, 32)
      builder.Pad(2)
      builder.Prep(2, 4)
      builder.Pad(1)
      builder.PrependInt8(test3_b)
      builder.PrependInt16(test3_a)
      builder.Pad(1)
      builder.PrependUint8(test2)
      builder.PrependFloat64(test1)
      builder.Pad(4)
      builder.PrependFloat32(z)
      builder.PrependFloat32(y)
      builder.PrependFloat32(x)
      return builder.Offset()
  
  try:
      from typing import Optional
  except:
      pass
  
  class Vec3T(object):
  
      # Vec3T
      def __init__(self):
          self.x = 0.0  # type: float
          self.y = 0.0  # type: float
          self.z = 0.0  # type: float
          self.test1 = 0.0  # type: float
          self.test2 = 0  # type: int
          self.test3 = None  # type: Optional[TestT]
  
      @classmethod
      def InitFromBuf(cls, buf, pos):
          vec3 = Vec3()
          vec3.Init(buf, pos)
          return cls.InitFromObj(vec3)
  
      @classmethod
      def InitFromObj(cls, vec3):
          x = Vec3T()
          x._UnPack(vec3)
          return x
  
      # Vec3T
      def _UnPack(self, vec3):
          if vec3 is None:
              return
          self.x = vec3.X()
          self.y = vec3.Y()
          self.z = vec3.Z()
          self.test1 = vec3.Test1()
          self.test2 = vec3.Test2()
          if vec3.Test3(Test()) is not None:
              self.test3 = TestT.InitFromObj(vec3.Test3(Test()))
  
      # Vec3T
      def Pack(self, builder):
          return CreateVec3(builder, self.x, self.y, self.z, self.test1, self.test2, self.test3.a, self.test3.b)
  
  
  class Ability(object):
      __slots__ = ['_tab']
  
      @classmethod
      def SizeOf(cls):
          return 8
  
      # Ability
      def Init(self, buf, pos):
          self._tab = flatbuffers.table.Table(buf, pos)
  
      # Ability
      def Id(self): return self._tab.Get(flatbuffers.number_types.Uint32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(0))
      # Ability
      def Distance(self): return self._tab.Get(flatbuffers.number_types.Uint32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(4))
  
  def CreateAbility(builder, id, distance):
      builder.Prep(4, 8)
      builder.PrependUint32(distance)
      builder.PrependUint32(id)
      return builder.Offset()
  
  
  class AbilityT(object):
  
      # AbilityT
      def __init__(self):
          self.id = 0  # type: int
          self.distance = 0  # type: int
  
      @classmethod
      def InitFromBuf(cls, buf, pos):
          ability = Ability()
          ability.Init(buf, pos)
          return cls.InitFromObj(ability)
  
      @classmethod
      def InitFromObj(cls, ability):
          x = AbilityT()
          x._UnPack(ability)
          return x
  
      # AbilityT
      def _UnPack(self, ability):
          if ability is None:
              return
          self.id = ability.Id()
          self.distance = ability.Distance()
  
      # AbilityT
      def Pack(self, builder):
          return CreateAbility(builder, self.id, self.distance)
  
  
  class StructOfStructs(object):
      __slots__ = ['_tab']
  
      @classmethod
      def SizeOf(cls):
          return 20
  
      # StructOfStructs
      def Init(self, buf, pos):
          self._tab = flatbuffers.table.Table(buf, pos)
  
      # StructOfStructs
      def A(self, obj):
          obj.Init(self._tab.Bytes, self._tab.Pos + 0)
          return obj
  
      # StructOfStructs
      def B(self, obj):
          obj.Init(self._tab.Bytes, self._tab.Pos + 8)
          return obj
  
      # StructOfStructs
      def C(self, obj):
          obj.Init(self._tab.Bytes, self._tab.Pos + 12)
          return obj
  
  
  def CreateStructOfStructs(builder, a_id, a_distance, b_a, b_b, c_id, c_distance):
      builder.Prep(4, 20)
      builder.Prep(4, 8)
      builder.PrependUint32(c_distance)
      builder.PrependUint32(c_id)
      builder.Prep(2, 4)
      builder.Pad(1)
      builder.PrependInt8(b_b)
      builder.PrependInt16(b_a)
      builder.Prep(4, 8)
      builder.PrependUint32(a_distance)
      builder.PrependUint32(a_id)
      return builder.Offset()
  
  try:
      from typing import Optional
  except:
      pass
  
  class StructOfStructsT(object):
  
      # StructOfStructsT
      def __init__(self):
          self.a = None  # type: Optional[AbilityT]
          self.b = None  # type: Optional[TestT]
          self.c = None  # type: Optional[AbilityT]
  
      @classmethod
      def InitFromBuf(cls, buf, pos):
          structOfStructs = StructOfStructs()
          structOfStructs.Init(buf, pos)
          return cls.InitFromObj(structOfStructs)
  
      @classmethod
      def InitFromObj(cls, structOfStructs):
          x = StructOfStructsT()
          x._UnPack(structOfStructs)
          return x
  
      # StructOfStructsT
      def _UnPack(self, structOfStructs):
          if structOfStructs is None:
              return
          if structOfStructs.A(Ability()) is not None:
              self.a = AbilityT.InitFromObj(structOfStructs.A(Ability()))
          if structOfStructs.B(Test()) is not None:
              self.b = TestT.InitFromObj(structOfStructs.B(Test()))
          if structOfStructs.C(Ability()) is not None:
              self.c = AbilityT.InitFromObj(structOfStructs.C(Ability()))
  
      # StructOfStructsT
      def Pack(self, builder):
          return CreateStructOfStructs(builder, self.a.id, self.a.distance, self.b.a, self.b.b, self.c.id, self.c.distance)
  
  
  class Stat(object):
      __slots__ = ['_tab']
  
      @classmethod
      def GetRootAs(cls, buf, offset=0):
          n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
          x = Stat()
          x.Init(buf, n + offset)
          return x
  
      @classmethod
      def GetRootAsStat(cls, buf, offset=0):
          """This method is deprecated. Please switch to GetRootAs."""
          return cls.GetRootAs(buf, offset)
      @classmethod
      def StatBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
          return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x4F\x4E\x53", size_prefixed=size_prefixed)
  
      # Stat
      def Init(self, buf, pos):
          self._tab = flatbuffers.table.Table(buf, pos)
  
      # Stat
      def Id(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
          if o != 0:
              return self._tab.String(o + self._tab.Pos)
          return None
  
      # Stat
      def Val(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
          if o != 0:
              return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
          return 0
  
      # Stat
      def Count(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
          if o != 0:
              return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
          return 0
  
  def StatStart(builder): builder.StartObject(3)
  def StatAddId(builder, id): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(id), 0)
  def StatAddVal(builder, val): builder.PrependInt64Slot(1, val, 0)
  def StatAddCount(builder, count): builder.PrependUint16Slot(2, count, 0)
  def StatEnd(builder): return builder.EndObject()
  
  
  class StatT(object):
  
      # StatT
      def __init__(self):
          self.id = None  # type: str
          self.val = 0  # type: int
          self.count = 0  # type: int
  
      @classmethod
      def InitFromBuf(cls, buf, pos):
          stat = Stat()
          stat.Init(buf, pos)
          return cls.InitFromObj(stat)
  
      @classmethod
      def InitFromObj(cls, stat):
          x = StatT()
          x._UnPack(stat)
          return x
  
      # StatT
      def _UnPack(self, stat):
          if stat is None:
              return
          self.id = stat.Id()
          self.val = stat.Val()
          self.count = stat.Count()
  
      # StatT
      def Pack(self, builder):
          if self.id is not None:
              id = builder.CreateString(self.id)
          StatStart(builder)
          if self.id is not None:
              StatAddId(builder, id)
          StatAddVal(builder, self.val)
          StatAddCount(builder, self.count)
          stat = StatEnd(builder)
          return stat
  
  
  class Referrable(object):
      __slots__ = ['_tab']
  
      @classmethod
      def GetRootAs(cls, buf, offset=0):
          n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
          x = Referrable()
          x.Init(buf, n + offset)
          return x
  
      @classmethod
      def GetRootAsReferrable(cls, buf, offset=0):
          """This method is deprecated. Please switch to GetRootAs."""
          return cls.GetRootAs(buf, offset)
      @classmethod
      def ReferrableBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
          return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x4F\x4E\x53", size_prefixed=size_prefixed)
  
      # Referrable
      def Init(self, buf, pos):
          self._tab = flatbuffers.table.Table(buf, pos)
  
      # Referrable
      def Id(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
          if o != 0:
              return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
          return 0
  
  def ReferrableStart(builder): builder.StartObject(1)
  def ReferrableAddId(builder, id): builder.PrependUint64Slot(0, id, 0)
  def ReferrableEnd(builder): return builder.EndObject()
  
  
  class ReferrableT(object):
  
      # ReferrableT
      def __init__(self):
          self.id = 0  # type: int
  
      @classmethod
      def InitFromBuf(cls, buf, pos):
          referrable = Referrable()
          referrable.Init(buf, pos)
          return cls.InitFromObj(referrable)
  
      @classmethod
      def InitFromObj(cls, referrable):
          x = ReferrableT()
          x._UnPack(referrable)
          return x
  
      # ReferrableT
      def _UnPack(self, referrable):
          if referrable is None:
              return
          self.id = referrable.Id()
  
      # ReferrableT
      def Pack(self, builder):
          ReferrableStart(builder)
          ReferrableAddId(builder, self.id)
          referrable = ReferrableEnd(builder)
          return referrable
  
  
  # an example documentation comment: "monster object"
  class Monster(object):
      __slots__ = ['_tab']
  
      @classmethod
      def GetRootAs(cls, buf, offset=0):
          n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
          x = Monster()
          x.Init(buf, n + offset)
          return x
  
      @classmethod
      def GetRootAsMonster(cls, buf, offset=0):
          """This method is deprecated. Please switch to GetRootAs."""
          return cls.GetRootAs(buf, offset)
      @classmethod
      def MonsterBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
          return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x4F\x4E\x53", size_prefixed=size_prefixed)
  
      # Monster
      def Init(self, buf, pos):
          self._tab = flatbuffers.table.Table(buf, pos)
  
      # Monster
      def Pos(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
          if o != 0:
              x = o + self._tab.Pos
              obj = Vec3()
              obj.Init(self._tab.Bytes, x)
              return obj
          return None
  
      # Monster
      def Mana(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
          if o != 0:
              return self._tab.Get(flatbuffers.number_types.Int16Flags, o + self._tab.Pos)
          return 150
  
      # Monster
      def Hp(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
          if o != 0:
              return self._tab.Get(flatbuffers.number_types.Int16Flags, o + self._tab.Pos)
          return 100
  
      # Monster
      def Name(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
          if o != 0:
              return self._tab.String(o + self._tab.Pos)
          return None
  
      # Monster
      def Inventory(self, j):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
          if o != 0:
              a = self._tab.Vector(o)
              return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
          return 0
  
      # Monster
      def InventoryAsNumpy(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
          if o != 0:
              return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
          return 0
  
      # Monster
      def InventoryLength(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
          if o != 0:
              return self._tab.VectorLen(o)
          return 0
  
      # Monster
      def InventoryIsNone(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
          return o == 0
  
      # Monster
      def Color(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
          if o != 0:
              return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
          return 8
  
      # Monster
      def TestType(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
          if o != 0:
              return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
          return 0
  
      # Monster
      def Test(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
          if o != 0:
              from flatbuffers.table import Table
              obj = Table(bytearray(), 0)
              self._tab.Union(obj, o)
              return obj
          return None
  
      # Monster
      def Test4(self, j):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
          if o != 0:
              x = self._tab.Vector(o)
              x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
              obj = Test()
              obj.Init(self._tab.Bytes, x)
              return obj
          return None
  
      # Monster
      def Test4Length(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
          if o != 0:
              return self._tab.VectorLen(o)
          return 0
  
      # Monster
      def Test4IsNone(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
          return o == 0
  
      # Monster
      def Testarrayofstring(self, j):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
          if o != 0:
              a = self._tab.Vector(o)
              return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
          return ""
  
      # Monster
      def TestarrayofstringLength(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
          if o != 0:
              return self._tab.VectorLen(o)
          return 0
  
      # Monster
      def TestarrayofstringIsNone(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
          return o == 0
  
      # an example documentation comment: this will end up in the generated code
      # multiline too
      # Monster
      def Testarrayoftables(self, j):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
          if o != 0:
              x = self._tab.Vector(o)
              x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
              x = self._tab.Indirect(x)
              obj = Monster()
              obj.Init(self._tab.Bytes, x)
              return obj
          return None
  
      # Monster
      def TestarrayoftablesLength(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
          if o != 0:
              return self._tab.VectorLen(o)
          return 0
  
      # Monster
      def TestarrayoftablesIsNone(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
          return o == 0
  
      # Monster
      def Enemy(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
          if o != 0:
              x = self._tab.Indirect(o + self._tab.Pos)
              obj = Monster()
              obj.Init(self._tab.Bytes, x)
              return obj
          return None
  
      # Monster
      def Testnestedflatbuffer(self, j):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
          if o != 0:
              a = self._tab.Vector(o)
              return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
          return 0
  
      # Monster
      def TestnestedflatbufferAsNumpy(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
          if o != 0:
              return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
          return 0
  
      # Monster
      def TestnestedflatbufferNestedRoot(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
          if o != 0:
              from MyGame.Example.Monster import Monster
              return Monster.GetRootAsMonster(self._tab.Bytes, self._tab.Vector(o))
          return 0
  
      # Monster
      def TestnestedflatbufferLength(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
          if o != 0:
              return self._tab.VectorLen(o)
          return 0
  
      # Monster
      def TestnestedflatbufferIsNone(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
          return o == 0
  
      # Monster
      def Testempty(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
          if o != 0:
              x = self._tab.Indirect(o + self._tab.Pos)
              obj = Stat()
              obj.Init(self._tab.Bytes, x)
              return obj
          return None
  
      # Monster
      def Testbool(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
          if o != 0:
              return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
          return False
  
      # Monster
      def Testhashs32Fnv1(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
          if o != 0:
              return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
          return 0
  
      # Monster
      def Testhashu32Fnv1(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(38))
          if o != 0:
              return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
          return 0
  
      # Monster
      def Testhashs64Fnv1(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(40))
          if o != 0:
              return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
          return 0
  
      # Monster
      def Testhashu64Fnv1(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
          if o != 0:
              return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
          return 0
  
      # Monster
      def Testhashs32Fnv1a(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(44))
          if o != 0:
              return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
          return 0
  
      # Monster
      def Testhashu32Fnv1a(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(46))
          if o != 0:
              return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
          return 0
  
      # Monster
      def Testhashs64Fnv1a(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(48))
          if o != 0:
              return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
          return 0
  
      # Monster
      def Testhashu64Fnv1a(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(50))
          if o != 0:
              return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
          return 0
  
      # Monster
      def Testarrayofbools(self, j):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
          if o != 0:
              a = self._tab.Vector(o)
              return self._tab.Get(flatbuffers.number_types.BoolFlags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
          return 0
  
      # Monster
      def TestarrayofboolsAsNumpy(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
          if o != 0:
              return self._tab.GetVectorAsNumpy(flatbuffers.number_types.BoolFlags, o)
          return 0
  
      # Monster
      def TestarrayofboolsLength(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
          if o != 0:
              return self._tab.VectorLen(o)
          return 0
  
      # Monster
      def TestarrayofboolsIsNone(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
          return o == 0
  
      # Monster
      def Testf(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(54))
          if o != 0:
              return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
          return 3.14159
  
      # Monster
      def Testf2(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(56))
          if o != 0:
              return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
          return 3.0
  
      # Monster
      def Testf3(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(58))
          if o != 0:
              return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
          return 0.0
  
      # Monster
      def Testarrayofstring2(self, j):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
          if o != 0:
              a = self._tab.Vector(o)
              return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
          return ""
  
      # Monster
      def Testarrayofstring2Length(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
          if o != 0:
              return self._tab.VectorLen(o)
          return 0
  
      # Monster
      def Testarrayofstring2IsNone(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
          return o == 0
  
      # Monster
      def Testarrayofsortedstruct(self, j):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
          if o != 0:
              x = self._tab.Vector(o)
              x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 8
              obj = Ability()
              obj.Init(self._tab.Bytes, x)
              return obj
          return None
  
      # Monster
      def TestarrayofsortedstructLength(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
          if o != 0:
              return self._tab.VectorLen(o)
          return 0
  
      # Monster
      def TestarrayofsortedstructIsNone(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
          return o == 0
  
      # Monster
      def Flex(self, j):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
          if o != 0:
              a = self._tab.Vector(o)
              return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
          return 0
  
      # Monster
      def FlexAsNumpy(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
          if o != 0:
              return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
          return 0
  
      # Monster
      def FlexLength(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
          if o != 0:
              return self._tab.VectorLen(o)
          return 0
  
      # Monster
      def FlexIsNone(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
          return o == 0
  
      # Monster
      def Test5(self, j):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
          if o != 0:
              x = self._tab.Vector(o)
              x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
              obj = Test()
              obj.Init(self._tab.Bytes, x)
              return obj
          return None
  
      # Monster
      def Test5Length(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
          if o != 0:
              return self._tab.VectorLen(o)
          return 0
  
      # Monster
      def Test5IsNone(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
          return o == 0
  
      # Monster
      def VectorOfLongs(self, j):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
          if o != 0:
              a = self._tab.Vector(o)
              return self._tab.Get(flatbuffers.number_types.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
          return 0
  
      # Monster
      def VectorOfLongsAsNumpy(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
          if o != 0:
              return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
          return 0
  
      # Monster
      def VectorOfLongsLength(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
          if o != 0:
              return self._tab.VectorLen(o)
          return 0
  
      # Monster
      def VectorOfLongsIsNone(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
          return o == 0
  
      # Monster
      def VectorOfDoubles(self, j):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
          if o != 0:
              a = self._tab.Vector(o)
              return self._tab.Get(flatbuffers.number_types.Float64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
          return 0
  
      # Monster
      def VectorOfDoublesAsNumpy(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
          if o != 0:
              return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float64Flags, o)
          return 0
  
      # Monster
      def VectorOfDoublesLength(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
          if o != 0:
              return self._tab.VectorLen(o)
          return 0
  
      # Monster
      def VectorOfDoublesIsNone(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
          return o == 0
  
      # Monster
      def ParentNamespaceTest(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(72))
          if o != 0:
              x = self._tab.Indirect(o + self._tab.Pos)
              obj = InParentNamespace()
              obj.Init(self._tab.Bytes, x)
              return obj
          return None
  
      # Monster
      def VectorOfReferrables(self, j):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(74))
          if o != 0:
              x = self._tab.Vector(o)
              x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
              x = self._tab.Indirect(x)
              obj = Referrable()
              obj.Init(self._tab.Bytes, x)
              return obj
          return None
  
      # Monster
      def VectorOfReferrablesLength(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(74))
          if o != 0:
              return self._tab.VectorLen(o)
          return 0
  
      # Monster
      def VectorOfReferrablesIsNone(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(74))
          return o == 0
  
      # Monster
      def SingleWeakReference(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(76))
          if o != 0:
              return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
          return 0
  
      # Monster
      def VectorOfWeakReferences(self, j):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
          if o != 0:
              a = self._tab.Vector(o)
              return self._tab.Get(flatbuffers.number_types.Uint64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
          return 0
  
      # Monster
      def VectorOfWeakReferencesAsNumpy(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
          if o != 0:
              return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
          return 0
  
      # Monster
      def VectorOfWeakReferencesLength(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
          if o != 0:
              return self._tab.VectorLen(o)
          return 0
  
      # Monster
      def VectorOfWeakReferencesIsNone(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
          return o == 0
  
      # Monster
      def VectorOfStrongReferrables(self, j):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(80))
          if o != 0:
              x = self._tab.Vector(o)
              x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
              x = self._tab.Indirect(x)
              obj = Referrable()
              obj.Init(self._tab.Bytes, x)
              return obj
          return None
  
      # Monster
      def VectorOfStrongReferrablesLength(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(80))
          if o != 0:
              return self._tab.VectorLen(o)
          return 0
  
      # Monster
      def VectorOfStrongReferrablesIsNone(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(80))
          return o == 0
  
      # Monster
      def CoOwningReference(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(82))
          if o != 0:
              return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
          return 0
  
      # Monster
      def VectorOfCoOwningReferences(self, j):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
          if o != 0:
              a = self._tab.Vector(o)
              return self._tab.Get(flatbuffers.number_types.Uint64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
          return 0
  
      # Monster
      def VectorOfCoOwningReferencesAsNumpy(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
          if o != 0:
              return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
          return 0
  
      # Monster
      def VectorOfCoOwningReferencesLength(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
          if o != 0:
              return self._tab.VectorLen(o)
          return 0
  
      # Monster
      def VectorOfCoOwningReferencesIsNone(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
          return o == 0
  
      # Monster
      def NonOwningReference(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(86))
          if o != 0:
              return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
          return 0
  
      # Monster
      def VectorOfNonOwningReferences(self, j):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
          if o != 0:
              a = self._tab.Vector(o)
              return self._tab.Get(flatbuffers.number_types.Uint64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
          return 0
  
      # Monster
      def VectorOfNonOwningReferencesAsNumpy(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
          if o != 0:
              return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint64Flags, o)
          return 0
  
      # Monster
      def VectorOfNonOwningReferencesLength(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
          if o != 0:
              return self._tab.VectorLen(o)
          return 0
  
      # Monster
      def VectorOfNonOwningReferencesIsNone(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
          return o == 0
  
      # Monster
      def AnyUniqueType(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(90))
          if o != 0:
              return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
          return 0
  
      # Monster
      def AnyUnique(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(92))
          if o != 0:
              from flatbuffers.table import Table
              obj = Table(bytearray(), 0)
              self._tab.Union(obj, o)
              return obj
          return None
  
      # Monster
      def AnyAmbiguousType(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(94))
          if o != 0:
              return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
          return 0
  
      # Monster
      def AnyAmbiguous(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(96))
          if o != 0:
              from flatbuffers.table import Table
              obj = Table(bytearray(), 0)
              self._tab.Union(obj, o)
              return obj
          return None
  
      # Monster
      def VectorOfEnums(self, j):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
          if o != 0:
              a = self._tab.Vector(o)
              return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
          return 0
  
      # Monster
      def VectorOfEnumsAsNumpy(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
          if o != 0:
              return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
          return 0
  
      # Monster
      def VectorOfEnumsLength(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
          if o != 0:
              return self._tab.VectorLen(o)
          return 0
  
      # Monster
      def VectorOfEnumsIsNone(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
          return o == 0
  
      # Monster
      def SignedEnum(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(100))
          if o != 0:
              return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
          return -1
  
      # Monster
      def Testrequirednestedflatbuffer(self, j):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
          if o != 0:
              a = self._tab.Vector(o)
              return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
          return 0
  
      # Monster
      def TestrequirednestedflatbufferAsNumpy(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
          if o != 0:
              return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
          return 0
  
      # Monster
      def TestrequirednestedflatbufferNestedRoot(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
          if o != 0:
              from MyGame.Example.Monster import Monster
              return Monster.GetRootAsMonster(self._tab.Bytes, self._tab.Vector(o))
          return 0
  
      # Monster
      def TestrequirednestedflatbufferLength(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
          if o != 0:
              return self._tab.VectorLen(o)
          return 0
  
      # Monster
      def TestrequirednestedflatbufferIsNone(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
          return o == 0
  
      # Monster
      def ScalarKeySortedTables(self, j):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(104))
          if o != 0:
              x = self._tab.Vector(o)
              x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
              x = self._tab.Indirect(x)
              obj = Stat()
              obj.Init(self._tab.Bytes, x)
              return obj
          return None
  
      # Monster
      def ScalarKeySortedTablesLength(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(104))
          if o != 0:
              return self._tab.VectorLen(o)
          return 0
  
      # Monster
      def ScalarKeySortedTablesIsNone(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(104))
          return o == 0
  
  def MonsterStart(builder): builder.StartObject(51)
  def MonsterAddPos(builder, pos): builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pos), 0)
  def MonsterAddMana(builder, mana): builder.PrependInt16Slot(1, mana, 150)
  def MonsterAddHp(builder, hp): builder.PrependInt16Slot(2, hp, 100)
  def MonsterAddName(builder, name): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
  def MonsterAddInventory(builder, inventory): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(inventory), 0)
  def MonsterStartInventoryVector(builder, numElems): return builder.StartVector(1, numElems, 1)
  def MonsterAddColor(builder, color): builder.PrependUint8Slot(6, color, 8)
  def MonsterAddTestType(builder, testType): builder.PrependUint8Slot(7, testType, 0)
  def MonsterAddTest(builder, test): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(test), 0)
  def MonsterAddTest4(builder, test4): builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(test4), 0)
  def MonsterStartTest4Vector(builder, numElems): return builder.StartVector(4, numElems, 2)
  def MonsterAddTestarrayofstring(builder, testarrayofstring): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring), 0)
  def MonsterStartTestarrayofstringVector(builder, numElems): return builder.StartVector(4, numElems, 4)
  def MonsterAddTestarrayoftables(builder, testarrayoftables): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayoftables), 0)
  def MonsterStartTestarrayoftablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
  def MonsterAddEnemy(builder, enemy): builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(enemy), 0)
  def MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer): builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(testnestedflatbuffer), 0)
  def MonsterStartTestnestedflatbufferVector(builder, numElems): return builder.StartVector(1, numElems, 1)
  def MonsterMakeTestnestedflatbufferVectorFromBytes(builder, bytes):
      builder.StartVector(1, len(bytes), 1)
      builder.head = builder.head - len(bytes)
      builder.Bytes[builder.head : builder.head + len(bytes)] = bytes
      return builder.EndVector()
  def MonsterAddTestempty(builder, testempty): builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(testempty), 0)
  def MonsterAddTestbool(builder, testbool): builder.PrependBoolSlot(15, testbool, 0)
  def MonsterAddTesthashs32Fnv1(builder, testhashs32Fnv1): builder.PrependInt32Slot(16, testhashs32Fnv1, 0)
  def MonsterAddTesthashu32Fnv1(builder, testhashu32Fnv1): builder.PrependUint32Slot(17, testhashu32Fnv1, 0)
  def MonsterAddTesthashs64Fnv1(builder, testhashs64Fnv1): builder.PrependInt64Slot(18, testhashs64Fnv1, 0)
  def MonsterAddTesthashu64Fnv1(builder, testhashu64Fnv1): builder.PrependUint64Slot(19, testhashu64Fnv1, 0)
  def MonsterAddTesthashs32Fnv1a(builder, testhashs32Fnv1a): builder.PrependInt32Slot(20, testhashs32Fnv1a, 0)
  def MonsterAddTesthashu32Fnv1a(builder, testhashu32Fnv1a): builder.PrependUint32Slot(21, testhashu32Fnv1a, 0)
  def MonsterAddTesthashs64Fnv1a(builder, testhashs64Fnv1a): builder.PrependInt64Slot(22, testhashs64Fnv1a, 0)
  def MonsterAddTesthashu64Fnv1a(builder, testhashu64Fnv1a): builder.PrependUint64Slot(23, testhashu64Fnv1a, 0)
  def MonsterAddTestarrayofbools(builder, testarrayofbools): builder.PrependUOffsetTRelativeSlot(24, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofbools), 0)
  def MonsterStartTestarrayofboolsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
  def MonsterAddTestf(builder, testf): builder.PrependFloat32Slot(25, testf, 3.14159)
  def MonsterAddTestf2(builder, testf2): builder.PrependFloat32Slot(26, testf2, 3.0)
  def MonsterAddTestf3(builder, testf3): builder.PrependFloat32Slot(27, testf3, 0.0)
  def MonsterAddTestarrayofstring2(builder, testarrayofstring2): builder.PrependUOffsetTRelativeSlot(28, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring2), 0)
  def MonsterStartTestarrayofstring2Vector(builder, numElems): return builder.StartVector(4, numElems, 4)
  def MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct): builder.PrependUOffsetTRelativeSlot(29, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofsortedstruct), 0)
  def MonsterStartTestarrayofsortedstructVector(builder, numElems): return builder.StartVector(8, numElems, 4)
  def MonsterAddFlex(builder, flex): builder.PrependUOffsetTRelativeSlot(30, flatbuffers.number_types.UOffsetTFlags.py_type(flex), 0)
  def MonsterStartFlexVector(builder, numElems): return builder.StartVector(1, numElems, 1)
  def MonsterAddTest5(builder, test5): builder.PrependUOffsetTRelativeSlot(31, flatbuffers.number_types.UOffsetTFlags.py_type(test5), 0)
  def MonsterStartTest5Vector(builder, numElems): return builder.StartVector(4, numElems, 2)
  def MonsterAddVectorOfLongs(builder, vectorOfLongs): builder.PrependUOffsetTRelativeSlot(32, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfLongs), 0)
  def MonsterStartVectorOfLongsVector(builder, numElems): return builder.StartVector(8, numElems, 8)
  def MonsterAddVectorOfDoubles(builder, vectorOfDoubles): builder.PrependUOffsetTRelativeSlot(33, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfDoubles), 0)
  def MonsterStartVectorOfDoublesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
  def MonsterAddParentNamespaceTest(builder, parentNamespaceTest): builder.PrependUOffsetTRelativeSlot(34, flatbuffers.number_types.UOffsetTFlags.py_type(parentNamespaceTest), 0)
  def MonsterAddVectorOfReferrables(builder, vectorOfReferrables): builder.PrependUOffsetTRelativeSlot(35, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfReferrables), 0)
  def MonsterStartVectorOfReferrablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
  def MonsterAddSingleWeakReference(builder, singleWeakReference): builder.PrependUint64Slot(36, singleWeakReference, 0)
  def MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences): builder.PrependUOffsetTRelativeSlot(37, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfWeakReferences), 0)
  def MonsterStartVectorOfWeakReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
  def MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables): builder.PrependUOffsetTRelativeSlot(38, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfStrongReferrables), 0)
  def MonsterStartVectorOfStrongReferrablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
  def MonsterAddCoOwningReference(builder, coOwningReference): builder.PrependUint64Slot(39, coOwningReference, 0)
  def MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences): builder.PrependUOffsetTRelativeSlot(40, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfCoOwningReferences), 0)
  def MonsterStartVectorOfCoOwningReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
  def MonsterAddNonOwningReference(builder, nonOwningReference): builder.PrependUint64Slot(41, nonOwningReference, 0)
  def MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences): builder.PrependUOffsetTRelativeSlot(42, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfNonOwningReferences), 0)
  def MonsterStartVectorOfNonOwningReferencesVector(builder, numElems): return builder.StartVector(8, numElems, 8)
  def MonsterAddAnyUniqueType(builder, anyUniqueType): builder.PrependUint8Slot(43, anyUniqueType, 0)
  def MonsterAddAnyUnique(builder, anyUnique): builder.PrependUOffsetTRelativeSlot(44, flatbuffers.number_types.UOffsetTFlags.py_type(anyUnique), 0)
  def MonsterAddAnyAmbiguousType(builder, anyAmbiguousType): builder.PrependUint8Slot(45, anyAmbiguousType, 0)
  def MonsterAddAnyAmbiguous(builder, anyAmbiguous): builder.PrependUOffsetTRelativeSlot(46, flatbuffers.number_types.UOffsetTFlags.py_type(anyAmbiguous), 0)
  def MonsterAddVectorOfEnums(builder, vectorOfEnums): builder.PrependUOffsetTRelativeSlot(47, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfEnums), 0)
  def MonsterStartVectorOfEnumsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
  def MonsterAddSignedEnum(builder, signedEnum): builder.PrependInt8Slot(48, signedEnum, -1)
  def MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer): builder.PrependUOffsetTRelativeSlot(49, flatbuffers.number_types.UOffsetTFlags.py_type(testrequirednestedflatbuffer), 0)
  def MonsterStartTestrequirednestedflatbufferVector(builder, numElems): return builder.StartVector(1, numElems, 1)
  def MonsterMakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes):
      builder.StartVector(1, len(bytes), 1)
      builder.head = builder.head - len(bytes)
      builder.Bytes[builder.head : builder.head + len(bytes)] = bytes
      return builder.EndVector()
  def MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables): builder.PrependUOffsetTRelativeSlot(50, flatbuffers.number_types.UOffsetTFlags.py_type(scalarKeySortedTables), 0)
  def MonsterStartScalarKeySortedTablesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
  def MonsterEnd(builder): return builder.EndObject()
  
  try:
      from typing import List, Optional, Union
  except:
      pass
  
  class MonsterT(object):
  
      # MonsterT
      def __init__(self):
          self.pos = None  # type: Optional[Vec3T]
          self.mana = 150  # type: int
          self.hp = 100  # type: int
          self.name = None  # type: str
          self.inventory = None  # type: List[int]
          self.color = 8  # type: int
          self.testType = 0  # type: int
          self.test = None  # type: Union[None, MonsterT, TestSimpleTableWithEnumT, MonsterT]
          self.test4 = None  # type: List[TestT]
          self.testarrayofstring = None  # type: List[str]
          self.testarrayoftables = None  # type: List[MonsterT]
          self.enemy = None  # type: Optional[MonsterT]
          self.testnestedflatbuffer = None  # type: List[int]
          self.testempty = None  # type: Optional[StatT]
          self.testbool = False  # type: bool
          self.testhashs32Fnv1 = 0  # type: int
          self.testhashu32Fnv1 = 0  # type: int
          self.testhashs64Fnv1 = 0  # type: int
          self.testhashu64Fnv1 = 0  # type: int
          self.testhashs32Fnv1a = 0  # type: int
          self.testhashu32Fnv1a = 0  # type: int
          self.testhashs64Fnv1a = 0  # type: int
          self.testhashu64Fnv1a = 0  # type: int
          self.testarrayofbools = None  # type: List[bool]
          self.testf = 3.14159  # type: float
          self.testf2 = 3.0  # type: float
          self.testf3 = 0.0  # type: float
          self.testarrayofstring2 = None  # type: List[str]
          self.testarrayofsortedstruct = None  # type: List[AbilityT]
          self.flex = None  # type: List[int]
          self.test5 = None  # type: List[TestT]
          self.vectorOfLongs = None  # type: List[int]
          self.vectorOfDoubles = None  # type: List[float]
          self.parentNamespaceTest = None  # type: Optional[InParentNamespaceT]
          self.vectorOfReferrables = None  # type: List[ReferrableT]
          self.singleWeakReference = 0  # type: int
          self.vectorOfWeakReferences = None  # type: List[int]
          self.vectorOfStrongReferrables = None  # type: List[ReferrableT]
          self.coOwningReference = 0  # type: int
          self.vectorOfCoOwningReferences = None  # type: List[int]
          self.nonOwningReference = 0  # type: int
          self.vectorOfNonOwningReferences = None  # type: List[int]
          self.anyUniqueType = 0  # type: int
          self.anyUnique = None  # type: Union[None, MonsterT, TestSimpleTableWithEnumT, MonsterT]
          self.anyAmbiguousType = 0  # type: int
          self.anyAmbiguous = None  # type: Union[None, MonsterT, MonsterT, MonsterT]
          self.vectorOfEnums = None  # type: List[int]
          self.signedEnum = -1  # type: int
          self.testrequirednestedflatbuffer = None  # type: List[int]
          self.scalarKeySortedTables = None  # type: List[StatT]
  
      @classmethod
      def InitFromBuf(cls, buf, pos):
          monster = Monster()
          monster.Init(buf, pos)
          return cls.InitFromObj(monster)
  
      @classmethod
      def InitFromObj(cls, monster):
          x = MonsterT()
          x._UnPack(monster)
          return x
  
      # MonsterT
      def _UnPack(self, monster):
          if monster is None:
              return
          if monster.Pos() is not None:
              self.pos = Vec3T.InitFromObj(monster.Pos())
          self.mana = monster.Mana()
          self.hp = monster.Hp()
          self.name = monster.Name()
          if not monster.InventoryIsNone():
              if np is None:
                  self.inventory = []
                  for i in range(monster.InventoryLength()):
                      self.inventory.append(monster.Inventory(i))
              else:
                  self.inventory = monster.InventoryAsNumpy()
          self.color = monster.Color()
          self.testType = monster.TestType()
          self.test = AnyCreator(self.testType, monster.Test())
          if not monster.Test4IsNone():
              self.test4 = []
              for i in range(monster.Test4Length()):
                  if monster.Test4(i) is None:
                      self.test4.append(None)
                  else:
                      test_ = TestT.InitFromObj(monster.Test4(i))
                      self.test4.append(test_)
          if not monster.TestarrayofstringIsNone():
              self.testarrayofstring = []
              for i in range(monster.TestarrayofstringLength()):
                  self.testarrayofstring.append(monster.Testarrayofstring(i))
          if not monster.TestarrayoftablesIsNone():
              self.testarrayoftables = []
              for i in range(monster.TestarrayoftablesLength()):
                  if monster.Testarrayoftables(i) is None:
                      self.testarrayoftables.append(None)
                  else:
                      monster_ = MonsterT.InitFromObj(monster.Testarrayoftables(i))
                      self.testarrayoftables.append(monster_)
          if monster.Enemy() is not None:
              self.enemy = MonsterT.InitFromObj(monster.Enemy())
          if not monster.TestnestedflatbufferIsNone():
              if np is None:
                  self.testnestedflatbuffer = []
                  for i in range(monster.TestnestedflatbufferLength()):
                      self.testnestedflatbuffer.append(monster.Testnestedflatbuffer(i))
              else:
                  self.testnestedflatbuffer = monster.TestnestedflatbufferAsNumpy()
          if monster.Testempty() is not None:
              self.testempty = StatT.InitFromObj(monster.Testempty())
          self.testbool = monster.Testbool()
          self.testhashs32Fnv1 = monster.Testhashs32Fnv1()
          self.testhashu32Fnv1 = monster.Testhashu32Fnv1()
          self.testhashs64Fnv1 = monster.Testhashs64Fnv1()
          self.testhashu64Fnv1 = monster.Testhashu64Fnv1()
          self.testhashs32Fnv1a = monster.Testhashs32Fnv1a()
          self.testhashu32Fnv1a = monster.Testhashu32Fnv1a()
          self.testhashs64Fnv1a = monster.Testhashs64Fnv1a()
          self.testhashu64Fnv1a = monster.Testhashu64Fnv1a()
          if not monster.TestarrayofboolsIsNone():
              if np is None:
                  self.testarrayofbools = []
                  for i in range(monster.TestarrayofboolsLength()):
                      self.testarrayofbools.append(monster.Testarrayofbools(i))
              else:
                  self.testarrayofbools = monster.TestarrayofboolsAsNumpy()
          self.testf = monster.Testf()
          self.testf2 = monster.Testf2()
          self.testf3 = monster.Testf3()
          if not monster.Testarrayofstring2IsNone():
              self.testarrayofstring2 = []
              for i in range(monster.Testarrayofstring2Length()):
                  self.testarrayofstring2.append(monster.Testarrayofstring2(i))
          if not monster.TestarrayofsortedstructIsNone():
              self.testarrayofsortedstruct = []
              for i in range(monster.TestarrayofsortedstructLength()):
                  if monster.Testarrayofsortedstruct(i) is None:
                      self.testarrayofsortedstruct.append(None)
                  else:
                      ability_ = AbilityT.InitFromObj(monster.Testarrayofsortedstruct(i))
                      self.testarrayofsortedstruct.append(ability_)
          if not monster.FlexIsNone():
              if np is None:
                  self.flex = []
                  for i in range(monster.FlexLength()):
                      self.flex.append(monster.Flex(i))
              else:
                  self.flex = monster.FlexAsNumpy()
          if not monster.Test5IsNone():
              self.test5 = []
              for i in range(monster.Test5Length()):
                  if monster.Test5(i) is None:
                      self.test5.append(None)
                  else:
                      test_ = TestT.InitFromObj(monster.Test5(i))
                      self.test5.append(test_)
          if not monster.VectorOfLongsIsNone():
              if np is None:
                  self.vectorOfLongs = []
                  for i in range(monster.VectorOfLongsLength()):
                      self.vectorOfLongs.append(monster.VectorOfLongs(i))
              else:
                  self.vectorOfLongs = monster.VectorOfLongsAsNumpy()
          if not monster.VectorOfDoublesIsNone():
              if np is None:
                  self.vectorOfDoubles = []
                  for i in range(monster.VectorOfDoublesLength()):
                      self.vectorOfDoubles.append(monster.VectorOfDoubles(i))
              else:
                  self.vectorOfDoubles = monster.VectorOfDoublesAsNumpy()
          if monster.ParentNamespaceTest() is not None:
              self.parentNamespaceTest = InParentNamespaceT.InitFromObj(monster.ParentNamespaceTest())
          if not monster.VectorOfReferrablesIsNone():
              self.vectorOfReferrables = []
              for i in range(monster.VectorOfReferrablesLength()):
                  if monster.VectorOfReferrables(i) is None:
                      self.vectorOfReferrables.append(None)
                  else:
                      referrable_ = ReferrableT.InitFromObj(monster.VectorOfReferrables(i))
                      self.vectorOfReferrables.append(referrable_)
          self.singleWeakReference = monster.SingleWeakReference()
          if not monster.VectorOfWeakReferencesIsNone():
              if np is None:
                  self.vectorOfWeakReferences = []
                  for i in range(monster.VectorOfWeakReferencesLength()):
                      self.vectorOfWeakReferences.append(monster.VectorOfWeakReferences(i))
              else:
                  self.vectorOfWeakReferences = monster.VectorOfWeakReferencesAsNumpy()
          if not monster.VectorOfStrongReferrablesIsNone():
              self.vectorOfStrongReferrables = []
              for i in range(monster.VectorOfStrongReferrablesLength()):
                  if monster.VectorOfStrongReferrables(i) is None:
                      self.vectorOfStrongReferrables.append(None)
                  else:
                      referrable_ = ReferrableT.InitFromObj(monster.VectorOfStrongReferrables(i))
                      self.vectorOfStrongReferrables.append(referrable_)
          self.coOwningReference = monster.CoOwningReference()
          if not monster.VectorOfCoOwningReferencesIsNone():
              if np is None:
                  self.vectorOfCoOwningReferences = []
                  for i in range(monster.VectorOfCoOwningReferencesLength()):
                      self.vectorOfCoOwningReferences.append(monster.VectorOfCoOwningReferences(i))
              else:
                  self.vectorOfCoOwningReferences = monster.VectorOfCoOwningReferencesAsNumpy()
          self.nonOwningReference = monster.NonOwningReference()
          if not monster.VectorOfNonOwningReferencesIsNone():
              if np is None:
                  self.vectorOfNonOwningReferences = []
                  for i in range(monster.VectorOfNonOwningReferencesLength()):
                      self.vectorOfNonOwningReferences.append(monster.VectorOfNonOwningReferences(i))
              else:
                  self.vectorOfNonOwningReferences = monster.VectorOfNonOwningReferencesAsNumpy()
          self.anyUniqueType = monster.AnyUniqueType()
          self.anyUnique = AnyUniqueAliasesCreator(self.anyUniqueType, monster.AnyUnique())
          self.anyAmbiguousType = monster.AnyAmbiguousType()
          self.anyAmbiguous = AnyAmbiguousAliasesCreator(self.anyAmbiguousType, monster.AnyAmbiguous())
          if not monster.VectorOfEnumsIsNone():
              if np is None:
                  self.vectorOfEnums = []
                  for i in range(monster.VectorOfEnumsLength()):
                      self.vectorOfEnums.append(monster.VectorOfEnums(i))
              else:
                  self.vectorOfEnums = monster.VectorOfEnumsAsNumpy()
          self.signedEnum = monster.SignedEnum()
          if not monster.TestrequirednestedflatbufferIsNone():
              if np is None:
                  self.testrequirednestedflatbuffer = []
                  for i in range(monster.TestrequirednestedflatbufferLength()):
                      self.testrequirednestedflatbuffer.append(monster.Testrequirednestedflatbuffer(i))
              else:
                  self.testrequirednestedflatbuffer = monster.TestrequirednestedflatbufferAsNumpy()
          if not monster.ScalarKeySortedTablesIsNone():
              self.scalarKeySortedTables = []
              for i in range(monster.ScalarKeySortedTablesLength()):
                  if monster.ScalarKeySortedTables(i) is None:
                      self.scalarKeySortedTables.append(None)
                  else:
                      stat_ = StatT.InitFromObj(monster.ScalarKeySortedTables(i))
                      self.scalarKeySortedTables.append(stat_)
  
      # MonsterT
      def Pack(self, builder):
          if self.name is not None:
              name = builder.CreateString(self.name)
          if self.inventory is not None:
              if np is not None and type(self.inventory) is np.ndarray:
                  inventory = builder.CreateNumpyVector(self.inventory)
              else:
                  MonsterStartInventoryVector(builder, len(self.inventory))
                  for i in reversed(range(len(self.inventory))):
                      builder.PrependUint8(self.inventory[i])
                  inventory = builder.EndVector()
          if self.test is not None:
              test = self.test.Pack(builder)
          if self.test4 is not None:
              MonsterStartTest4Vector(builder, len(self.test4))
              for i in reversed(range(len(self.test4))):
                  self.test4[i].Pack(builder)
              test4 = builder.EndVector()
          if self.testarrayofstring is not None:
              testarrayofstringlist = []
              for i in range(len(self.testarrayofstring)):
                  testarrayofstringlist.append(builder.CreateString(self.testarrayofstring[i]))
              MonsterStartTestarrayofstringVector(builder, len(self.testarrayofstring))
              for i in reversed(range(len(self.testarrayofstring))):
                  builder.PrependUOffsetTRelative(testarrayofstringlist[i])
              testarrayofstring = builder.EndVector()
          if self.testarrayoftables is not None:
              testarrayoftableslist = []
              for i in range(len(self.testarrayoftables)):
                  testarrayoftableslist.append(self.testarrayoftables[i].Pack(builder))
              MonsterStartTestarrayoftablesVector(builder, len(self.testarrayoftables))
              for i in reversed(range(len(self.testarrayoftables))):
                  builder.PrependUOffsetTRelative(testarrayoftableslist[i])
              testarrayoftables = builder.EndVector()
          if self.enemy is not None:
              enemy = self.enemy.Pack(builder)
          if self.testnestedflatbuffer is not None:
              if np is not None and type(self.testnestedflatbuffer) is np.ndarray:
                  testnestedflatbuffer = builder.CreateNumpyVector(self.testnestedflatbuffer)
              else:
                  MonsterStartTestnestedflatbufferVector(builder, len(self.testnestedflatbuffer))
                  for i in reversed(range(len(self.testnestedflatbuffer))):
                      builder.PrependUint8(self.testnestedflatbuffer[i])
                  testnestedflatbuffer = builder.EndVector()
          if self.testempty is not None:
              testempty = self.testempty.Pack(builder)
          if self.testarrayofbools is not None:
              if np is not None and type(self.testarrayofbools) is np.ndarray:
                  testarrayofbools = builder.CreateNumpyVector(self.testarrayofbools)
              else:
                  MonsterStartTestarrayofboolsVector(builder, len(self.testarrayofbools))
                  for i in reversed(range(len(self.testarrayofbools))):
                      builder.PrependBool(self.testarrayofbools[i])
                  testarrayofbools = builder.EndVector()
          if self.testarrayofstring2 is not None:
              testarrayofstring2list = []
              for i in range(len(self.testarrayofstring2)):
                  testarrayofstring2list.append(builder.CreateString(self.testarrayofstring2[i]))
              MonsterStartTestarrayofstring2Vector(builder, len(self.testarrayofstring2))
              for i in reversed(range(len(self.testarrayofstring2))):
                  builder.PrependUOffsetTRelative(testarrayofstring2list[i])
              testarrayofstring2 = builder.EndVector()
          if self.testarrayofsortedstruct is not None:
              MonsterStartTestarrayofsortedstructVector(builder, len(self.testarrayofsortedstruct))
              for i in reversed(range(len(self.testarrayofsortedstruct))):
                  self.testarrayofsortedstruct[i].Pack(builder)
              testarrayofsortedstruct = builder.EndVector()
          if self.flex is not None:
              if np is not None and type(self.flex) is np.ndarray:
                  flex = builder.CreateNumpyVector(self.flex)
              else:
                  MonsterStartFlexVector(builder, len(self.flex))
                  for i in reversed(range(len(self.flex))):
                      builder.PrependUint8(self.flex[i])
                  flex = builder.EndVector()
          if self.test5 is not None:
              MonsterStartTest5Vector(builder, len(self.test5))
              for i in reversed(range(len(self.test5))):
                  self.test5[i].Pack(builder)
              test5 = builder.EndVector()
          if self.vectorOfLongs is not None:
              if np is not None and type(self.vectorOfLongs) is np.ndarray:
                  vectorOfLongs = builder.CreateNumpyVector(self.vectorOfLongs)
              else:
                  MonsterStartVectorOfLongsVector(builder, len(self.vectorOfLongs))
                  for i in reversed(range(len(self.vectorOfLongs))):
                      builder.PrependInt64(self.vectorOfLongs[i])
                  vectorOfLongs = builder.EndVector()
          if self.vectorOfDoubles is not None:
              if np is not None and type(self.vectorOfDoubles) is np.ndarray:
                  vectorOfDoubles = builder.CreateNumpyVector(self.vectorOfDoubles)
              else:
                  MonsterStartVectorOfDoublesVector(builder, len(self.vectorOfDoubles))
                  for i in reversed(range(len(self.vectorOfDoubles))):
                      builder.PrependFloat64(self.vectorOfDoubles[i])
                  vectorOfDoubles = builder.EndVector()
          if self.parentNamespaceTest is not None:
              parentNamespaceTest = self.parentNamespaceTest.Pack(builder)
          if self.vectorOfReferrables is not None:
              vectorOfReferrableslist = []
              for i in range(len(self.vectorOfReferrables)):
                  vectorOfReferrableslist.append(self.vectorOfReferrables[i].Pack(builder))
              MonsterStartVectorOfReferrablesVector(builder, len(self.vectorOfReferrables))
              for i in reversed(range(len(self.vectorOfReferrables))):
                  builder.PrependUOffsetTRelative(vectorOfReferrableslist[i])
              vectorOfReferrables = builder.EndVector()
          if self.vectorOfWeakReferences is not None:
              if np is not None and type(self.vectorOfWeakReferences) is np.ndarray:
                  vectorOfWeakReferences = builder.CreateNumpyVector(self.vectorOfWeakReferences)
              else:
                  MonsterStartVectorOfWeakReferencesVector(builder, len(self.vectorOfWeakReferences))
                  for i in reversed(range(len(self.vectorOfWeakReferences))):
                      builder.PrependUint64(self.vectorOfWeakReferences[i])
                  vectorOfWeakReferences = builder.EndVector()
          if self.vectorOfStrongReferrables is not None:
              vectorOfStrongReferrableslist = []
              for i in range(len(self.vectorOfStrongReferrables)):
                  vectorOfStrongReferrableslist.append(self.vectorOfStrongReferrables[i].Pack(builder))
              MonsterStartVectorOfStrongReferrablesVector(builder, len(self.vectorOfStrongReferrables))
              for i in reversed(range(len(self.vectorOfStrongReferrables))):
                  builder.PrependUOffsetTRelative(vectorOfStrongReferrableslist[i])
              vectorOfStrongReferrables = builder.EndVector()
          if self.vectorOfCoOwningReferences is not None:
              if np is not None and type(self.vectorOfCoOwningReferences) is np.ndarray:
                  vectorOfCoOwningReferences = builder.CreateNumpyVector(self.vectorOfCoOwningReferences)
              else:
                  MonsterStartVectorOfCoOwningReferencesVector(builder, len(self.vectorOfCoOwningReferences))
                  for i in reversed(range(len(self.vectorOfCoOwningReferences))):
                      builder.PrependUint64(self.vectorOfCoOwningReferences[i])
                  vectorOfCoOwningReferences = builder.EndVector()
          if self.vectorOfNonOwningReferences is not None:
              if np is not None and type(self.vectorOfNonOwningReferences) is np.ndarray:
                  vectorOfNonOwningReferences = builder.CreateNumpyVector(self.vectorOfNonOwningReferences)
              else:
                  MonsterStartVectorOfNonOwningReferencesVector(builder, len(self.vectorOfNonOwningReferences))
                  for i in reversed(range(len(self.vectorOfNonOwningReferences))):
                      builder.PrependUint64(self.vectorOfNonOwningReferences[i])
                  vectorOfNonOwningReferences = builder.EndVector()
          if self.anyUnique is not None:
              anyUnique = self.anyUnique.Pack(builder)
          if self.anyAmbiguous is not None:
              anyAmbiguous = self.anyAmbiguous.Pack(builder)
          if self.vectorOfEnums is not None:
              if np is not None and type(self.vectorOfEnums) is np.ndarray:
                  vectorOfEnums = builder.CreateNumpyVector(self.vectorOfEnums)
              else:
                  MonsterStartVectorOfEnumsVector(builder, len(self.vectorOfEnums))
                  for i in reversed(range(len(self.vectorOfEnums))):
                      builder.PrependUint8(self.vectorOfEnums[i])
                  vectorOfEnums = builder.EndVector()
          if self.testrequirednestedflatbuffer is not None:
              if np is not None and type(self.testrequirednestedflatbuffer) is np.ndarray:
                  testrequirednestedflatbuffer = builder.CreateNumpyVector(self.testrequirednestedflatbuffer)
              else:
                  MonsterStartTestrequirednestedflatbufferVector(builder, len(self.testrequirednestedflatbuffer))
                  for i in reversed(range(len(self.testrequirednestedflatbuffer))):
                      builder.PrependUint8(self.testrequirednestedflatbuffer[i])
                  testrequirednestedflatbuffer = builder.EndVector()
          if self.scalarKeySortedTables is not None:
              scalarKeySortedTableslist = []
              for i in range(len(self.scalarKeySortedTables)):
                  scalarKeySortedTableslist.append(self.scalarKeySortedTables[i].Pack(builder))
              MonsterStartScalarKeySortedTablesVector(builder, len(self.scalarKeySortedTables))
              for i in reversed(range(len(self.scalarKeySortedTables))):
                  builder.PrependUOffsetTRelative(scalarKeySortedTableslist[i])
              scalarKeySortedTables = builder.EndVector()
          MonsterStart(builder)
          if self.pos is not None:
              pos = self.pos.Pack(builder)
              MonsterAddPos(builder, pos)
          MonsterAddMana(builder, self.mana)
          MonsterAddHp(builder, self.hp)
          if self.name is not None:
              MonsterAddName(builder, name)
          if self.inventory is not None:
              MonsterAddInventory(builder, inventory)
          MonsterAddColor(builder, self.color)
          MonsterAddTestType(builder, self.testType)
          if self.test is not None:
              MonsterAddTest(builder, test)
          if self.test4 is not None:
              MonsterAddTest4(builder, test4)
          if self.testarrayofstring is not None:
              MonsterAddTestarrayofstring(builder, testarrayofstring)
          if self.testarrayoftables is not None:
              MonsterAddTestarrayoftables(builder, testarrayoftables)
          if self.enemy is not None:
              MonsterAddEnemy(builder, enemy)
          if self.testnestedflatbuffer is not None:
              MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer)
          if self.testempty is not None:
              MonsterAddTestempty(builder, testempty)
          MonsterAddTestbool(builder, self.testbool)
          MonsterAddTesthashs32Fnv1(builder, self.testhashs32Fnv1)
          MonsterAddTesthashu32Fnv1(builder, self.testhashu32Fnv1)
          MonsterAddTesthashs64Fnv1(builder, self.testhashs64Fnv1)
          MonsterAddTesthashu64Fnv1(builder, self.testhashu64Fnv1)
          MonsterAddTesthashs32Fnv1a(builder, self.testhashs32Fnv1a)
          MonsterAddTesthashu32Fnv1a(builder, self.testhashu32Fnv1a)
          MonsterAddTesthashs64Fnv1a(builder, self.testhashs64Fnv1a)
          MonsterAddTesthashu64Fnv1a(builder, self.testhashu64Fnv1a)
          if self.testarrayofbools is not None:
              MonsterAddTestarrayofbools(builder, testarrayofbools)
          MonsterAddTestf(builder, self.testf)
          MonsterAddTestf2(builder, self.testf2)
          MonsterAddTestf3(builder, self.testf3)
          if self.testarrayofstring2 is not None:
              MonsterAddTestarrayofstring2(builder, testarrayofstring2)
          if self.testarrayofsortedstruct is not None:
              MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct)
          if self.flex is not None:
              MonsterAddFlex(builder, flex)
          if self.test5 is not None:
              MonsterAddTest5(builder, test5)
          if self.vectorOfLongs is not None:
              MonsterAddVectorOfLongs(builder, vectorOfLongs)
          if self.vectorOfDoubles is not None:
              MonsterAddVectorOfDoubles(builder, vectorOfDoubles)
          if self.parentNamespaceTest is not None:
              MonsterAddParentNamespaceTest(builder, parentNamespaceTest)
          if self.vectorOfReferrables is not None:
              MonsterAddVectorOfReferrables(builder, vectorOfReferrables)
          MonsterAddSingleWeakReference(builder, self.singleWeakReference)
          if self.vectorOfWeakReferences is not None:
              MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences)
          if self.vectorOfStrongReferrables is not None:
              MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables)
          MonsterAddCoOwningReference(builder, self.coOwningReference)
          if self.vectorOfCoOwningReferences is not None:
              MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences)
          MonsterAddNonOwningReference(builder, self.nonOwningReference)
          if self.vectorOfNonOwningReferences is not None:
              MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences)
          MonsterAddAnyUniqueType(builder, self.anyUniqueType)
          if self.anyUnique is not None:
              MonsterAddAnyUnique(builder, anyUnique)
          MonsterAddAnyAmbiguousType(builder, self.anyAmbiguousType)
          if self.anyAmbiguous is not None:
              MonsterAddAnyAmbiguous(builder, anyAmbiguous)
          if self.vectorOfEnums is not None:
              MonsterAddVectorOfEnums(builder, vectorOfEnums)
          MonsterAddSignedEnum(builder, self.signedEnum)
          if self.testrequirednestedflatbuffer is not None:
              MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer)
          if self.scalarKeySortedTables is not None:
              MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables)
          monster = MonsterEnd(builder)
          return monster
  
  
  class TypeAliases(object):
      __slots__ = ['_tab']
  
      @classmethod
      def GetRootAs(cls, buf, offset=0):
          n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
          x = TypeAliases()
          x.Init(buf, n + offset)
          return x
  
      @classmethod
      def GetRootAsTypeAliases(cls, buf, offset=0):
          """This method is deprecated. Please switch to GetRootAs."""
          return cls.GetRootAs(buf, offset)
      @classmethod
      def TypeAliasesBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
          return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4D\x4F\x4E\x53", size_prefixed=size_prefixed)
  
      # TypeAliases
      def Init(self, buf, pos):
          self._tab = flatbuffers.table.Table(buf, pos)
  
      # TypeAliases
      def I8(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
          if o != 0:
              return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
          return 0
  
      # TypeAliases
      def U8(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
          if o != 0:
              return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
          return 0
  
      # TypeAliases
      def I16(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
          if o != 0:
              return self._tab.Get(flatbuffers.number_types.Int16Flags, o + self._tab.Pos)
          return 0
  
      # TypeAliases
      def U16(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
          if o != 0:
              return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
          return 0
  
      # TypeAliases
      def I32(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
          if o != 0:
              return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
          return 0
  
      # TypeAliases
      def U32(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
          if o != 0:
              return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
          return 0
  
      # TypeAliases
      def I64(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
          if o != 0:
              return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
          return 0
  
      # TypeAliases
      def U64(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
          if o != 0:
              return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
          return 0
  
      # TypeAliases
      def F32(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
          if o != 0:
              return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
          return 0.0
  
      # TypeAliases
      def F64(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
          if o != 0:
              return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
          return 0.0
  
      # TypeAliases
      def V8(self, j):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
          if o != 0:
              a = self._tab.Vector(o)
              return self._tab.Get(flatbuffers.number_types.Int8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
          return 0
  
      # TypeAliases
      def V8AsNumpy(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
          if o != 0:
              return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int8Flags, o)
          return 0
  
      # TypeAliases
      def V8Length(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
          if o != 0:
              return self._tab.VectorLen(o)
          return 0
  
      # TypeAliases
      def V8IsNone(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
          return o == 0
  
      # TypeAliases
      def Vf64(self, j):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
          if o != 0:
              a = self._tab.Vector(o)
              return self._tab.Get(flatbuffers.number_types.Float64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
          return 0
  
      # TypeAliases
      def Vf64AsNumpy(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
          if o != 0:
              return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float64Flags, o)
          return 0
  
      # TypeAliases
      def Vf64Length(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
          if o != 0:
              return self._tab.VectorLen(o)
          return 0
  
      # TypeAliases
      def Vf64IsNone(self):
          o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
          return o == 0
  
  def TypeAliasesStart(builder): builder.StartObject(12)
  def TypeAliasesAddI8(builder, i8): builder.PrependInt8Slot(0, i8, 0)
  def TypeAliasesAddU8(builder, u8): builder.PrependUint8Slot(1, u8, 0)
  def TypeAliasesAddI16(builder, i16): builder.PrependInt16Slot(2, i16, 0)
  def TypeAliasesAddU16(builder, u16): builder.PrependUint16Slot(3, u16, 0)
  def TypeAliasesAddI32(builder, i32): builder.PrependInt32Slot(4, i32, 0)
  def TypeAliasesAddU32(builder, u32): builder.PrependUint32Slot(5, u32, 0)
  def TypeAliasesAddI64(builder, i64): builder.PrependInt64Slot(6, i64, 0)
  def TypeAliasesAddU64(builder, u64): builder.PrependUint64Slot(7, u64, 0)
  def TypeAliasesAddF32(builder, f32): builder.PrependFloat32Slot(8, f32, 0.0)
  def TypeAliasesAddF64(builder, f64): builder.PrependFloat64Slot(9, f64, 0.0)
  def TypeAliasesAddV8(builder, v8): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(v8), 0)
  def TypeAliasesStartV8Vector(builder, numElems): return builder.StartVector(1, numElems, 1)
  def TypeAliasesAddVf64(builder, vf64): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(vf64), 0)
  def TypeAliasesStartVf64Vector(builder, numElems): return builder.StartVector(8, numElems, 8)
  def TypeAliasesEnd(builder): return builder.EndObject()
  
  try:
      from typing import List
  except:
      pass
  
  class TypeAliasesT(object):
  
      # TypeAliasesT
      def __init__(self):
          self.i8 = 0  # type: int
          self.u8 = 0  # type: int
          self.i16 = 0  # type: int
          self.u16 = 0  # type: int
          self.i32 = 0  # type: int
          self.u32 = 0  # type: int
          self.i64 = 0  # type: int
          self.u64 = 0  # type: int
          self.f32 = 0.0  # type: float
          self.f64 = 0.0  # type: float
          self.v8 = None  # type: List[int]
          self.vf64 = None  # type: List[float]
  
      @classmethod
      def InitFromBuf(cls, buf, pos):
          typeAliases = TypeAliases()
          typeAliases.Init(buf, pos)
          return cls.InitFromObj(typeAliases)
  
      @classmethod
      def InitFromObj(cls, typeAliases):
          x = TypeAliasesT()
          x._UnPack(typeAliases)
          return x
  
      # TypeAliasesT
      def _UnPack(self, typeAliases):
          if typeAliases is None:
              return
          self.i8 = typeAliases.I8()
          self.u8 = typeAliases.U8()
          self.i16 = typeAliases.I16()
          self.u16 = typeAliases.U16()
          self.i32 = typeAliases.I32()
          self.u32 = typeAliases.U32()
          self.i64 = typeAliases.I64()
          self.u64 = typeAliases.U64()
          self.f32 = typeAliases.F32()
          self.f64 = typeAliases.F64()
          if not typeAliases.V8IsNone():
              if np is None:
                  self.v8 = []
                  for i in range(typeAliases.V8Length()):
                      self.v8.append(typeAliases.V8(i))
              else:
                  self.v8 = typeAliases.V8AsNumpy()
          if not typeAliases.Vf64IsNone():
              if np is None:
                  self.vf64 = []
                  for i in range(typeAliases.Vf64Length()):
                      self.vf64.append(typeAliases.Vf64(i))
              else:
                  self.vf64 = typeAliases.Vf64AsNumpy()
  
      # TypeAliasesT
      def Pack(self, builder):
          if self.v8 is not None:
              if np is not None and type(self.v8) is np.ndarray:
                  v8 = builder.CreateNumpyVector(self.v8)
              else:
                  TypeAliasesStartV8Vector(builder, len(self.v8))
                  for i in reversed(range(len(self.v8))):
                      builder.PrependByte(self.v8[i])
                  v8 = builder.EndVector()
          if self.vf64 is not None:
              if np is not None and type(self.vf64) is np.ndarray:
                  vf64 = builder.CreateNumpyVector(self.vf64)
              else:
                  TypeAliasesStartVf64Vector(builder, len(self.vf64))
                  for i in reversed(range(len(self.vf64))):
                      builder.PrependFloat64(self.vf64[i])
                  vf64 = builder.EndVector()
          TypeAliasesStart(builder)
          TypeAliasesAddI8(builder, self.i8)
          TypeAliasesAddU8(builder, self.u8)
          TypeAliasesAddI16(builder, self.i16)
          TypeAliasesAddU16(builder, self.u16)
          TypeAliasesAddI32(builder, self.i32)
          TypeAliasesAddU32(builder, self.u32)
          TypeAliasesAddI64(builder, self.i64)
          TypeAliasesAddU64(builder, self.u64)
          TypeAliasesAddF32(builder, self.f32)
          TypeAliasesAddF64(builder, self.f64)
          if self.v8 is not None:
              TypeAliasesAddV8(builder, v8)
          if self.vf64 is not None:
              TypeAliasesAddVf64(builder, vf64)
          typeAliases = TypeAliasesEnd(builder)
          return typeAliases
  
  
  