// automatically generated by the FlatBuffers compiler, do not modify
// swiftlint:disable all

import FlatBuffers

///  Composite components of Monster color.
public enum MyGame_Example_Color: UInt8, Enum { 
    public typealias T = UInt8
    public static var byteSize: Int { return MemoryLayout<UInt8>.size }
    public var value: UInt8 { return self.rawValue }
    case red = 1
    ///  \brief color Green
    ///  Green is bit_flag with value (1u << 1)
    case green = 2
    ///  \brief color Blue (1u << 3)
    case blue = 8
    

    public static var max: MyGame_Example_Color { return .blue }
    public static var min: MyGame_Example_Color { return .red }
}

public enum MyGame_Example_Race: Int8, Enum { 
    public typealias T = Int8
    public static var byteSize: Int { return MemoryLayout<Int8>.size }
    public var value: Int8 { return self.rawValue }
    case none_ = -1
    case human = 0
    case dwarf = 1
    case elf = 2
    

    public static var max: MyGame_Example_Race { return .elf }
    public static var min: MyGame_Example_Race { return .none_ }
}

public enum MyGame_Example_Any_: UInt8, Enum { 
    public typealias T = UInt8
    public static var byteSize: Int { return MemoryLayout<UInt8>.size }
    public var value: UInt8 { return self.rawValue }
    case none_ = 0
    case monster = 1
    case testsimpletablewithenum = 2
    case mygameExample2Monster = 3
    

    public static var max: MyGame_Example_Any_ { return .mygameExample2Monster }
    public static var min: MyGame_Example_Any_ { return .none_ }
}

public struct MyGame_Example_Any_Union {
    public var type: MyGame_Example_Any_
    public var value: NativeTable?
    public init(_ v: NativeTable?, type: MyGame_Example_Any_) {
        self.type = type
        self.value = v
    }
    public func pack(builder: inout FlatBufferBuilder) -> Offset<UOffset> {
        switch type {
        case .monster:
            var __obj = value as? MyGame_Example_MonsterT
            return MyGame_Example_Monster.pack(&builder, obj: &__obj)
        case .testsimpletablewithenum:
            var __obj = value as? MyGame_Example_TestSimpleTableWithEnumT
            return MyGame_Example_TestSimpleTableWithEnum.pack(&builder, obj: &__obj)
        case .mygameExample2Monster:
            var __obj = value as? MyGame_Example2_MonsterT
            return MyGame_Example2_Monster.pack(&builder, obj: &__obj)
        default: return Offset()
        }
    }
}
public enum MyGame_Example_AnyUniqueAliases: UInt8, Enum { 
    public typealias T = UInt8
    public static var byteSize: Int { return MemoryLayout<UInt8>.size }
    public var value: UInt8 { return self.rawValue }
    case none_ = 0
    case m = 1
    case ts = 2
    case m2 = 3
    

    public static var max: MyGame_Example_AnyUniqueAliases { return .m2 }
    public static var min: MyGame_Example_AnyUniqueAliases { return .none_ }
}

public struct MyGame_Example_AnyUniqueAliasesUnion {
    public var type: MyGame_Example_AnyUniqueAliases
    public var value: NativeTable?
    public init(_ v: NativeTable?, type: MyGame_Example_AnyUniqueAliases) {
        self.type = type
        self.value = v
    }
    public func pack(builder: inout FlatBufferBuilder) -> Offset<UOffset> {
        switch type {
        case .m:
            var __obj = value as? MyGame_Example_MonsterT
            return MyGame_Example_Monster.pack(&builder, obj: &__obj)
        case .ts:
            var __obj = value as? MyGame_Example_TestSimpleTableWithEnumT
            return MyGame_Example_TestSimpleTableWithEnum.pack(&builder, obj: &__obj)
        case .m2:
            var __obj = value as? MyGame_Example2_MonsterT
            return MyGame_Example2_Monster.pack(&builder, obj: &__obj)
        default: return Offset()
        }
    }
}
public enum MyGame_Example_AnyAmbiguousAliases: UInt8, Enum { 
    public typealias T = UInt8
    public static var byteSize: Int { return MemoryLayout<UInt8>.size }
    public var value: UInt8 { return self.rawValue }
    case none_ = 0
    case m1 = 1
    case m2 = 2
    case m3 = 3
    

    public static var max: MyGame_Example_AnyAmbiguousAliases { return .m3 }
    public static var min: MyGame_Example_AnyAmbiguousAliases { return .none_ }
}

public struct MyGame_Example_AnyAmbiguousAliasesUnion {
    public var type: MyGame_Example_AnyAmbiguousAliases
    public var value: NativeTable?
    public init(_ v: NativeTable?, type: MyGame_Example_AnyAmbiguousAliases) {
        self.type = type
        self.value = v
    }
    public func pack(builder: inout FlatBufferBuilder) -> Offset<UOffset> {
        switch type {
        case .m1:
            var __obj = value as? MyGame_Example_MonsterT
            return MyGame_Example_Monster.pack(&builder, obj: &__obj)
        case .m2:
            var __obj = value as? MyGame_Example_MonsterT
            return MyGame_Example_Monster.pack(&builder, obj: &__obj)
        case .m3:
            var __obj = value as? MyGame_Example_MonsterT
            return MyGame_Example_Monster.pack(&builder, obj: &__obj)
        default: return Offset()
        }
    }
}
public struct MyGame_Example_Test: Readable {

    static func validateVersion() { FlatBuffersVersion_1_12_0() }
    public var __buffer: ByteBuffer! { return _accessor.bb }
    private var _accessor: Struct

    public static var size = 4
    public static var alignment = 2
    public init(_ bb: ByteBuffer, o: Int32) { _accessor = Struct(bb: bb, position: o) }

    public var a: Int16 { return _accessor.readBuffer(of: Int16.self, at: 0) }
    @discardableResult public func mutate(a: Int16) -> Bool { return _accessor.mutate(a, index: 0) }
    public var b: Int8 { return _accessor.readBuffer(of: Int8.self, at: 2) }
    @discardableResult public func mutate(b: Int8) -> Bool { return _accessor.mutate(b, index: 2) }
    

    public mutating func unpack() -> MyGame_Example_TestT {
        return MyGame_Example_TestT(&self)
    }
    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_TestT?) -> Offset<UOffset> {
        guard var obj = obj else { return Offset<UOffset>() }
        return pack(&builder, obj: &obj)
    }

    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_TestT) -> Offset<UOffset> {
        return builder.create(struct: createTest(a: obj.a, b: obj.b), type: MyGame_Example_Test.self)
    }
}

public class MyGame_Example_TestT: NativeTable {

    public var a: Int16
    public var b: Int8

    public init(_ _t: inout MyGame_Example_Test) {
        a = _t.a
        b = _t.b
    }

    public init() {
        a = 0
        b = 0
    }

}
public struct MyGame_Example_Vec3: Readable {

    static func validateVersion() { FlatBuffersVersion_1_12_0() }
    public var __buffer: ByteBuffer! { return _accessor.bb }
    private var _accessor: Struct

    public static var size = 32
    public static var alignment = 8
    public init(_ bb: ByteBuffer, o: Int32) { _accessor = Struct(bb: bb, position: o) }

    public var x: Float32 { return _accessor.readBuffer(of: Float32.self, at: 0) }
    @discardableResult public func mutate(x: Float32) -> Bool { return _accessor.mutate(x, index: 0) }
    public var y: Float32 { return _accessor.readBuffer(of: Float32.self, at: 4) }
    @discardableResult public func mutate(y: Float32) -> Bool { return _accessor.mutate(y, index: 4) }
    public var z: Float32 { return _accessor.readBuffer(of: Float32.self, at: 8) }
    @discardableResult public func mutate(z: Float32) -> Bool { return _accessor.mutate(z, index: 8) }
    public var test1: Double { return _accessor.readBuffer(of: Double.self, at: 16) }
    @discardableResult public func mutate(test1: Double) -> Bool { return _accessor.mutate(test1, index: 16) }
    public var test2: MyGame_Example_Color { return MyGame_Example_Color(rawValue: _accessor.readBuffer(of: UInt8.self, at: 24)) ?? .red }
    public var test3: MyGame_Example_Test { return MyGame_Example_Test(_accessor.bb, o: _accessor.postion + 26) }
    

    public mutating func unpack() -> MyGame_Example_Vec3T {
        return MyGame_Example_Vec3T(&self)
    }
    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_Vec3T?) -> Offset<UOffset> {
        guard var obj = obj else { return Offset<UOffset>() }
        return pack(&builder, obj: &obj)
    }

    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_Vec3T) -> Offset<UOffset> {
        return builder.create(struct: createVec3(x: obj.x, y: obj.y, z: obj.z, test1: obj.test1, test2: obj.test2, test3a: obj.test3.a, test3b: obj.test3.b), type: MyGame_Example_Vec3.self)
    }
}

public class MyGame_Example_Vec3T: NativeTable {

    public var x: Float32
    public var y: Float32
    public var z: Float32
    public var test1: Double
    public var test2: MyGame_Example_Color
    public var test3: MyGame_Example_TestT

    public init(_ _t: inout MyGame_Example_Vec3) {
        x = _t.x
        y = _t.y
        z = _t.z
        test1 = _t.test1
        test2 = _t.test2
        var __test3 = _t.test3
        test3 = __test3.unpack()
    }

    public init() {
        x = 0.0
        y = 0.0
        z = 0.0
        test1 = 0.0
        test2 = .red
        test3 = MyGame_Example_TestT()
    }

}
public struct MyGame_Example_Ability: Readable {

    static func validateVersion() { FlatBuffersVersion_1_12_0() }
    public var __buffer: ByteBuffer! { return _accessor.bb }
    private var _accessor: Struct

    public static var size = 8
    public static var alignment = 4
    public init(_ bb: ByteBuffer, o: Int32) { _accessor = Struct(bb: bb, position: o) }

    public var id: UInt32 { return _accessor.readBuffer(of: UInt32.self, at: 0) }
    @discardableResult public func mutate(id: UInt32) -> Bool { return _accessor.mutate(id, index: 0) }
    public var distance: UInt32 { return _accessor.readBuffer(of: UInt32.self, at: 4) }
    @discardableResult public func mutate(distance: UInt32) -> Bool { return _accessor.mutate(distance, index: 4) }
    

    public mutating func unpack() -> MyGame_Example_AbilityT {
        return MyGame_Example_AbilityT(&self)
    }
    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_AbilityT?) -> Offset<UOffset> {
        guard var obj = obj else { return Offset<UOffset>() }
        return pack(&builder, obj: &obj)
    }

    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_AbilityT) -> Offset<UOffset> {
        return builder.create(struct: createAbility(id: obj.id, distance: obj.distance), type: MyGame_Example_Ability.self)
    }
}

public class MyGame_Example_AbilityT: NativeTable {

    public var id: UInt32
    public var distance: UInt32

    public init(_ _t: inout MyGame_Example_Ability) {
        id = _t.id
        distance = _t.distance
    }

    public init() {
        id = 0
        distance = 0
    }

}
extension MyGame_Example_Test {
    public static func createTest(a: Int16 = 0, b: Int8 = 0) -> UnsafeMutableRawPointer {
        let memory = UnsafeMutableRawPointer.allocate(byteCount: MyGame_Example_Test.size, alignment: MyGame_Example_Test.alignment)
        memory.initializeMemory(as: UInt8.self, repeating: 0, count: MyGame_Example_Test.size)
        memory.storeBytes(of: a, toByteOffset: 0, as: Int16.self)
        memory.storeBytes(of: b, toByteOffset: 2, as: Int8.self)
        return memory
    }

}

extension MyGame_Example_Vec3 {
    public static func createVec3(x: Float32 = 0.0, y: Float32 = 0.0, z: Float32 = 0.0, test1: Double = 0.0, test2: MyGame_Example_Color, test3a: Int16 = 0, test3b: Int8 = 0) -> UnsafeMutableRawPointer {
        let memory = UnsafeMutableRawPointer.allocate(byteCount: MyGame_Example_Vec3.size, alignment: MyGame_Example_Vec3.alignment)
        memory.initializeMemory(as: UInt8.self, repeating: 0, count: MyGame_Example_Vec3.size)
        memory.storeBytes(of: x, toByteOffset: 0, as: Float32.self)
        memory.storeBytes(of: y, toByteOffset: 4, as: Float32.self)
        memory.storeBytes(of: z, toByteOffset: 8, as: Float32.self)
        memory.storeBytes(of: test1, toByteOffset: 16, as: Double.self)
        memory.storeBytes(of: test2.rawValue, toByteOffset: 24, as: UInt8.self)
        memory.storeBytes(of: test3a, toByteOffset: 26, as: Int16.self)
        memory.storeBytes(of: test3b, toByteOffset: 28, as: Int8.self)
        return memory
    }

}

extension MyGame_Example_Ability {
    public static func createAbility(id: UInt32 = 0, distance: UInt32 = 0) -> UnsafeMutableRawPointer {
        let memory = UnsafeMutableRawPointer.allocate(byteCount: MyGame_Example_Ability.size, alignment: MyGame_Example_Ability.alignment)
        memory.initializeMemory(as: UInt8.self, repeating: 0, count: MyGame_Example_Ability.size)
        memory.storeBytes(of: id, toByteOffset: 0, as: UInt32.self)
        memory.storeBytes(of: distance, toByteOffset: 4, as: UInt32.self)
        return memory
    }

}

public struct MyGame_InParentNamespace: FlatBufferObject, ObjectAPI {

    static func validateVersion() { FlatBuffersVersion_1_12_0() }
    public var __buffer: ByteBuffer! { return _accessor.bb }
    private var _accessor: Table

    public static func finish(_ fbb: inout FlatBufferBuilder, end: Offset<UOffset>, prefix: Bool = false) { fbb.finish(offset: end, fileId: "MONS", addPrefix: prefix) }
    public static func getRootAsInParentNamespace(bb: ByteBuffer) -> MyGame_InParentNamespace { return MyGame_InParentNamespace(Table(bb: bb, position: Int32(bb.read(def: UOffset.self, position: bb.reader)) + Int32(bb.reader))) }

    private init(_ t: Table) { _accessor = t }
    public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }

    public static func startInParentNamespace(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 0) }
    public static func endInParentNamespace(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); return end }
    

    public mutating func unpack() -> MyGame_InParentNamespaceT {
        return MyGame_InParentNamespaceT(&self)
    }
    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_InParentNamespaceT?) -> Offset<UOffset> {
        guard var obj = obj else { return Offset<UOffset>() }
        return pack(&builder, obj: &obj)
    }

    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_InParentNamespaceT) -> Offset<UOffset> {
        let __root = MyGame_InParentNamespace.startInParentNamespace(&builder)
        return MyGame_InParentNamespace.endInParentNamespace(&builder, start: __root)
    }
}

public class MyGame_InParentNamespaceT: NativeTable {


    public init(_ _t: inout MyGame_InParentNamespace) {
    }

    public init() {
    }

    public func serialize() -> ByteBuffer { return serialize(type: MyGame_InParentNamespace.self) }

}
public struct MyGame_Example2_Monster: FlatBufferObject, ObjectAPI {

    static func validateVersion() { FlatBuffersVersion_1_12_0() }
    public var __buffer: ByteBuffer! { return _accessor.bb }
    private var _accessor: Table

    public static func finish(_ fbb: inout FlatBufferBuilder, end: Offset<UOffset>, prefix: Bool = false) { fbb.finish(offset: end, fileId: "MONS", addPrefix: prefix) }
    public static func getRootAsMonster(bb: ByteBuffer) -> MyGame_Example2_Monster { return MyGame_Example2_Monster(Table(bb: bb, position: Int32(bb.read(def: UOffset.self, position: bb.reader)) + Int32(bb.reader))) }

    private init(_ t: Table) { _accessor = t }
    public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }

    public static func startMonster(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 0) }
    public static func endMonster(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); return end }
    

    public mutating func unpack() -> MyGame_Example2_MonsterT {
        return MyGame_Example2_MonsterT(&self)
    }
    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example2_MonsterT?) -> Offset<UOffset> {
        guard var obj = obj else { return Offset<UOffset>() }
        return pack(&builder, obj: &obj)
    }

    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example2_MonsterT) -> Offset<UOffset> {
        let __root = MyGame_Example2_Monster.startMonster(&builder)
        return MyGame_Example2_Monster.endMonster(&builder, start: __root)
    }
}

public class MyGame_Example2_MonsterT: NativeTable {


    public init(_ _t: inout MyGame_Example2_Monster) {
    }

    public init() {
    }

    public func serialize() -> ByteBuffer { return serialize(type: MyGame_Example2_Monster.self) }

}
internal struct MyGame_Example_TestSimpleTableWithEnum: FlatBufferObject, ObjectAPI {

    static func validateVersion() { FlatBuffersVersion_1_12_0() }
    internal var __buffer: ByteBuffer! { return _accessor.bb }
    private var _accessor: Table

    internal static func finish(_ fbb: inout FlatBufferBuilder, end: Offset<UOffset>, prefix: Bool = false) { fbb.finish(offset: end, fileId: "MONS", addPrefix: prefix) }
    internal static func getRootAsTestSimpleTableWithEnum(bb: ByteBuffer) -> MyGame_Example_TestSimpleTableWithEnum { return MyGame_Example_TestSimpleTableWithEnum(Table(bb: bb, position: Int32(bb.read(def: UOffset.self, position: bb.reader)) + Int32(bb.reader))) }

    private init(_ t: Table) { _accessor = t }
    internal init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }

    private enum VTOFFSET: VOffset {
        case color = 4
        var v: Int32 { Int32(self.rawValue) }
        var p: VOffset { self.rawValue }
    }

    internal var color: MyGame_Example_Color { let o = _accessor.offset(VTOFFSET.color.v); return o == 0 ? .green : MyGame_Example_Color(rawValue: _accessor.readBuffer(of: UInt8.self, at: o)) ?? .green }
    @discardableResult internal func mutate(color: MyGame_Example_Color) -> Bool {let o = _accessor.offset(VTOFFSET.color.v);  return _accessor.mutate(color.rawValue, index: o) }
    internal static func startTestSimpleTableWithEnum(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
    internal static func add(color: MyGame_Example_Color, _ fbb: inout FlatBufferBuilder) { fbb.add(element: color.rawValue, def: 2, at: VTOFFSET.color.p) }
    internal static func endTestSimpleTableWithEnum(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); return end }
    internal static func createTestSimpleTableWithEnum(
        _ fbb: inout FlatBufferBuilder,
        color: MyGame_Example_Color = .green
    ) -> Offset<UOffset> {
        let __start = MyGame_Example_TestSimpleTableWithEnum.startTestSimpleTableWithEnum(&fbb)
        MyGame_Example_TestSimpleTableWithEnum.add(color: color, &fbb)
        return MyGame_Example_TestSimpleTableWithEnum.endTestSimpleTableWithEnum(&fbb, start: __start)
    }
    

    internal mutating func unpack() -> MyGame_Example_TestSimpleTableWithEnumT {
        return MyGame_Example_TestSimpleTableWithEnumT(&self)
    }
    internal static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_TestSimpleTableWithEnumT?) -> Offset<UOffset> {
        guard var obj = obj else { return Offset<UOffset>() }
        return pack(&builder, obj: &obj)
    }

    internal static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_TestSimpleTableWithEnumT) -> Offset<UOffset> {
        let __root = MyGame_Example_TestSimpleTableWithEnum.startTestSimpleTableWithEnum(&builder)
        MyGame_Example_TestSimpleTableWithEnum.add(color: obj.color, &builder)
        return MyGame_Example_TestSimpleTableWithEnum.endTestSimpleTableWithEnum(&builder, start: __root)
    }
}

internal class MyGame_Example_TestSimpleTableWithEnumT: NativeTable {

    internal var color: MyGame_Example_Color

    internal init(_ _t: inout MyGame_Example_TestSimpleTableWithEnum) {
        color = _t.color
    }

    internal init() {
        color = .green
    }

    internal func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_TestSimpleTableWithEnum.self) }

}
public struct MyGame_Example_Stat: FlatBufferObject, ObjectAPI {

    static func validateVersion() { FlatBuffersVersion_1_12_0() }
    public var __buffer: ByteBuffer! { return _accessor.bb }
    private var _accessor: Table

    public static func finish(_ fbb: inout FlatBufferBuilder, end: Offset<UOffset>, prefix: Bool = false) { fbb.finish(offset: end, fileId: "MONS", addPrefix: prefix) }
    public static func getRootAsStat(bb: ByteBuffer) -> MyGame_Example_Stat { return MyGame_Example_Stat(Table(bb: bb, position: Int32(bb.read(def: UOffset.self, position: bb.reader)) + Int32(bb.reader))) }

    private init(_ t: Table) { _accessor = t }
    public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }

    private enum VTOFFSET: VOffset {
        case id = 4
        case val = 6
        case count = 8
        var v: Int32 { Int32(self.rawValue) }
        var p: VOffset { self.rawValue }
    }

    public var id: String? { let o = _accessor.offset(VTOFFSET.id.v); return o == 0 ? nil : _accessor.string(at: o) }
    public var idSegmentArray: [UInt8]? { return _accessor.getVector(at: VTOFFSET.id.v) }
    public var val: Int64 { let o = _accessor.offset(VTOFFSET.val.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int64.self, at: o) }
    @discardableResult public func mutate(val: Int64) -> Bool {let o = _accessor.offset(VTOFFSET.val.v);  return _accessor.mutate(val, index: o) }
    public var count: UInt16 { let o = _accessor.offset(VTOFFSET.count.v); return o == 0 ? 0 : _accessor.readBuffer(of: UInt16.self, at: o) }
    @discardableResult public func mutate(count: UInt16) -> Bool {let o = _accessor.offset(VTOFFSET.count.v);  return _accessor.mutate(count, index: o) }
    public static func startStat(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 3) }
    public static func add(id: Offset<String>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: id, at: VTOFFSET.id.p)  }
    public static func add(val: Int64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: val, def: 0, at: VTOFFSET.val.p) }
    public static func add(count: UInt16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: count, def: 0, at: VTOFFSET.count.p) }
    public static func endStat(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); return end }
    public static func createStat(
        _ fbb: inout FlatBufferBuilder,
        offsetOfId id: Offset<String> = Offset(),
        val: Int64 = 0,
        count: UInt16 = 0
    ) -> Offset<UOffset> {
        let __start = MyGame_Example_Stat.startStat(&fbb)
        MyGame_Example_Stat.add(id: id, &fbb)
        MyGame_Example_Stat.add(val: val, &fbb)
        MyGame_Example_Stat.add(count: count, &fbb)
        return MyGame_Example_Stat.endStat(&fbb, start: __start)
    }
    

    public mutating func unpack() -> MyGame_Example_StatT {
        return MyGame_Example_StatT(&self)
    }
    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_StatT?) -> Offset<UOffset> {
        guard var obj = obj else { return Offset<UOffset>() }
        return pack(&builder, obj: &obj)
    }

    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_StatT) -> Offset<UOffset> {
        let __id: Offset<String>
        if let s = obj.id {
            __id = builder.create(string: s)
        } else {
            __id = Offset<String>()
        }

        let __root = MyGame_Example_Stat.startStat(&builder)
        MyGame_Example_Stat.add(id: __id, &builder)
        MyGame_Example_Stat.add(val: obj.val, &builder)
        MyGame_Example_Stat.add(count: obj.count, &builder)
        return MyGame_Example_Stat.endStat(&builder, start: __root)
    }
}

public class MyGame_Example_StatT: NativeTable {

    public var id: String?
    public var val: Int64
    public var count: UInt16

    public init(_ _t: inout MyGame_Example_Stat) {
        id = _t.id
        val = _t.val
        count = _t.count
    }

    public init() {
        val = 0
        count = 0
    }

    public func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_Stat.self) }

}
public struct MyGame_Example_Referrable: FlatBufferObject, ObjectAPI {

    static func validateVersion() { FlatBuffersVersion_1_12_0() }
    public var __buffer: ByteBuffer! { return _accessor.bb }
    private var _accessor: Table

    public static func finish(_ fbb: inout FlatBufferBuilder, end: Offset<UOffset>, prefix: Bool = false) { fbb.finish(offset: end, fileId: "MONS", addPrefix: prefix) }
    public static func getRootAsReferrable(bb: ByteBuffer) -> MyGame_Example_Referrable { return MyGame_Example_Referrable(Table(bb: bb, position: Int32(bb.read(def: UOffset.self, position: bb.reader)) + Int32(bb.reader))) }

    private init(_ t: Table) { _accessor = t }
    public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }

    private enum VTOFFSET: VOffset {
        case id = 4
        var v: Int32 { Int32(self.rawValue) }
        var p: VOffset { self.rawValue }
    }

    public var id: UInt64 { let o = _accessor.offset(VTOFFSET.id.v); return o == 0 ? 0 : _accessor.readBuffer(of: UInt64.self, at: o) }
    @discardableResult public func mutate(id: UInt64) -> Bool {let o = _accessor.offset(VTOFFSET.id.v);  return _accessor.mutate(id, index: o) }
    public static func startReferrable(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
    public static func add(id: UInt64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: id, def: 0, at: VTOFFSET.id.p) }
    public static func endReferrable(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); return end }
    public static func createReferrable(
        _ fbb: inout FlatBufferBuilder,
        id: UInt64 = 0
    ) -> Offset<UOffset> {
        let __start = MyGame_Example_Referrable.startReferrable(&fbb)
        MyGame_Example_Referrable.add(id: id, &fbb)
        return MyGame_Example_Referrable.endReferrable(&fbb, start: __start)
    }
    public static func sortVectorOfReferrable(offsets:[Offset<UOffset>], _ fbb: inout FlatBufferBuilder) -> Offset<UOffset> {
        var off = offsets
        off.sort { Table.compare(Table.offset(Int32($1.o), vOffset: 4, fbb: fbb.buffer), Table.offset(Int32($0.o), vOffset: 4, fbb: fbb.buffer), fbb: fbb.buffer) < 0 } 
        return fbb.createVector(ofOffsets: off)
    }
    fileprivate static func lookupByKey(vector: Int32, key: UInt64, fbb: ByteBuffer) -> MyGame_Example_Referrable? {
        var span = fbb.read(def: Int32.self, position: Int(vector - 4))
        var start: Int32 = 0
        while span != 0 {
            var middle = span / 2
            let tableOffset = Table.indirect(vector + 4 * (start + middle), fbb)
            let comp = fbb.read(def: UInt64.self, position: Int(Table.offset(Int32(fbb.capacity) - tableOffset, vOffset: 4, fbb: fbb)))
            if comp > 0 {
                span = middle
            } else if comp < 0 {
                middle += 1
                start += middle
                span -= middle
            } else {
                return MyGame_Example_Referrable(fbb, o: tableOffset)
            }
        }
        return nil
    }
    

    public mutating func unpack() -> MyGame_Example_ReferrableT {
        return MyGame_Example_ReferrableT(&self)
    }
    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_ReferrableT?) -> Offset<UOffset> {
        guard var obj = obj else { return Offset<UOffset>() }
        return pack(&builder, obj: &obj)
    }

    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_ReferrableT) -> Offset<UOffset> {
        let __root = MyGame_Example_Referrable.startReferrable(&builder)
        MyGame_Example_Referrable.add(id: obj.id, &builder)
        return MyGame_Example_Referrable.endReferrable(&builder, start: __root)
    }
}

public class MyGame_Example_ReferrableT: NativeTable {

    public var id: UInt64

    public init(_ _t: inout MyGame_Example_Referrable) {
        id = _t.id
    }

    public init() {
        id = 0
    }

    public func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_Referrable.self) }

}
///  an example documentation comment: "monster object"
public struct MyGame_Example_Monster: FlatBufferObject, ObjectAPI {

    static func validateVersion() { FlatBuffersVersion_1_12_0() }
    public var __buffer: ByteBuffer! { return _accessor.bb }
    private var _accessor: Table

    public static func finish(_ fbb: inout FlatBufferBuilder, end: Offset<UOffset>, prefix: Bool = false) { fbb.finish(offset: end, fileId: "MONS", addPrefix: prefix) }
    public static func getRootAsMonster(bb: ByteBuffer) -> MyGame_Example_Monster { return MyGame_Example_Monster(Table(bb: bb, position: Int32(bb.read(def: UOffset.self, position: bb.reader)) + Int32(bb.reader))) }

    private init(_ t: Table) { _accessor = t }
    public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }

    private enum VTOFFSET: VOffset {
        case pos = 4
        case mana = 6
        case hp = 8
        case name = 10
        case inventory = 14
        case color = 16
        case testType = 18
        case test = 20
        case test4 = 22
        case testarrayofstring = 24
        case testarrayoftables = 26
        case enemy = 28
        case testnestedflatbuffer = 30
        case testempty = 32
        case testbool = 34
        case testhashs32Fnv1 = 36
        case testhashu32Fnv1 = 38
        case testhashs64Fnv1 = 40
        case testhashu64Fnv1 = 42
        case testhashs32Fnv1a = 44
        case testhashu32Fnv1a = 46
        case testhashs64Fnv1a = 48
        case testhashu64Fnv1a = 50
        case testarrayofbools = 52
        case testf = 54
        case testf2 = 56
        case testf3 = 58
        case testarrayofstring2 = 60
        case testarrayofsortedstruct = 62
        case flex = 64
        case test5 = 66
        case vectorOfLongs = 68
        case vectorOfDoubles = 70
        case parentNamespaceTest = 72
        case vectorOfReferrables = 74
        case singleWeakReference = 76
        case vectorOfWeakReferences = 78
        case vectorOfStrongReferrables = 80
        case coOwningReference = 82
        case vectorOfCoOwningReferences = 84
        case nonOwningReference = 86
        case vectorOfNonOwningReferences = 88
        case anyUniqueType = 90
        case anyUnique = 92
        case anyAmbiguousType = 94
        case anyAmbiguous = 96
        case vectorOfEnums = 98
        case signedEnum = 100
        var v: Int32 { Int32(self.rawValue) }
        var p: VOffset { self.rawValue }
    }

    public var pos: MyGame_Example_Vec3? { let o = _accessor.offset(VTOFFSET.pos.v); return o == 0 ? nil : MyGame_Example_Vec3(_accessor.bb, o: o + _accessor.postion) }
    public var mana: Int16 { let o = _accessor.offset(VTOFFSET.mana.v); return o == 0 ? 150 : _accessor.readBuffer(of: Int16.self, at: o) }
    @discardableResult public func mutate(mana: Int16) -> Bool {let o = _accessor.offset(VTOFFSET.mana.v);  return _accessor.mutate(mana, index: o) }
    public var hp: Int16 { let o = _accessor.offset(VTOFFSET.hp.v); return o == 0 ? 100 : _accessor.readBuffer(of: Int16.self, at: o) }
    @discardableResult public func mutate(hp: Int16) -> Bool {let o = _accessor.offset(VTOFFSET.hp.v);  return _accessor.mutate(hp, index: o) }
    public var name: String! { let o = _accessor.offset(VTOFFSET.name.v); return _accessor.string(at: o) }
    public var nameSegmentArray: [UInt8]! { return _accessor.getVector(at: VTOFFSET.name.v) }
    public var inventoryCount: Int32 { let o = _accessor.offset(VTOFFSET.inventory.v); return o == 0 ? 0 : _accessor.vector(count: o) }
    public func inventory(at index: Int32) -> UInt8 { let o = _accessor.offset(VTOFFSET.inventory.v); return o == 0 ? 0 : _accessor.directRead(of: UInt8.self, offset: _accessor.vector(at: o) + index * 1) }
    public var inventory: [UInt8] { return _accessor.getVector(at: VTOFFSET.inventory.v) ?? [] }
    public func mutate(inventory: UInt8, at index: Int32) -> Bool { let o = _accessor.offset(VTOFFSET.inventory.v); return _accessor.directMutate(inventory, index: _accessor.vector(at: o) + index * 1) }
    public var color: MyGame_Example_Color { let o = _accessor.offset(VTOFFSET.color.v); return o == 0 ? .blue : MyGame_Example_Color(rawValue: _accessor.readBuffer(of: UInt8.self, at: o)) ?? .blue }
    @discardableResult public func mutate(color: MyGame_Example_Color) -> Bool {let o = _accessor.offset(VTOFFSET.color.v);  return _accessor.mutate(color.rawValue, index: o) }
    public var testType: MyGame_Example_Any_ { let o = _accessor.offset(VTOFFSET.testType.v); return o == 0 ? .none_ : MyGame_Example_Any_(rawValue: _accessor.readBuffer(of: UInt8.self, at: o)) ?? .none_ }
    public func test<T: FlatBufferObject>(type: T.Type) -> T? { let o = _accessor.offset(VTOFFSET.test.v); return o == 0 ? nil : _accessor.union(o) }
    public var test4Count: Int32 { let o = _accessor.offset(VTOFFSET.test4.v); return o == 0 ? 0 : _accessor.vector(count: o) }
    public func test4(at index: Int32) -> MyGame_Example_Test? { let o = _accessor.offset(VTOFFSET.test4.v); return o == 0 ? nil : MyGame_Example_Test(_accessor.bb, o: _accessor.vector(at: o) + index * 4) }
    public var testarrayofstringCount: Int32 { let o = _accessor.offset(VTOFFSET.testarrayofstring.v); return o == 0 ? 0 : _accessor.vector(count: o) }
    public func testarrayofstring(at index: Int32) -> String? { let o = _accessor.offset(VTOFFSET.testarrayofstring.v); return o == 0 ? nil : _accessor.directString(at: _accessor.vector(at: o) + index * 4) }
    ///  an example documentation comment: this will end up in the generated code
    ///  multiline too
    public var testarrayoftablesCount: Int32 { let o = _accessor.offset(VTOFFSET.testarrayoftables.v); return o == 0 ? 0 : _accessor.vector(count: o) }
    public func testarrayoftables(at index: Int32) -> MyGame_Example_Monster? { let o = _accessor.offset(VTOFFSET.testarrayoftables.v); return o == 0 ? nil : MyGame_Example_Monster(_accessor.bb, o: _accessor.indirect(_accessor.vector(at: o) + index * 4)) }
    public func testarrayoftablesBy(key: String) -> MyGame_Example_Monster? { let o = _accessor.offset(VTOFFSET.testarrayoftables.v); return o == 0 ? nil : MyGame_Example_Monster.lookupByKey(vector: _accessor.vector(at: o), key: key, fbb: _accessor.bb) }
    public var enemy: MyGame_Example_Monster? { let o = _accessor.offset(VTOFFSET.enemy.v); return o == 0 ? nil : MyGame_Example_Monster(_accessor.bb, o: _accessor.indirect(o + _accessor.postion)) }
    public var testnestedflatbufferCount: Int32 { let o = _accessor.offset(VTOFFSET.testnestedflatbuffer.v); return o == 0 ? 0 : _accessor.vector(count: o) }
    public func testnestedflatbuffer(at index: Int32) -> UInt8 { let o = _accessor.offset(VTOFFSET.testnestedflatbuffer.v); return o == 0 ? 0 : _accessor.directRead(of: UInt8.self, offset: _accessor.vector(at: o) + index * 1) }
    public var testnestedflatbuffer: [UInt8] { return _accessor.getVector(at: VTOFFSET.testnestedflatbuffer.v) ?? [] }
    public func mutate(testnestedflatbuffer: UInt8, at index: Int32) -> Bool { let o = _accessor.offset(VTOFFSET.testnestedflatbuffer.v); return _accessor.directMutate(testnestedflatbuffer, index: _accessor.vector(at: o) + index * 1) }
    public var testempty: MyGame_Example_Stat? { let o = _accessor.offset(VTOFFSET.testempty.v); return o == 0 ? nil : MyGame_Example_Stat(_accessor.bb, o: _accessor.indirect(o + _accessor.postion)) }
    public var testbool: Bool { let o = _accessor.offset(VTOFFSET.testbool.v); return o == 0 ? false : 0 != _accessor.readBuffer(of: Byte.self, at: o) }
    @discardableResult public func mutate(testbool: Byte) -> Bool {let o = _accessor.offset(VTOFFSET.testbool.v);  return _accessor.mutate(testbool, index: o) }
    public var testhashs32Fnv1: Int32 { let o = _accessor.offset(VTOFFSET.testhashs32Fnv1.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int32.self, at: o) }
    @discardableResult public func mutate(testhashs32Fnv1: Int32) -> Bool {let o = _accessor.offset(VTOFFSET.testhashs32Fnv1.v);  return _accessor.mutate(testhashs32Fnv1, index: o) }
    public var testhashu32Fnv1: UInt32 { let o = _accessor.offset(VTOFFSET.testhashu32Fnv1.v); return o == 0 ? 0 : _accessor.readBuffer(of: UInt32.self, at: o) }
    @discardableResult public func mutate(testhashu32Fnv1: UInt32) -> Bool {let o = _accessor.offset(VTOFFSET.testhashu32Fnv1.v);  return _accessor.mutate(testhashu32Fnv1, index: o) }
    public var testhashs64Fnv1: Int64 { let o = _accessor.offset(VTOFFSET.testhashs64Fnv1.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int64.self, at: o) }
    @discardableResult public func mutate(testhashs64Fnv1: Int64) -> Bool {let o = _accessor.offset(VTOFFSET.testhashs64Fnv1.v);  return _accessor.mutate(testhashs64Fnv1, index: o) }
    public var testhashu64Fnv1: UInt64 { let o = _accessor.offset(VTOFFSET.testhashu64Fnv1.v); return o == 0 ? 0 : _accessor.readBuffer(of: UInt64.self, at: o) }
    @discardableResult public func mutate(testhashu64Fnv1: UInt64) -> Bool {let o = _accessor.offset(VTOFFSET.testhashu64Fnv1.v);  return _accessor.mutate(testhashu64Fnv1, index: o) }
    public var testhashs32Fnv1a: Int32 { let o = _accessor.offset(VTOFFSET.testhashs32Fnv1a.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int32.self, at: o) }
    @discardableResult public func mutate(testhashs32Fnv1a: Int32) -> Bool {let o = _accessor.offset(VTOFFSET.testhashs32Fnv1a.v);  return _accessor.mutate(testhashs32Fnv1a, index: o) }
    public var testhashu32Fnv1a: UInt32 { let o = _accessor.offset(VTOFFSET.testhashu32Fnv1a.v); return o == 0 ? 0 : _accessor.readBuffer(of: UInt32.self, at: o) }
    @discardableResult public func mutate(testhashu32Fnv1a: UInt32) -> Bool {let o = _accessor.offset(VTOFFSET.testhashu32Fnv1a.v);  return _accessor.mutate(testhashu32Fnv1a, index: o) }
    public var testhashs64Fnv1a: Int64 { let o = _accessor.offset(VTOFFSET.testhashs64Fnv1a.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int64.self, at: o) }
    @discardableResult public func mutate(testhashs64Fnv1a: Int64) -> Bool {let o = _accessor.offset(VTOFFSET.testhashs64Fnv1a.v);  return _accessor.mutate(testhashs64Fnv1a, index: o) }
    public var testhashu64Fnv1a: UInt64 { let o = _accessor.offset(VTOFFSET.testhashu64Fnv1a.v); return o == 0 ? 0 : _accessor.readBuffer(of: UInt64.self, at: o) }
    @discardableResult public func mutate(testhashu64Fnv1a: UInt64) -> Bool {let o = _accessor.offset(VTOFFSET.testhashu64Fnv1a.v);  return _accessor.mutate(testhashu64Fnv1a, index: o) }
    public var testarrayofboolsCount: Int32 { let o = _accessor.offset(VTOFFSET.testarrayofbools.v); return o == 0 ? 0 : _accessor.vector(count: o) }
    public func testarrayofbools(at index: Int32) -> Bool { let o = _accessor.offset(VTOFFSET.testarrayofbools.v); return o == 0 ? true : 0 != _accessor.directRead(of: Byte.self, offset: _accessor.vector(at: o) + index * 1) }
    public var testarrayofbools: [Byte] { return _accessor.getVector(at: VTOFFSET.testarrayofbools.v) ?? [] }
    public func mutate(testarrayofbools: Byte, at index: Int32) -> Bool { let o = _accessor.offset(VTOFFSET.testarrayofbools.v); return _accessor.directMutate(testarrayofbools, index: _accessor.vector(at: o) + index * 1) }
    public var testf: Float32 { let o = _accessor.offset(VTOFFSET.testf.v); return o == 0 ? 3.14159 : _accessor.readBuffer(of: Float32.self, at: o) }
    @discardableResult public func mutate(testf: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.testf.v);  return _accessor.mutate(testf, index: o) }
    public var testf2: Float32 { let o = _accessor.offset(VTOFFSET.testf2.v); return o == 0 ? 3.0 : _accessor.readBuffer(of: Float32.self, at: o) }
    @discardableResult public func mutate(testf2: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.testf2.v);  return _accessor.mutate(testf2, index: o) }
    public var testf3: Float32 { let o = _accessor.offset(VTOFFSET.testf3.v); return o == 0 ? 0.0 : _accessor.readBuffer(of: Float32.self, at: o) }
    @discardableResult public func mutate(testf3: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.testf3.v);  return _accessor.mutate(testf3, index: o) }
    public var testarrayofstring2Count: Int32 { let o = _accessor.offset(VTOFFSET.testarrayofstring2.v); return o == 0 ? 0 : _accessor.vector(count: o) }
    public func testarrayofstring2(at index: Int32) -> String? { let o = _accessor.offset(VTOFFSET.testarrayofstring2.v); return o == 0 ? nil : _accessor.directString(at: _accessor.vector(at: o) + index * 4) }
    public var testarrayofsortedstructCount: Int32 { let o = _accessor.offset(VTOFFSET.testarrayofsortedstruct.v); return o == 0 ? 0 : _accessor.vector(count: o) }
    public func testarrayofsortedstruct(at index: Int32) -> MyGame_Example_Ability? { let o = _accessor.offset(VTOFFSET.testarrayofsortedstruct.v); return o == 0 ? nil : MyGame_Example_Ability(_accessor.bb, o: _accessor.vector(at: o) + index * 8) }
    public var flexCount: Int32 { let o = _accessor.offset(VTOFFSET.flex.v); return o == 0 ? 0 : _accessor.vector(count: o) }
    public func flex(at index: Int32) -> UInt8 { let o = _accessor.offset(VTOFFSET.flex.v); return o == 0 ? 0 : _accessor.directRead(of: UInt8.self, offset: _accessor.vector(at: o) + index * 1) }
    public var flex: [UInt8] { return _accessor.getVector(at: VTOFFSET.flex.v) ?? [] }
    public func mutate(flex: UInt8, at index: Int32) -> Bool { let o = _accessor.offset(VTOFFSET.flex.v); return _accessor.directMutate(flex, index: _accessor.vector(at: o) + index * 1) }
    public var test5Count: Int32 { let o = _accessor.offset(VTOFFSET.test5.v); return o == 0 ? 0 : _accessor.vector(count: o) }
    public func test5(at index: Int32) -> MyGame_Example_Test? { let o = _accessor.offset(VTOFFSET.test5.v); return o == 0 ? nil : MyGame_Example_Test(_accessor.bb, o: _accessor.vector(at: o) + index * 4) }
    public var vectorOfLongsCount: Int32 { let o = _accessor.offset(VTOFFSET.vectorOfLongs.v); return o == 0 ? 0 : _accessor.vector(count: o) }
    public func vectorOfLongs(at index: Int32) -> Int64 { let o = _accessor.offset(VTOFFSET.vectorOfLongs.v); return o == 0 ? 0 : _accessor.directRead(of: Int64.self, offset: _accessor.vector(at: o) + index * 8) }
    public var vectorOfLongs: [Int64] { return _accessor.getVector(at: VTOFFSET.vectorOfLongs.v) ?? [] }
    public func mutate(vectorOfLongs: Int64, at index: Int32) -> Bool { let o = _accessor.offset(VTOFFSET.vectorOfLongs.v); return _accessor.directMutate(vectorOfLongs, index: _accessor.vector(at: o) + index * 8) }
    public var vectorOfDoublesCount: Int32 { let o = _accessor.offset(VTOFFSET.vectorOfDoubles.v); return o == 0 ? 0 : _accessor.vector(count: o) }
    public func vectorOfDoubles(at index: Int32) -> Double { let o = _accessor.offset(VTOFFSET.vectorOfDoubles.v); return o == 0 ? 0 : _accessor.directRead(of: Double.self, offset: _accessor.vector(at: o) + index * 8) }
    public var vectorOfDoubles: [Double] { return _accessor.getVector(at: VTOFFSET.vectorOfDoubles.v) ?? [] }
    public func mutate(vectorOfDoubles: Double, at index: Int32) -> Bool { let o = _accessor.offset(VTOFFSET.vectorOfDoubles.v); return _accessor.directMutate(vectorOfDoubles, index: _accessor.vector(at: o) + index * 8) }
    public var parentNamespaceTest: MyGame_InParentNamespace? { let o = _accessor.offset(VTOFFSET.parentNamespaceTest.v); return o == 0 ? nil : MyGame_InParentNamespace(_accessor.bb, o: _accessor.indirect(o + _accessor.postion)) }
    public var vectorOfReferrablesCount: Int32 { let o = _accessor.offset(VTOFFSET.vectorOfReferrables.v); return o == 0 ? 0 : _accessor.vector(count: o) }
    public func vectorOfReferrables(at index: Int32) -> MyGame_Example_Referrable? { let o = _accessor.offset(VTOFFSET.vectorOfReferrables.v); return o == 0 ? nil : MyGame_Example_Referrable(_accessor.bb, o: _accessor.indirect(_accessor.vector(at: o) + index * 4)) }
    public func vectorOfReferrablesBy(key: UInt64) -> MyGame_Example_Referrable? { let o = _accessor.offset(VTOFFSET.vectorOfReferrables.v); return o == 0 ? nil : MyGame_Example_Referrable.lookupByKey(vector: _accessor.vector(at: o), key: key, fbb: _accessor.bb) }
    public var singleWeakReference: UInt64 { let o = _accessor.offset(VTOFFSET.singleWeakReference.v); return o == 0 ? 0 : _accessor.readBuffer(of: UInt64.self, at: o) }
    @discardableResult public func mutate(singleWeakReference: UInt64) -> Bool {let o = _accessor.offset(VTOFFSET.singleWeakReference.v);  return _accessor.mutate(singleWeakReference, index: o) }
    public var vectorOfWeakReferencesCount: Int32 { let o = _accessor.offset(VTOFFSET.vectorOfWeakReferences.v); return o == 0 ? 0 : _accessor.vector(count: o) }
    public func vectorOfWeakReferences(at index: Int32) -> UInt64 { let o = _accessor.offset(VTOFFSET.vectorOfWeakReferences.v); return o == 0 ? 0 : _accessor.directRead(of: UInt64.self, offset: _accessor.vector(at: o) + index * 8) }
    public var vectorOfWeakReferences: [UInt64] { return _accessor.getVector(at: VTOFFSET.vectorOfWeakReferences.v) ?? [] }
    public func mutate(vectorOfWeakReferences: UInt64, at index: Int32) -> Bool { let o = _accessor.offset(VTOFFSET.vectorOfWeakReferences.v); return _accessor.directMutate(vectorOfWeakReferences, index: _accessor.vector(at: o) + index * 8) }
    public var vectorOfStrongReferrablesCount: Int32 { let o = _accessor.offset(VTOFFSET.vectorOfStrongReferrables.v); return o == 0 ? 0 : _accessor.vector(count: o) }
    public func vectorOfStrongReferrables(at index: Int32) -> MyGame_Example_Referrable? { let o = _accessor.offset(VTOFFSET.vectorOfStrongReferrables.v); return o == 0 ? nil : MyGame_Example_Referrable(_accessor.bb, o: _accessor.indirect(_accessor.vector(at: o) + index * 4)) }
    public func vectorOfStrongReferrablesBy(key: UInt64) -> MyGame_Example_Referrable? { let o = _accessor.offset(VTOFFSET.vectorOfStrongReferrables.v); return o == 0 ? nil : MyGame_Example_Referrable.lookupByKey(vector: _accessor.vector(at: o), key: key, fbb: _accessor.bb) }
    public var coOwningReference: UInt64 { let o = _accessor.offset(VTOFFSET.coOwningReference.v); return o == 0 ? 0 : _accessor.readBuffer(of: UInt64.self, at: o) }
    @discardableResult public func mutate(coOwningReference: UInt64) -> Bool {let o = _accessor.offset(VTOFFSET.coOwningReference.v);  return _accessor.mutate(coOwningReference, index: o) }
    public var vectorOfCoOwningReferencesCount: Int32 { let o = _accessor.offset(VTOFFSET.vectorOfCoOwningReferences.v); return o == 0 ? 0 : _accessor.vector(count: o) }
    public func vectorOfCoOwningReferences(at index: Int32) -> UInt64 { let o = _accessor.offset(VTOFFSET.vectorOfCoOwningReferences.v); return o == 0 ? 0 : _accessor.directRead(of: UInt64.self, offset: _accessor.vector(at: o) + index * 8) }
    public var vectorOfCoOwningReferences: [UInt64] { return _accessor.getVector(at: VTOFFSET.vectorOfCoOwningReferences.v) ?? [] }
    public func mutate(vectorOfCoOwningReferences: UInt64, at index: Int32) -> Bool { let o = _accessor.offset(VTOFFSET.vectorOfCoOwningReferences.v); return _accessor.directMutate(vectorOfCoOwningReferences, index: _accessor.vector(at: o) + index * 8) }
    public var nonOwningReference: UInt64 { let o = _accessor.offset(VTOFFSET.nonOwningReference.v); return o == 0 ? 0 : _accessor.readBuffer(of: UInt64.self, at: o) }
    @discardableResult public func mutate(nonOwningReference: UInt64) -> Bool {let o = _accessor.offset(VTOFFSET.nonOwningReference.v);  return _accessor.mutate(nonOwningReference, index: o) }
    public var vectorOfNonOwningReferencesCount: Int32 { let o = _accessor.offset(VTOFFSET.vectorOfNonOwningReferences.v); return o == 0 ? 0 : _accessor.vector(count: o) }
    public func vectorOfNonOwningReferences(at index: Int32) -> UInt64 { let o = _accessor.offset(VTOFFSET.vectorOfNonOwningReferences.v); return o == 0 ? 0 : _accessor.directRead(of: UInt64.self, offset: _accessor.vector(at: o) + index * 8) }
    public var vectorOfNonOwningReferences: [UInt64] { return _accessor.getVector(at: VTOFFSET.vectorOfNonOwningReferences.v) ?? [] }
    public func mutate(vectorOfNonOwningReferences: UInt64, at index: Int32) -> Bool { let o = _accessor.offset(VTOFFSET.vectorOfNonOwningReferences.v); return _accessor.directMutate(vectorOfNonOwningReferences, index: _accessor.vector(at: o) + index * 8) }
    public var anyUniqueType: MyGame_Example_AnyUniqueAliases { let o = _accessor.offset(VTOFFSET.anyUniqueType.v); return o == 0 ? .none_ : MyGame_Example_AnyUniqueAliases(rawValue: _accessor.readBuffer(of: UInt8.self, at: o)) ?? .none_ }
    public func anyUnique<T: FlatBufferObject>(type: T.Type) -> T? { let o = _accessor.offset(VTOFFSET.anyUnique.v); return o == 0 ? nil : _accessor.union(o) }
    public var anyAmbiguousType: MyGame_Example_AnyAmbiguousAliases { let o = _accessor.offset(VTOFFSET.anyAmbiguousType.v); return o == 0 ? .none_ : MyGame_Example_AnyAmbiguousAliases(rawValue: _accessor.readBuffer(of: UInt8.self, at: o)) ?? .none_ }
    public func anyAmbiguous<T: FlatBufferObject>(type: T.Type) -> T? { let o = _accessor.offset(VTOFFSET.anyAmbiguous.v); return o == 0 ? nil : _accessor.union(o) }
    public var vectorOfEnumsCount: Int32 { let o = _accessor.offset(VTOFFSET.vectorOfEnums.v); return o == 0 ? 0 : _accessor.vector(count: o) }
    public func vectorOfEnums(at index: Int32) -> MyGame_Example_Color? { let o = _accessor.offset(VTOFFSET.vectorOfEnums.v); return o == 0 ? MyGame_Example_Color.red : MyGame_Example_Color(rawValue: _accessor.directRead(of: UInt8.self, offset: _accessor.vector(at: o) + index * 1)) }
    public var signedEnum: MyGame_Example_Race { let o = _accessor.offset(VTOFFSET.signedEnum.v); return o == 0 ? .none_ : MyGame_Example_Race(rawValue: _accessor.readBuffer(of: Int8.self, at: o)) ?? .none_ }
    @discardableResult public func mutate(signedEnum: MyGame_Example_Race) -> Bool {let o = _accessor.offset(VTOFFSET.signedEnum.v);  return _accessor.mutate(signedEnum.rawValue, index: o) }
    public static func startMonster(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 49) }
    public static func add(pos: UnsafeMutableRawPointer?, _ fbb: inout FlatBufferBuilder) { guard let pos = pos else { return }; fbb.create(struct: pos, type: MyGame_Example_Vec3.self); fbb.add(structOffset: VTOFFSET.pos.p) }
    public static func add(mana: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: mana, def: 150, at: VTOFFSET.mana.p) }
    public static func add(hp: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: hp, def: 100, at: VTOFFSET.hp.p) }
    public static func add(name: Offset<String>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: name, at: VTOFFSET.name.p)  }
    public static func addVectorOf(inventory: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: inventory, at: VTOFFSET.inventory.p)  }
    public static func add(color: MyGame_Example_Color, _ fbb: inout FlatBufferBuilder) { fbb.add(element: color.rawValue, def: 8, at: VTOFFSET.color.p) }
    public static func add(testType: MyGame_Example_Any_, _ fbb: inout FlatBufferBuilder) { fbb.add(element: testType.rawValue, def: 0, at: VTOFFSET.testType.p) }
    public static func add(test: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: test, at: VTOFFSET.test.p)  }
    public static func addVectorOf(test4: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: test4, at: VTOFFSET.test4.p)  }
    public static func addVectorOf(testarrayofstring: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: testarrayofstring, at: VTOFFSET.testarrayofstring.p)  }
    public static func addVectorOf(testarrayoftables: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: testarrayoftables, at: VTOFFSET.testarrayoftables.p)  }
    public static func add(enemy: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: enemy, at: VTOFFSET.enemy.p)  }
    public static func addVectorOf(testnestedflatbuffer: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: testnestedflatbuffer, at: VTOFFSET.testnestedflatbuffer.p)  }
    public static func add(testempty: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: testempty, at: VTOFFSET.testempty.p)  }
    public static func add(testbool: Bool, _ fbb: inout FlatBufferBuilder) { fbb.add(element: testbool, def: false,
     at: VTOFFSET.testbool.p) }
    public static func add(testhashs32Fnv1: Int32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: testhashs32Fnv1, def: 0, at: VTOFFSET.testhashs32Fnv1.p) }
    public static func add(testhashu32Fnv1: UInt32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: testhashu32Fnv1, def: 0, at: VTOFFSET.testhashu32Fnv1.p) }
    public static func add(testhashs64Fnv1: Int64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: testhashs64Fnv1, def: 0, at: VTOFFSET.testhashs64Fnv1.p) }
    public static func add(testhashu64Fnv1: UInt64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: testhashu64Fnv1, def: 0, at: VTOFFSET.testhashu64Fnv1.p) }
    public static func add(testhashs32Fnv1a: Int32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: testhashs32Fnv1a, def: 0, at: VTOFFSET.testhashs32Fnv1a.p) }
    public static func add(testhashu32Fnv1a: UInt32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: testhashu32Fnv1a, def: 0, at: VTOFFSET.testhashu32Fnv1a.p) }
    public static func add(testhashs64Fnv1a: Int64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: testhashs64Fnv1a, def: 0, at: VTOFFSET.testhashs64Fnv1a.p) }
    public static func add(testhashu64Fnv1a: UInt64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: testhashu64Fnv1a, def: 0, at: VTOFFSET.testhashu64Fnv1a.p) }
    public static func addVectorOf(testarrayofbools: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: testarrayofbools, at: VTOFFSET.testarrayofbools.p)  }
    public static func add(testf: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: testf, def: 3.14159, at: VTOFFSET.testf.p) }
    public static func add(testf2: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: testf2, def: 3.0, at: VTOFFSET.testf2.p) }
    public static func add(testf3: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: testf3, def: 0.0, at: VTOFFSET.testf3.p) }
    public static func addVectorOf(testarrayofstring2: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: testarrayofstring2, at: VTOFFSET.testarrayofstring2.p)  }
    public static func addVectorOf(testarrayofsortedstruct: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: testarrayofsortedstruct, at: VTOFFSET.testarrayofsortedstruct.p)  }
    public static func addVectorOf(flex: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: flex, at: VTOFFSET.flex.p)  }
    public static func addVectorOf(test5: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: test5, at: VTOFFSET.test5.p)  }
    public static func addVectorOf(vectorOfLongs: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: vectorOfLongs, at: VTOFFSET.vectorOfLongs.p)  }
    public static func addVectorOf(vectorOfDoubles: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: vectorOfDoubles, at: VTOFFSET.vectorOfDoubles.p)  }
    public static func add(parentNamespaceTest: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: parentNamespaceTest, at: VTOFFSET.parentNamespaceTest.p)  }
    public static func addVectorOf(vectorOfReferrables: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: vectorOfReferrables, at: VTOFFSET.vectorOfReferrables.p)  }
    public static func add(singleWeakReference: UInt64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: singleWeakReference, def: 0, at: VTOFFSET.singleWeakReference.p) }
    public static func addVectorOf(vectorOfWeakReferences: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: vectorOfWeakReferences, at: VTOFFSET.vectorOfWeakReferences.p)  }
    public static func addVectorOf(vectorOfStrongReferrables: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: vectorOfStrongReferrables, at: VTOFFSET.vectorOfStrongReferrables.p)  }
    public static func add(coOwningReference: UInt64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: coOwningReference, def: 0, at: VTOFFSET.coOwningReference.p) }
    public static func addVectorOf(vectorOfCoOwningReferences: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: vectorOfCoOwningReferences, at: VTOFFSET.vectorOfCoOwningReferences.p)  }
    public static func add(nonOwningReference: UInt64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: nonOwningReference, def: 0, at: VTOFFSET.nonOwningReference.p) }
    public static func addVectorOf(vectorOfNonOwningReferences: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: vectorOfNonOwningReferences, at: VTOFFSET.vectorOfNonOwningReferences.p)  }
    public static func add(anyUniqueType: MyGame_Example_AnyUniqueAliases, _ fbb: inout FlatBufferBuilder) { fbb.add(element: anyUniqueType.rawValue, def: 0, at: VTOFFSET.anyUniqueType.p) }
    public static func add(anyUnique: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: anyUnique, at: VTOFFSET.anyUnique.p)  }
    public static func add(anyAmbiguousType: MyGame_Example_AnyAmbiguousAliases, _ fbb: inout FlatBufferBuilder) { fbb.add(element: anyAmbiguousType.rawValue, def: 0, at: VTOFFSET.anyAmbiguousType.p) }
    public static func add(anyAmbiguous: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: anyAmbiguous, at: VTOFFSET.anyAmbiguous.p)  }
    public static func addVectorOf(vectorOfEnums: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: vectorOfEnums, at: VTOFFSET.vectorOfEnums.p)  }
    public static func add(signedEnum: MyGame_Example_Race, _ fbb: inout FlatBufferBuilder) { fbb.add(element: signedEnum.rawValue, def: -1, at: VTOFFSET.signedEnum.p) }
    public static func endMonster(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); fbb.require(table: end, fields: [10]); return end }
    public static func createMonster(
        _ fbb: inout FlatBufferBuilder,
        structOfPos pos: UnsafeMutableRawPointer? = nil,
        mana: Int16 = 150,
        hp: Int16 = 100,
        offsetOfName name: Offset<String> = Offset(),
        vectorOfInventory inventory: Offset<UOffset> = Offset(),
        color: MyGame_Example_Color = .blue,
        testType: MyGame_Example_Any_ = .none_,
        offsetOfTest test: Offset<UOffset> = Offset(),
        vectorOfTest4 test4: Offset<UOffset> = Offset(),
        vectorOfTestarrayofstring testarrayofstring: Offset<UOffset> = Offset(),
        vectorOfTestarrayoftables testarrayoftables: Offset<UOffset> = Offset(),
        offsetOfEnemy enemy: Offset<UOffset> = Offset(),
        vectorOfTestnestedflatbuffer testnestedflatbuffer: Offset<UOffset> = Offset(),
        offsetOfTestempty testempty: Offset<UOffset> = Offset(),
        testbool: Bool = false,
        testhashs32Fnv1: Int32 = 0,
        testhashu32Fnv1: UInt32 = 0,
        testhashs64Fnv1: Int64 = 0,
        testhashu64Fnv1: UInt64 = 0,
        testhashs32Fnv1a: Int32 = 0,
        testhashu32Fnv1a: UInt32 = 0,
        testhashs64Fnv1a: Int64 = 0,
        testhashu64Fnv1a: UInt64 = 0,
        vectorOfTestarrayofbools testarrayofbools: Offset<UOffset> = Offset(),
        testf: Float32 = 3.14159,
        testf2: Float32 = 3.0,
        testf3: Float32 = 0.0,
        vectorOfTestarrayofstring2 testarrayofstring2: Offset<UOffset> = Offset(),
        vectorOfTestarrayofsortedstruct testarrayofsortedstruct: Offset<UOffset> = Offset(),
        vectorOfFlex flex: Offset<UOffset> = Offset(),
        vectorOfTest5 test5: Offset<UOffset> = Offset(),
        vectorOfVectorOfLongs vectorOfLongs: Offset<UOffset> = Offset(),
        vectorOfVectorOfDoubles vectorOfDoubles: Offset<UOffset> = Offset(),
        offsetOfParentNamespaceTest parentNamespaceTest: Offset<UOffset> = Offset(),
        vectorOfVectorOfReferrables vectorOfReferrables: Offset<UOffset> = Offset(),
        singleWeakReference: UInt64 = 0,
        vectorOfVectorOfWeakReferences vectorOfWeakReferences: Offset<UOffset> = Offset(),
        vectorOfVectorOfStrongReferrables vectorOfStrongReferrables: Offset<UOffset> = Offset(),
        coOwningReference: UInt64 = 0,
        vectorOfVectorOfCoOwningReferences vectorOfCoOwningReferences: Offset<UOffset> = Offset(),
        nonOwningReference: UInt64 = 0,
        vectorOfVectorOfNonOwningReferences vectorOfNonOwningReferences: Offset<UOffset> = Offset(),
        anyUniqueType: MyGame_Example_AnyUniqueAliases = .none_,
        offsetOfAnyUnique anyUnique: Offset<UOffset> = Offset(),
        anyAmbiguousType: MyGame_Example_AnyAmbiguousAliases = .none_,
        offsetOfAnyAmbiguous anyAmbiguous: Offset<UOffset> = Offset(),
        vectorOfVectorOfEnums vectorOfEnums: Offset<UOffset> = Offset(),
        signedEnum: MyGame_Example_Race = .none_
    ) -> Offset<UOffset> {
        let __start = MyGame_Example_Monster.startMonster(&fbb)
        MyGame_Example_Monster.add(pos: pos, &fbb)
        MyGame_Example_Monster.add(mana: mana, &fbb)
        MyGame_Example_Monster.add(hp: hp, &fbb)
        MyGame_Example_Monster.add(name: name, &fbb)
        MyGame_Example_Monster.addVectorOf(inventory: inventory, &fbb)
        MyGame_Example_Monster.add(color: color, &fbb)
        MyGame_Example_Monster.add(testType: testType, &fbb)
        MyGame_Example_Monster.add(test: test, &fbb)
        MyGame_Example_Monster.addVectorOf(test4: test4, &fbb)
        MyGame_Example_Monster.addVectorOf(testarrayofstring: testarrayofstring, &fbb)
        MyGame_Example_Monster.addVectorOf(testarrayoftables: testarrayoftables, &fbb)
        MyGame_Example_Monster.add(enemy: enemy, &fbb)
        MyGame_Example_Monster.addVectorOf(testnestedflatbuffer: testnestedflatbuffer, &fbb)
        MyGame_Example_Monster.add(testempty: testempty, &fbb)
        MyGame_Example_Monster.add(testbool: testbool, &fbb)
        MyGame_Example_Monster.add(testhashs32Fnv1: testhashs32Fnv1, &fbb)
        MyGame_Example_Monster.add(testhashu32Fnv1: testhashu32Fnv1, &fbb)
        MyGame_Example_Monster.add(testhashs64Fnv1: testhashs64Fnv1, &fbb)
        MyGame_Example_Monster.add(testhashu64Fnv1: testhashu64Fnv1, &fbb)
        MyGame_Example_Monster.add(testhashs32Fnv1a: testhashs32Fnv1a, &fbb)
        MyGame_Example_Monster.add(testhashu32Fnv1a: testhashu32Fnv1a, &fbb)
        MyGame_Example_Monster.add(testhashs64Fnv1a: testhashs64Fnv1a, &fbb)
        MyGame_Example_Monster.add(testhashu64Fnv1a: testhashu64Fnv1a, &fbb)
        MyGame_Example_Monster.addVectorOf(testarrayofbools: testarrayofbools, &fbb)
        MyGame_Example_Monster.add(testf: testf, &fbb)
        MyGame_Example_Monster.add(testf2: testf2, &fbb)
        MyGame_Example_Monster.add(testf3: testf3, &fbb)
        MyGame_Example_Monster.addVectorOf(testarrayofstring2: testarrayofstring2, &fbb)
        MyGame_Example_Monster.addVectorOf(testarrayofsortedstruct: testarrayofsortedstruct, &fbb)
        MyGame_Example_Monster.addVectorOf(flex: flex, &fbb)
        MyGame_Example_Monster.addVectorOf(test5: test5, &fbb)
        MyGame_Example_Monster.addVectorOf(vectorOfLongs: vectorOfLongs, &fbb)
        MyGame_Example_Monster.addVectorOf(vectorOfDoubles: vectorOfDoubles, &fbb)
        MyGame_Example_Monster.add(parentNamespaceTest: parentNamespaceTest, &fbb)
        MyGame_Example_Monster.addVectorOf(vectorOfReferrables: vectorOfReferrables, &fbb)
        MyGame_Example_Monster.add(singleWeakReference: singleWeakReference, &fbb)
        MyGame_Example_Monster.addVectorOf(vectorOfWeakReferences: vectorOfWeakReferences, &fbb)
        MyGame_Example_Monster.addVectorOf(vectorOfStrongReferrables: vectorOfStrongReferrables, &fbb)
        MyGame_Example_Monster.add(coOwningReference: coOwningReference, &fbb)
        MyGame_Example_Monster.addVectorOf(vectorOfCoOwningReferences: vectorOfCoOwningReferences, &fbb)
        MyGame_Example_Monster.add(nonOwningReference: nonOwningReference, &fbb)
        MyGame_Example_Monster.addVectorOf(vectorOfNonOwningReferences: vectorOfNonOwningReferences, &fbb)
        MyGame_Example_Monster.add(anyUniqueType: anyUniqueType, &fbb)
        MyGame_Example_Monster.add(anyUnique: anyUnique, &fbb)
        MyGame_Example_Monster.add(anyAmbiguousType: anyAmbiguousType, &fbb)
        MyGame_Example_Monster.add(anyAmbiguous: anyAmbiguous, &fbb)
        MyGame_Example_Monster.addVectorOf(vectorOfEnums: vectorOfEnums, &fbb)
        MyGame_Example_Monster.add(signedEnum: signedEnum, &fbb)
        return MyGame_Example_Monster.endMonster(&fbb, start: __start)
    }
    public static func sortVectorOfMonster(offsets:[Offset<UOffset>], _ fbb: inout FlatBufferBuilder) -> Offset<UOffset> {
        var off = offsets
        off.sort { Table.compare(Table.offset(Int32($1.o), vOffset: 10, fbb: fbb.buffer), Table.offset(Int32($0.o), vOffset: 10, fbb: fbb.buffer), fbb: fbb.buffer) < 0 } 
        return fbb.createVector(ofOffsets: off)
    }
    fileprivate static func lookupByKey(vector: Int32, key: String, fbb: ByteBuffer) -> MyGame_Example_Monster? {
        let key = key.utf8.map { $0 }
        var span = fbb.read(def: Int32.self, position: Int(vector - 4))
        var start: Int32 = 0
        while span != 0 {
            var middle = span / 2
            let tableOffset = Table.indirect(vector + 4 * (start + middle), fbb)
            let comp = Table.compare(Table.offset(Int32(fbb.capacity) - tableOffset, vOffset: 10, fbb: fbb), key, fbb: fbb)
            if comp > 0 {
                span = middle
            } else if comp < 0 {
                middle += 1
                start += middle
                span -= middle
            } else {
                return MyGame_Example_Monster(fbb, o: tableOffset)
            }
        }
        return nil
    }
    

    public mutating func unpack() -> MyGame_Example_MonsterT {
        return MyGame_Example_MonsterT(&self)
    }
    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_MonsterT?) -> Offset<UOffset> {
        guard var obj = obj else { return Offset<UOffset>() }
        return pack(&builder, obj: &obj)
    }

    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_MonsterT) -> Offset<UOffset> {
        let __pos = obj.pos.map { MyGame_Example_Vec3.createVec3(x: $0.x, y: $0.y, z: $0.z, test1: $0.test1, test2: $0.test2, test3a: $0.test3.a, test3b: $0.test3.b) }
        let __name = builder.create(string: obj.name)
        let __inventory = builder.createVector(obj.inventory)
        let __test = obj.test?.pack(builder: &builder) ?? Offset()
        var __test4__: [UnsafeMutableRawPointer] = []
        for i in obj.test4 {
            guard let _o = i else { continue }
            __test4__.append(MyGame_Example_Test.createTest(a: _o.a, b: _o.b))
        }
        let __test4 = builder.createVector(structs: __test4__, type: MyGame_Example_Test.self)
        let __testarrayofstring = builder.createVector(ofStrings: obj.testarrayofstring.compactMap({ $0 }) )
        var __testarrayoftables__: [Offset<UOffset>] = []
        for var i in obj.testarrayoftables {
            __testarrayoftables__.append(MyGame_Example_Monster.pack(&builder, obj: &i))
        }
        let __testarrayoftables = builder.createVector(ofOffsets: __testarrayoftables__)
        let __enemy = MyGame_Example_Monster.pack(&builder, obj: &obj.enemy)
        let __testnestedflatbuffer = builder.createVector(obj.testnestedflatbuffer)
        let __testempty = MyGame_Example_Stat.pack(&builder, obj: &obj.testempty)
        let __testarrayofbools = builder.createVector(obj.testarrayofbools)
        let __testarrayofstring2 = builder.createVector(ofStrings: obj.testarrayofstring2.compactMap({ $0 }) )
        var __testarrayofsortedstruct__: [UnsafeMutableRawPointer] = []
        for i in obj.testarrayofsortedstruct {
            guard let _o = i else { continue }
            __testarrayofsortedstruct__.append(MyGame_Example_Ability.createAbility(id: _o.id, distance: _o.distance))
        }
        let __testarrayofsortedstruct = builder.createVector(structs: __testarrayofsortedstruct__, type: MyGame_Example_Ability.self)
        let __flex = builder.createVector(obj.flex)
        var __test5__: [UnsafeMutableRawPointer] = []
        for i in obj.test5 {
            guard let _o = i else { continue }
            __test5__.append(MyGame_Example_Test.createTest(a: _o.a, b: _o.b))
        }
        let __test5 = builder.createVector(structs: __test5__, type: MyGame_Example_Test.self)
        let __vectorOfLongs = builder.createVector(obj.vectorOfLongs)
        let __vectorOfDoubles = builder.createVector(obj.vectorOfDoubles)
        let __parentNamespaceTest = MyGame_InParentNamespace.pack(&builder, obj: &obj.parentNamespaceTest)
        var __vectorOfReferrables__: [Offset<UOffset>] = []
        for var i in obj.vectorOfReferrables {
            __vectorOfReferrables__.append(MyGame_Example_Referrable.pack(&builder, obj: &i))
        }
        let __vectorOfReferrables = builder.createVector(ofOffsets: __vectorOfReferrables__)
        let __vectorOfWeakReferences = builder.createVector(obj.vectorOfWeakReferences)
        var __vectorOfStrongReferrables__: [Offset<UOffset>] = []
        for var i in obj.vectorOfStrongReferrables {
            __vectorOfStrongReferrables__.append(MyGame_Example_Referrable.pack(&builder, obj: &i))
        }
        let __vectorOfStrongReferrables = builder.createVector(ofOffsets: __vectorOfStrongReferrables__)
        let __vectorOfCoOwningReferences = builder.createVector(obj.vectorOfCoOwningReferences)
        let __vectorOfNonOwningReferences = builder.createVector(obj.vectorOfNonOwningReferences)
        let __anyUnique = obj.anyUnique?.pack(builder: &builder) ?? Offset()
        let __anyAmbiguous = obj.anyAmbiguous?.pack(builder: &builder) ?? Offset()
        let __vectorOfEnums = builder.createVector(obj.vectorOfEnums)
        let __root = MyGame_Example_Monster.startMonster(&builder)
        MyGame_Example_Monster.add(pos: __pos, &builder)
        MyGame_Example_Monster.add(mana: obj.mana, &builder)
        MyGame_Example_Monster.add(hp: obj.hp, &builder)
        MyGame_Example_Monster.add(name: __name, &builder)
        MyGame_Example_Monster.addVectorOf(inventory: __inventory, &builder)
        MyGame_Example_Monster.add(color: obj.color, &builder)
        if let o = obj.test?.type {
          MyGame_Example_Monster.add(testType: o, &builder)
          MyGame_Example_Monster.add(test: __test, &builder)
        }

        MyGame_Example_Monster.addVectorOf(test4: __test4, &builder)
        MyGame_Example_Monster.addVectorOf(testarrayofstring: __testarrayofstring, &builder)
        MyGame_Example_Monster.addVectorOf(testarrayoftables: __testarrayoftables, &builder)
        MyGame_Example_Monster.add(enemy: __enemy, &builder)
        MyGame_Example_Monster.addVectorOf(testnestedflatbuffer: __testnestedflatbuffer, &builder)
        MyGame_Example_Monster.add(testempty: __testempty, &builder)
        MyGame_Example_Monster.add(testbool: obj.testbool, &builder)
        MyGame_Example_Monster.add(testhashs32Fnv1: obj.testhashs32Fnv1, &builder)
        MyGame_Example_Monster.add(testhashu32Fnv1: obj.testhashu32Fnv1, &builder)
        MyGame_Example_Monster.add(testhashs64Fnv1: obj.testhashs64Fnv1, &builder)
        MyGame_Example_Monster.add(testhashu64Fnv1: obj.testhashu64Fnv1, &builder)
        MyGame_Example_Monster.add(testhashs32Fnv1a: obj.testhashs32Fnv1a, &builder)
        MyGame_Example_Monster.add(testhashu32Fnv1a: obj.testhashu32Fnv1a, &builder)
        MyGame_Example_Monster.add(testhashs64Fnv1a: obj.testhashs64Fnv1a, &builder)
        MyGame_Example_Monster.add(testhashu64Fnv1a: obj.testhashu64Fnv1a, &builder)
        MyGame_Example_Monster.addVectorOf(testarrayofbools: __testarrayofbools, &builder)
        MyGame_Example_Monster.add(testf: obj.testf, &builder)
        MyGame_Example_Monster.add(testf2: obj.testf2, &builder)
        MyGame_Example_Monster.add(testf3: obj.testf3, &builder)
        MyGame_Example_Monster.addVectorOf(testarrayofstring2: __testarrayofstring2, &builder)
        MyGame_Example_Monster.addVectorOf(testarrayofsortedstruct: __testarrayofsortedstruct, &builder)
        MyGame_Example_Monster.addVectorOf(flex: __flex, &builder)
        MyGame_Example_Monster.addVectorOf(test5: __test5, &builder)
        MyGame_Example_Monster.addVectorOf(vectorOfLongs: __vectorOfLongs, &builder)
        MyGame_Example_Monster.addVectorOf(vectorOfDoubles: __vectorOfDoubles, &builder)
        MyGame_Example_Monster.add(parentNamespaceTest: __parentNamespaceTest, &builder)
        MyGame_Example_Monster.addVectorOf(vectorOfReferrables: __vectorOfReferrables, &builder)
        MyGame_Example_Monster.add(singleWeakReference: obj.singleWeakReference, &builder)
        MyGame_Example_Monster.addVectorOf(vectorOfWeakReferences: __vectorOfWeakReferences, &builder)
        MyGame_Example_Monster.addVectorOf(vectorOfStrongReferrables: __vectorOfStrongReferrables, &builder)
        MyGame_Example_Monster.add(coOwningReference: obj.coOwningReference, &builder)
        MyGame_Example_Monster.addVectorOf(vectorOfCoOwningReferences: __vectorOfCoOwningReferences, &builder)
        MyGame_Example_Monster.add(nonOwningReference: obj.nonOwningReference, &builder)
        MyGame_Example_Monster.addVectorOf(vectorOfNonOwningReferences: __vectorOfNonOwningReferences, &builder)
        if let o = obj.anyUnique?.type {
          MyGame_Example_Monster.add(anyUniqueType: o, &builder)
          MyGame_Example_Monster.add(anyUnique: __anyUnique, &builder)
        }

        if let o = obj.anyAmbiguous?.type {
          MyGame_Example_Monster.add(anyAmbiguousType: o, &builder)
          MyGame_Example_Monster.add(anyAmbiguous: __anyAmbiguous, &builder)
        }

        MyGame_Example_Monster.addVectorOf(vectorOfEnums: __vectorOfEnums, &builder)
        MyGame_Example_Monster.add(signedEnum: obj.signedEnum, &builder)
        return MyGame_Example_Monster.endMonster(&builder, start: __root)
    }
}

public class MyGame_Example_MonsterT: NativeTable {

    public var pos: MyGame_Example_Vec3T?
    public var mana: Int16
    public var hp: Int16
    public var name: String
    public var inventory: [UInt8]
    public var color: MyGame_Example_Color
    public var test: MyGame_Example_Any_Union?
    public var test4: [MyGame_Example_TestT?]
    public var testarrayofstring: [String?]
    public var testarrayoftables: [MyGame_Example_MonsterT?]
    public var enemy: MyGame_Example_MonsterT?
    public var testnestedflatbuffer: [UInt8]
    public var testempty: MyGame_Example_StatT?
    public var testbool: Bool
    public var testhashs32Fnv1: Int32
    public var testhashu32Fnv1: UInt32
    public var testhashs64Fnv1: Int64
    public var testhashu64Fnv1: UInt64
    public var testhashs32Fnv1a: Int32
    public var testhashu32Fnv1a: UInt32
    public var testhashs64Fnv1a: Int64
    public var testhashu64Fnv1a: UInt64
    public var testarrayofbools: [Bool]
    public var testf: Float32
    public var testf2: Float32
    public var testf3: Float32
    public var testarrayofstring2: [String?]
    public var testarrayofsortedstruct: [MyGame_Example_AbilityT?]
    public var flex: [UInt8]
    public var test5: [MyGame_Example_TestT?]
    public var vectorOfLongs: [Int64]
    public var vectorOfDoubles: [Double]
    public var parentNamespaceTest: MyGame_InParentNamespaceT?
    public var vectorOfReferrables: [MyGame_Example_ReferrableT?]
    public var singleWeakReference: UInt64
    public var vectorOfWeakReferences: [UInt64]
    public var vectorOfStrongReferrables: [MyGame_Example_ReferrableT?]
    public var coOwningReference: UInt64
    public var vectorOfCoOwningReferences: [UInt64]
    public var nonOwningReference: UInt64
    public var vectorOfNonOwningReferences: [UInt64]
    public var anyUnique: MyGame_Example_AnyUniqueAliasesUnion?
    public var anyAmbiguous: MyGame_Example_AnyAmbiguousAliasesUnion?
    public var vectorOfEnums: [MyGame_Example_Color]
    public var signedEnum: MyGame_Example_Race

    public init(_ _t: inout MyGame_Example_Monster) {
        var __pos = _t.pos
        pos = __pos?.unpack()
        mana = _t.mana
        hp = _t.hp
        name = _t.name
        inventory = []
        for index in 0..<_t.inventoryCount {
            inventory.append(_t.inventory(at: index))
        }
        color = _t.color
        switch _t.testType {
        case .monster:
            var _v = _t.test(type: MyGame_Example_Monster.self)
            test = MyGame_Example_Any_Union(_v?.unpack(), type: .monster)
        case .testsimpletablewithenum:
            var _v = _t.test(type: MyGame_Example_TestSimpleTableWithEnum.self)
            test = MyGame_Example_Any_Union(_v?.unpack(), type: .testsimpletablewithenum)
        case .mygameExample2Monster:
            var _v = _t.test(type: MyGame_Example2_Monster.self)
            test = MyGame_Example_Any_Union(_v?.unpack(), type: .mygameExample2Monster)
        default: break
        }
        test4 = []
        for index in 0..<_t.test4Count {
            var __v_ = _t.test4(at: index)
            test4.append(__v_?.unpack())
        }
        testarrayofstring = []
        for index in 0..<_t.testarrayofstringCount {
            testarrayofstring.append(_t.testarrayofstring(at: index))
        }
        testarrayoftables = []
        for index in 0..<_t.testarrayoftablesCount {
            var __v_ = _t.testarrayoftables(at: index)
            testarrayoftables.append(__v_?.unpack())
        }
        var __enemy = _t.enemy
        enemy = __enemy?.unpack()
        testnestedflatbuffer = []
        for index in 0..<_t.testnestedflatbufferCount {
            testnestedflatbuffer.append(_t.testnestedflatbuffer(at: index))
        }
        var __testempty = _t.testempty
        testempty = __testempty?.unpack()
        testbool = _t.testbool
        testhashs32Fnv1 = _t.testhashs32Fnv1
        testhashu32Fnv1 = _t.testhashu32Fnv1
        testhashs64Fnv1 = _t.testhashs64Fnv1
        testhashu64Fnv1 = _t.testhashu64Fnv1
        testhashs32Fnv1a = _t.testhashs32Fnv1a
        testhashu32Fnv1a = _t.testhashu32Fnv1a
        testhashs64Fnv1a = _t.testhashs64Fnv1a
        testhashu64Fnv1a = _t.testhashu64Fnv1a
        testarrayofbools = []
        for index in 0..<_t.testarrayofboolsCount {
            testarrayofbools.append(_t.testarrayofbools(at: index))
        }
        testf = _t.testf
        testf2 = _t.testf2
        testf3 = _t.testf3
        testarrayofstring2 = []
        for index in 0..<_t.testarrayofstring2Count {
            testarrayofstring2.append(_t.testarrayofstring2(at: index))
        }
        testarrayofsortedstruct = []
        for index in 0..<_t.testarrayofsortedstructCount {
            var __v_ = _t.testarrayofsortedstruct(at: index)
            testarrayofsortedstruct.append(__v_?.unpack())
        }
        flex = []
        for index in 0..<_t.flexCount {
            flex.append(_t.flex(at: index))
        }
        test5 = []
        for index in 0..<_t.test5Count {
            var __v_ = _t.test5(at: index)
            test5.append(__v_?.unpack())
        }
        vectorOfLongs = []
        for index in 0..<_t.vectorOfLongsCount {
            vectorOfLongs.append(_t.vectorOfLongs(at: index))
        }
        vectorOfDoubles = []
        for index in 0..<_t.vectorOfDoublesCount {
            vectorOfDoubles.append(_t.vectorOfDoubles(at: index))
        }
        var __parentNamespaceTest = _t.parentNamespaceTest
        parentNamespaceTest = __parentNamespaceTest?.unpack()
        vectorOfReferrables = []
        for index in 0..<_t.vectorOfReferrablesCount {
            var __v_ = _t.vectorOfReferrables(at: index)
            vectorOfReferrables.append(__v_?.unpack())
        }
        singleWeakReference = _t.singleWeakReference
        vectorOfWeakReferences = []
        for index in 0..<_t.vectorOfWeakReferencesCount {
            vectorOfWeakReferences.append(_t.vectorOfWeakReferences(at: index))
        }
        vectorOfStrongReferrables = []
        for index in 0..<_t.vectorOfStrongReferrablesCount {
            var __v_ = _t.vectorOfStrongReferrables(at: index)
            vectorOfStrongReferrables.append(__v_?.unpack())
        }
        coOwningReference = _t.coOwningReference
        vectorOfCoOwningReferences = []
        for index in 0..<_t.vectorOfCoOwningReferencesCount {
            vectorOfCoOwningReferences.append(_t.vectorOfCoOwningReferences(at: index))
        }
        nonOwningReference = _t.nonOwningReference
        vectorOfNonOwningReferences = []
        for index in 0..<_t.vectorOfNonOwningReferencesCount {
            vectorOfNonOwningReferences.append(_t.vectorOfNonOwningReferences(at: index))
        }
        switch _t.anyUniqueType {
        case .m:
            var _v = _t.anyUnique(type: MyGame_Example_Monster.self)
            anyUnique = MyGame_Example_AnyUniqueAliasesUnion(_v?.unpack(), type: .m)
        case .ts:
            var _v = _t.anyUnique(type: MyGame_Example_TestSimpleTableWithEnum.self)
            anyUnique = MyGame_Example_AnyUniqueAliasesUnion(_v?.unpack(), type: .ts)
        case .m2:
            var _v = _t.anyUnique(type: MyGame_Example2_Monster.self)
            anyUnique = MyGame_Example_AnyUniqueAliasesUnion(_v?.unpack(), type: .m2)
        default: break
        }
        switch _t.anyAmbiguousType {
        case .m1:
            var _v = _t.anyAmbiguous(type: MyGame_Example_Monster.self)
            anyAmbiguous = MyGame_Example_AnyAmbiguousAliasesUnion(_v?.unpack(), type: .m1)
        case .m2:
            var _v = _t.anyAmbiguous(type: MyGame_Example_Monster.self)
            anyAmbiguous = MyGame_Example_AnyAmbiguousAliasesUnion(_v?.unpack(), type: .m2)
        case .m3:
            var _v = _t.anyAmbiguous(type: MyGame_Example_Monster.self)
            anyAmbiguous = MyGame_Example_AnyAmbiguousAliasesUnion(_v?.unpack(), type: .m3)
        default: break
        }
        vectorOfEnums = []
        for index in 0..<_t.vectorOfEnumsCount {
            vectorOfEnums.append(_t.vectorOfEnums(at: index)!)
        }
        signedEnum = _t.signedEnum
    }

    public init() {
        pos = MyGame_Example_Vec3T()
        mana = 150
        hp = 100
        name = ""
        inventory = []
        color = .blue
        test4 = []
        testarrayofstring = []
        testarrayoftables = []
        enemy = MyGame_Example_MonsterT()
        testnestedflatbuffer = []
        testempty = MyGame_Example_StatT()
        testbool = false
        testhashs32Fnv1 = 0
        testhashu32Fnv1 = 0
        testhashs64Fnv1 = 0
        testhashu64Fnv1 = 0
        testhashs32Fnv1a = 0
        testhashu32Fnv1a = 0
        testhashs64Fnv1a = 0
        testhashu64Fnv1a = 0
        testarrayofbools = []
        testf = 3.14159
        testf2 = 3.0
        testf3 = 0.0
        testarrayofstring2 = []
        testarrayofsortedstruct = []
        flex = []
        test5 = []
        vectorOfLongs = []
        vectorOfDoubles = []
        parentNamespaceTest = MyGame_InParentNamespaceT()
        vectorOfReferrables = []
        singleWeakReference = 0
        vectorOfWeakReferences = []
        vectorOfStrongReferrables = []
        coOwningReference = 0
        vectorOfCoOwningReferences = []
        nonOwningReference = 0
        vectorOfNonOwningReferences = []
        vectorOfEnums = []
        signedEnum = .none_
    }

    public func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_Monster.self) }

}
public struct MyGame_Example_TypeAliases: FlatBufferObject, ObjectAPI {

    static func validateVersion() { FlatBuffersVersion_1_12_0() }
    public var __buffer: ByteBuffer! { return _accessor.bb }
    private var _accessor: Table

    public static func finish(_ fbb: inout FlatBufferBuilder, end: Offset<UOffset>, prefix: Bool = false) { fbb.finish(offset: end, fileId: "MONS", addPrefix: prefix) }
    public static func getRootAsTypeAliases(bb: ByteBuffer) -> MyGame_Example_TypeAliases { return MyGame_Example_TypeAliases(Table(bb: bb, position: Int32(bb.read(def: UOffset.self, position: bb.reader)) + Int32(bb.reader))) }

    private init(_ t: Table) { _accessor = t }
    public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }

    private enum VTOFFSET: VOffset {
        case i8 = 4
        case u8 = 6
        case i16 = 8
        case u16 = 10
        case i32 = 12
        case u32 = 14
        case i64 = 16
        case u64 = 18
        case f32 = 20
        case f64 = 22
        case v8 = 24
        case vf64 = 26
        var v: Int32 { Int32(self.rawValue) }
        var p: VOffset { self.rawValue }
    }

    public var i8: Int8 { let o = _accessor.offset(VTOFFSET.i8.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int8.self, at: o) }
    @discardableResult public func mutate(i8: Int8) -> Bool {let o = _accessor.offset(VTOFFSET.i8.v);  return _accessor.mutate(i8, index: o) }
    public var u8: UInt8 { let o = _accessor.offset(VTOFFSET.u8.v); return o == 0 ? 0 : _accessor.readBuffer(of: UInt8.self, at: o) }
    @discardableResult public func mutate(u8: UInt8) -> Bool {let o = _accessor.offset(VTOFFSET.u8.v);  return _accessor.mutate(u8, index: o) }
    public var i16: Int16 { let o = _accessor.offset(VTOFFSET.i16.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int16.self, at: o) }
    @discardableResult public func mutate(i16: Int16) -> Bool {let o = _accessor.offset(VTOFFSET.i16.v);  return _accessor.mutate(i16, index: o) }
    public var u16: UInt16 { let o = _accessor.offset(VTOFFSET.u16.v); return o == 0 ? 0 : _accessor.readBuffer(of: UInt16.self, at: o) }
    @discardableResult public func mutate(u16: UInt16) -> Bool {let o = _accessor.offset(VTOFFSET.u16.v);  return _accessor.mutate(u16, index: o) }
    public var i32: Int32 { let o = _accessor.offset(VTOFFSET.i32.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int32.self, at: o) }
    @discardableResult public func mutate(i32: Int32) -> Bool {let o = _accessor.offset(VTOFFSET.i32.v);  return _accessor.mutate(i32, index: o) }
    public var u32: UInt32 { let o = _accessor.offset(VTOFFSET.u32.v); return o == 0 ? 0 : _accessor.readBuffer(of: UInt32.self, at: o) }
    @discardableResult public func mutate(u32: UInt32) -> Bool {let o = _accessor.offset(VTOFFSET.u32.v);  return _accessor.mutate(u32, index: o) }
    public var i64: Int64 { let o = _accessor.offset(VTOFFSET.i64.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int64.self, at: o) }
    @discardableResult public func mutate(i64: Int64) -> Bool {let o = _accessor.offset(VTOFFSET.i64.v);  return _accessor.mutate(i64, index: o) }
    public var u64: UInt64 { let o = _accessor.offset(VTOFFSET.u64.v); return o == 0 ? 0 : _accessor.readBuffer(of: UInt64.self, at: o) }
    @discardableResult public func mutate(u64: UInt64) -> Bool {let o = _accessor.offset(VTOFFSET.u64.v);  return _accessor.mutate(u64, index: o) }
    public var f32: Float32 { let o = _accessor.offset(VTOFFSET.f32.v); return o == 0 ? 0.0 : _accessor.readBuffer(of: Float32.self, at: o) }
    @discardableResult public func mutate(f32: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.f32.v);  return _accessor.mutate(f32, index: o) }
    public var f64: Double { let o = _accessor.offset(VTOFFSET.f64.v); return o == 0 ? 0.0 : _accessor.readBuffer(of: Double.self, at: o) }
    @discardableResult public func mutate(f64: Double) -> Bool {let o = _accessor.offset(VTOFFSET.f64.v);  return _accessor.mutate(f64, index: o) }
    public var v8Count: Int32 { let o = _accessor.offset(VTOFFSET.v8.v); return o == 0 ? 0 : _accessor.vector(count: o) }
    public func v8(at index: Int32) -> Int8 { let o = _accessor.offset(VTOFFSET.v8.v); return o == 0 ? 0 : _accessor.directRead(of: Int8.self, offset: _accessor.vector(at: o) + index * 1) }
    public var v8: [Int8] { return _accessor.getVector(at: VTOFFSET.v8.v) ?? [] }
    public func mutate(v8: Int8, at index: Int32) -> Bool { let o = _accessor.offset(VTOFFSET.v8.v); return _accessor.directMutate(v8, index: _accessor.vector(at: o) + index * 1) }
    public var vf64Count: Int32 { let o = _accessor.offset(VTOFFSET.vf64.v); return o == 0 ? 0 : _accessor.vector(count: o) }
    public func vf64(at index: Int32) -> Double { let o = _accessor.offset(VTOFFSET.vf64.v); return o == 0 ? 0 : _accessor.directRead(of: Double.self, offset: _accessor.vector(at: o) + index * 8) }
    public var vf64: [Double] { return _accessor.getVector(at: VTOFFSET.vf64.v) ?? [] }
    public func mutate(vf64: Double, at index: Int32) -> Bool { let o = _accessor.offset(VTOFFSET.vf64.v); return _accessor.directMutate(vf64, index: _accessor.vector(at: o) + index * 8) }
    public static func startTypeAliases(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 12) }
    public static func add(i8: Int8, _ fbb: inout FlatBufferBuilder) { fbb.add(element: i8, def: 0, at: VTOFFSET.i8.p) }
    public static func add(u8: UInt8, _ fbb: inout FlatBufferBuilder) { fbb.add(element: u8, def: 0, at: VTOFFSET.u8.p) }
    public static func add(i16: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: i16, def: 0, at: VTOFFSET.i16.p) }
    public static func add(u16: UInt16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: u16, def: 0, at: VTOFFSET.u16.p) }
    public static func add(i32: Int32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: i32, def: 0, at: VTOFFSET.i32.p) }
    public static func add(u32: UInt32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: u32, def: 0, at: VTOFFSET.u32.p) }
    public static func add(i64: Int64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: i64, def: 0, at: VTOFFSET.i64.p) }
    public static func add(u64: UInt64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: u64, def: 0, at: VTOFFSET.u64.p) }
    public static func add(f32: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: f32, def: 0.0, at: VTOFFSET.f32.p) }
    public static func add(f64: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: f64, def: 0.0, at: VTOFFSET.f64.p) }
    public static func addVectorOf(v8: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: v8, at: VTOFFSET.v8.p)  }
    public static func addVectorOf(vf64: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: vf64, at: VTOFFSET.vf64.p)  }
    public static func endTypeAliases(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); return end }
    public static func createTypeAliases(
        _ fbb: inout FlatBufferBuilder,
        i8: Int8 = 0,
        u8: UInt8 = 0,
        i16: Int16 = 0,
        u16: UInt16 = 0,
        i32: Int32 = 0,
        u32: UInt32 = 0,
        i64: Int64 = 0,
        u64: UInt64 = 0,
        f32: Float32 = 0.0,
        f64: Double = 0.0,
        vectorOfV8 v8: Offset<UOffset> = Offset(),
        vectorOfVf64 vf64: Offset<UOffset> = Offset()
    ) -> Offset<UOffset> {
        let __start = MyGame_Example_TypeAliases.startTypeAliases(&fbb)
        MyGame_Example_TypeAliases.add(i8: i8, &fbb)
        MyGame_Example_TypeAliases.add(u8: u8, &fbb)
        MyGame_Example_TypeAliases.add(i16: i16, &fbb)
        MyGame_Example_TypeAliases.add(u16: u16, &fbb)
        MyGame_Example_TypeAliases.add(i32: i32, &fbb)
        MyGame_Example_TypeAliases.add(u32: u32, &fbb)
        MyGame_Example_TypeAliases.add(i64: i64, &fbb)
        MyGame_Example_TypeAliases.add(u64: u64, &fbb)
        MyGame_Example_TypeAliases.add(f32: f32, &fbb)
        MyGame_Example_TypeAliases.add(f64: f64, &fbb)
        MyGame_Example_TypeAliases.addVectorOf(v8: v8, &fbb)
        MyGame_Example_TypeAliases.addVectorOf(vf64: vf64, &fbb)
        return MyGame_Example_TypeAliases.endTypeAliases(&fbb, start: __start)
    }
    

    public mutating func unpack() -> MyGame_Example_TypeAliasesT {
        return MyGame_Example_TypeAliasesT(&self)
    }
    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_TypeAliasesT?) -> Offset<UOffset> {
        guard var obj = obj else { return Offset<UOffset>() }
        return pack(&builder, obj: &obj)
    }

    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_TypeAliasesT) -> Offset<UOffset> {
        let __v8 = builder.createVector(obj.v8)
        let __vf64 = builder.createVector(obj.vf64)
        let __root = MyGame_Example_TypeAliases.startTypeAliases(&builder)
        MyGame_Example_TypeAliases.add(i8: obj.i8, &builder)
        MyGame_Example_TypeAliases.add(u8: obj.u8, &builder)
        MyGame_Example_TypeAliases.add(i16: obj.i16, &builder)
        MyGame_Example_TypeAliases.add(u16: obj.u16, &builder)
        MyGame_Example_TypeAliases.add(i32: obj.i32, &builder)
        MyGame_Example_TypeAliases.add(u32: obj.u32, &builder)
        MyGame_Example_TypeAliases.add(i64: obj.i64, &builder)
        MyGame_Example_TypeAliases.add(u64: obj.u64, &builder)
        MyGame_Example_TypeAliases.add(f32: obj.f32, &builder)
        MyGame_Example_TypeAliases.add(f64: obj.f64, &builder)
        MyGame_Example_TypeAliases.addVectorOf(v8: __v8, &builder)
        MyGame_Example_TypeAliases.addVectorOf(vf64: __vf64, &builder)
        return MyGame_Example_TypeAliases.endTypeAliases(&builder, start: __root)
    }
}

public class MyGame_Example_TypeAliasesT: NativeTable {

    public var i8: Int8
    public var u8: UInt8
    public var i16: Int16
    public var u16: UInt16
    public var i32: Int32
    public var u32: UInt32
    public var i64: Int64
    public var u64: UInt64
    public var f32: Float32
    public var f64: Double
    public var v8: [Int8]
    public var vf64: [Double]

    public init(_ _t: inout MyGame_Example_TypeAliases) {
        i8 = _t.i8
        u8 = _t.u8
        i16 = _t.i16
        u16 = _t.u16
        i32 = _t.i32
        u32 = _t.u32
        i64 = _t.i64
        u64 = _t.u64
        f32 = _t.f32
        f64 = _t.f64
        v8 = []
        for index in 0..<_t.v8Count {
            v8.append(_t.v8(at: index))
        }
        vf64 = []
        for index in 0..<_t.vf64Count {
            vf64.append(_t.vf64(at: index))
        }
    }

    public init() {
        i8 = 0
        u8 = 0
        i16 = 0
        u16 = 0
        i32 = 0
        u32 = 0
        i64 = 0
        u64 = 0
        f32 = 0.0
        f64 = 0.0
        v8 = []
        vf64 = []
    }

    public func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_TypeAliases.self) }

}
