# automatically generated by the FlatBuffers compiler, do not modify

# namespace: optional_scalars

import flatbuffers
from flatbuffers.compat import import_numpy
np = import_numpy()

class ScalarStuff(object):
    __slots__ = ['_tab']

    @classmethod
    def GetRootAs(cls, buf, offset=0):
        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
        x = ScalarStuff()
        x.Init(buf, n + offset)
        return x

    @classmethod
    def GetRootAsScalarStuff(cls, buf, offset=0):
        """This method is deprecated. Please switch to GetRootAs."""
        return cls.GetRootAs(buf, offset)
    @classmethod
    def ScalarStuffBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4E\x55\x4C\x4C", size_prefixed=size_prefixed)

    # ScalarStuff
    def Init(self, buf, pos):
        self._tab = flatbuffers.table.Table(buf, pos)

    # ScalarStuff
    def JustI8(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
        return 0

    # ScalarStuff
    def MaybeI8(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
        return None

    # ScalarStuff
    def DefaultI8(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
        return 42

    # ScalarStuff
    def JustU8(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
        return 0

    # ScalarStuff
    def MaybeU8(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
        return None

    # ScalarStuff
    def DefaultU8(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
        return 42

    # ScalarStuff
    def JustI16(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Int16Flags, o + self._tab.Pos)
        return 0

    # ScalarStuff
    def MaybeI16(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Int16Flags, o + self._tab.Pos)
        return None

    # ScalarStuff
    def DefaultI16(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Int16Flags, o + self._tab.Pos)
        return 42

    # ScalarStuff
    def JustU16(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
        return 0

    # ScalarStuff
    def MaybeU16(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
        return None

    # ScalarStuff
    def DefaultU16(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
        return 42

    # ScalarStuff
    def JustI32(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
        return 0

    # ScalarStuff
    def MaybeI32(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
        return None

    # ScalarStuff
    def DefaultI32(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
        return 42

    # ScalarStuff
    def JustU32(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
        return 0

    # ScalarStuff
    def MaybeU32(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
        return None

    # ScalarStuff
    def DefaultU32(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(38))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
        return 42

    # ScalarStuff
    def JustI64(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(40))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
        return 0

    # ScalarStuff
    def MaybeI64(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
        return None

    # ScalarStuff
    def DefaultI64(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(44))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
        return 42

    # ScalarStuff
    def JustU64(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(46))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 0

    # ScalarStuff
    def MaybeU64(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(48))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return None

    # ScalarStuff
    def DefaultU64(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(50))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 42

    # ScalarStuff
    def JustF32(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
        return 0.0

    # ScalarStuff
    def MaybeF32(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(54))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
        return None

    # ScalarStuff
    def DefaultF32(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(56))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
        return 42.0

    # ScalarStuff
    def JustF64(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(58))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
        return 0.0

    # ScalarStuff
    def MaybeF64(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
        return None

    # ScalarStuff
    def DefaultF64(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
        return 42.0

    # ScalarStuff
    def JustBool(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
        if o != 0:
            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
        return False

    # ScalarStuff
    def MaybeBool(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
        if o != 0:
            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
        return None

    # ScalarStuff
    def DefaultBool(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
        if o != 0:
            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
        return True

    # ScalarStuff
    def JustEnum(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
        return 0

    # ScalarStuff
    def MaybeEnum(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(72))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
        return None

    # ScalarStuff
    def DefaultEnum(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(74))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
        return 1

def ScalarStuffStart(builder):
    builder.StartObject(36)

def Start(builder):
    ScalarStuffStart(builder)

def ScalarStuffAddJustI8(builder, justI8):
    builder.PrependInt8Slot(0, justI8, 0)

def AddJustI8(builder, justI8):
    ScalarStuffAddJustI8(builder, justI8)

def ScalarStuffAddMaybeI8(builder, maybeI8):
    builder.PrependInt8Slot(1, maybeI8, None)

def AddMaybeI8(builder, maybeI8):
    ScalarStuffAddMaybeI8(builder, maybeI8)

def ScalarStuffAddDefaultI8(builder, defaultI8):
    builder.PrependInt8Slot(2, defaultI8, 42)

def AddDefaultI8(builder, defaultI8):
    ScalarStuffAddDefaultI8(builder, defaultI8)

def ScalarStuffAddJustU8(builder, justU8):
    builder.PrependUint8Slot(3, justU8, 0)

def AddJustU8(builder, justU8):
    ScalarStuffAddJustU8(builder, justU8)

def ScalarStuffAddMaybeU8(builder, maybeU8):
    builder.PrependUint8Slot(4, maybeU8, None)

def AddMaybeU8(builder, maybeU8):
    ScalarStuffAddMaybeU8(builder, maybeU8)

def ScalarStuffAddDefaultU8(builder, defaultU8):
    builder.PrependUint8Slot(5, defaultU8, 42)

def AddDefaultU8(builder, defaultU8):
    ScalarStuffAddDefaultU8(builder, defaultU8)

def ScalarStuffAddJustI16(builder, justI16):
    builder.PrependInt16Slot(6, justI16, 0)

def AddJustI16(builder, justI16):
    ScalarStuffAddJustI16(builder, justI16)

def ScalarStuffAddMaybeI16(builder, maybeI16):
    builder.PrependInt16Slot(7, maybeI16, None)

def AddMaybeI16(builder, maybeI16):
    ScalarStuffAddMaybeI16(builder, maybeI16)

def ScalarStuffAddDefaultI16(builder, defaultI16):
    builder.PrependInt16Slot(8, defaultI16, 42)

def AddDefaultI16(builder, defaultI16):
    ScalarStuffAddDefaultI16(builder, defaultI16)

def ScalarStuffAddJustU16(builder, justU16):
    builder.PrependUint16Slot(9, justU16, 0)

def AddJustU16(builder, justU16):
    ScalarStuffAddJustU16(builder, justU16)

def ScalarStuffAddMaybeU16(builder, maybeU16):
    builder.PrependUint16Slot(10, maybeU16, None)

def AddMaybeU16(builder, maybeU16):
    ScalarStuffAddMaybeU16(builder, maybeU16)

def ScalarStuffAddDefaultU16(builder, defaultU16):
    builder.PrependUint16Slot(11, defaultU16, 42)

def AddDefaultU16(builder, defaultU16):
    ScalarStuffAddDefaultU16(builder, defaultU16)

def ScalarStuffAddJustI32(builder, justI32):
    builder.PrependInt32Slot(12, justI32, 0)

def AddJustI32(builder, justI32):
    ScalarStuffAddJustI32(builder, justI32)

def ScalarStuffAddMaybeI32(builder, maybeI32):
    builder.PrependInt32Slot(13, maybeI32, None)

def AddMaybeI32(builder, maybeI32):
    ScalarStuffAddMaybeI32(builder, maybeI32)

def ScalarStuffAddDefaultI32(builder, defaultI32):
    builder.PrependInt32Slot(14, defaultI32, 42)

def AddDefaultI32(builder, defaultI32):
    ScalarStuffAddDefaultI32(builder, defaultI32)

def ScalarStuffAddJustU32(builder, justU32):
    builder.PrependUint32Slot(15, justU32, 0)

def AddJustU32(builder, justU32):
    ScalarStuffAddJustU32(builder, justU32)

def ScalarStuffAddMaybeU32(builder, maybeU32):
    builder.PrependUint32Slot(16, maybeU32, None)

def AddMaybeU32(builder, maybeU32):
    ScalarStuffAddMaybeU32(builder, maybeU32)

def ScalarStuffAddDefaultU32(builder, defaultU32):
    builder.PrependUint32Slot(17, defaultU32, 42)

def AddDefaultU32(builder, defaultU32):
    ScalarStuffAddDefaultU32(builder, defaultU32)

def ScalarStuffAddJustI64(builder, justI64):
    builder.PrependInt64Slot(18, justI64, 0)

def AddJustI64(builder, justI64):
    ScalarStuffAddJustI64(builder, justI64)

def ScalarStuffAddMaybeI64(builder, maybeI64):
    builder.PrependInt64Slot(19, maybeI64, None)

def AddMaybeI64(builder, maybeI64):
    ScalarStuffAddMaybeI64(builder, maybeI64)

def ScalarStuffAddDefaultI64(builder, defaultI64):
    builder.PrependInt64Slot(20, defaultI64, 42)

def AddDefaultI64(builder, defaultI64):
    ScalarStuffAddDefaultI64(builder, defaultI64)

def ScalarStuffAddJustU64(builder, justU64):
    builder.PrependUint64Slot(21, justU64, 0)

def AddJustU64(builder, justU64):
    ScalarStuffAddJustU64(builder, justU64)

def ScalarStuffAddMaybeU64(builder, maybeU64):
    builder.PrependUint64Slot(22, maybeU64, None)

def AddMaybeU64(builder, maybeU64):
    ScalarStuffAddMaybeU64(builder, maybeU64)

def ScalarStuffAddDefaultU64(builder, defaultU64):
    builder.PrependUint64Slot(23, defaultU64, 42)

def AddDefaultU64(builder, defaultU64):
    ScalarStuffAddDefaultU64(builder, defaultU64)

def ScalarStuffAddJustF32(builder, justF32):
    builder.PrependFloat32Slot(24, justF32, 0.0)

def AddJustF32(builder, justF32):
    ScalarStuffAddJustF32(builder, justF32)

def ScalarStuffAddMaybeF32(builder, maybeF32):
    builder.PrependFloat32Slot(25, maybeF32, None)

def AddMaybeF32(builder, maybeF32):
    ScalarStuffAddMaybeF32(builder, maybeF32)

def ScalarStuffAddDefaultF32(builder, defaultF32):
    builder.PrependFloat32Slot(26, defaultF32, 42.0)

def AddDefaultF32(builder, defaultF32):
    ScalarStuffAddDefaultF32(builder, defaultF32)

def ScalarStuffAddJustF64(builder, justF64):
    builder.PrependFloat64Slot(27, justF64, 0.0)

def AddJustF64(builder, justF64):
    ScalarStuffAddJustF64(builder, justF64)

def ScalarStuffAddMaybeF64(builder, maybeF64):
    builder.PrependFloat64Slot(28, maybeF64, None)

def AddMaybeF64(builder, maybeF64):
    ScalarStuffAddMaybeF64(builder, maybeF64)

def ScalarStuffAddDefaultF64(builder, defaultF64):
    builder.PrependFloat64Slot(29, defaultF64, 42.0)

def AddDefaultF64(builder, defaultF64):
    ScalarStuffAddDefaultF64(builder, defaultF64)

def ScalarStuffAddJustBool(builder, justBool):
    builder.PrependBoolSlot(30, justBool, 0)

def AddJustBool(builder, justBool):
    ScalarStuffAddJustBool(builder, justBool)

def ScalarStuffAddMaybeBool(builder, maybeBool):
    builder.PrependBoolSlot(31, maybeBool, None)

def AddMaybeBool(builder, maybeBool):
    ScalarStuffAddMaybeBool(builder, maybeBool)

def ScalarStuffAddDefaultBool(builder, defaultBool):
    builder.PrependBoolSlot(32, defaultBool, 1)

def AddDefaultBool(builder, defaultBool):
    ScalarStuffAddDefaultBool(builder, defaultBool)

def ScalarStuffAddJustEnum(builder, justEnum):
    builder.PrependInt8Slot(33, justEnum, 0)

def AddJustEnum(builder, justEnum):
    ScalarStuffAddJustEnum(builder, justEnum)

def ScalarStuffAddMaybeEnum(builder, maybeEnum):
    builder.PrependInt8Slot(34, maybeEnum, None)

def AddMaybeEnum(builder, maybeEnum):
    ScalarStuffAddMaybeEnum(builder, maybeEnum)

def ScalarStuffAddDefaultEnum(builder, defaultEnum):
    builder.PrependInt8Slot(35, defaultEnum, 1)

def AddDefaultEnum(builder, defaultEnum):
    ScalarStuffAddDefaultEnum(builder, defaultEnum)

def ScalarStuffEnd(builder):
    return builder.EndObject()

def End(builder):
    return ScalarStuffEnd(builder)

try:
    from typing import Optional
except:
    pass

class ScalarStuffT(object):

    # ScalarStuffT
    def __init__(
        self,
        justI8 = 0,
        maybeI8 = None,
        defaultI8 = 42,
        justU8 = 0,
        maybeU8 = None,
        defaultU8 = 42,
        justI16 = 0,
        maybeI16 = None,
        defaultI16 = 42,
        justU16 = 0,
        maybeU16 = None,
        defaultU16 = 42,
        justI32 = 0,
        maybeI32 = None,
        defaultI32 = 42,
        justU32 = 0,
        maybeU32 = None,
        defaultU32 = 42,
        justI64 = 0,
        maybeI64 = None,
        defaultI64 = 42,
        justU64 = 0,
        maybeU64 = None,
        defaultU64 = 42,
        justF32 = 0.0,
        maybeF32 = None,
        defaultF32 = 42.0,
        justF64 = 0.0,
        maybeF64 = None,
        defaultF64 = 42.0,
        justBool = False,
        maybeBool = None,
        defaultBool = True,
        justEnum = 0,
        maybeEnum = None,
        defaultEnum = 1,
    ):
        self.justI8 = justI8  # type: int
        self.maybeI8 = maybeI8  # type: Optional[int]
        self.defaultI8 = defaultI8  # type: int
        self.justU8 = justU8  # type: int
        self.maybeU8 = maybeU8  # type: Optional[int]
        self.defaultU8 = defaultU8  # type: int
        self.justI16 = justI16  # type: int
        self.maybeI16 = maybeI16  # type: Optional[int]
        self.defaultI16 = defaultI16  # type: int
        self.justU16 = justU16  # type: int
        self.maybeU16 = maybeU16  # type: Optional[int]
        self.defaultU16 = defaultU16  # type: int
        self.justI32 = justI32  # type: int
        self.maybeI32 = maybeI32  # type: Optional[int]
        self.defaultI32 = defaultI32  # type: int
        self.justU32 = justU32  # type: int
        self.maybeU32 = maybeU32  # type: Optional[int]
        self.defaultU32 = defaultU32  # type: int
        self.justI64 = justI64  # type: int
        self.maybeI64 = maybeI64  # type: Optional[int]
        self.defaultI64 = defaultI64  # type: int
        self.justU64 = justU64  # type: int
        self.maybeU64 = maybeU64  # type: Optional[int]
        self.defaultU64 = defaultU64  # type: int
        self.justF32 = justF32  # type: float
        self.maybeF32 = maybeF32  # type: Optional[float]
        self.defaultF32 = defaultF32  # type: float
        self.justF64 = justF64  # type: float
        self.maybeF64 = maybeF64  # type: Optional[float]
        self.defaultF64 = defaultF64  # type: float
        self.justBool = justBool  # type: bool
        self.maybeBool = maybeBool  # type: Optional[bool]
        self.defaultBool = defaultBool  # type: bool
        self.justEnum = justEnum  # type: int
        self.maybeEnum = maybeEnum  # type: Optional[int]
        self.defaultEnum = defaultEnum  # type: int

    @classmethod
    def InitFromBuf(cls, buf, pos):
        scalarStuff = ScalarStuff()
        scalarStuff.Init(buf, pos)
        return cls.InitFromObj(scalarStuff)

    @classmethod
    def InitFromPackedBuf(cls, buf, pos=0):
        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
        return cls.InitFromBuf(buf, pos+n)

    @classmethod
    def InitFromObj(cls, scalarStuff):
        x = ScalarStuffT()
        x._UnPack(scalarStuff)
        return x

    # ScalarStuffT
    def _UnPack(self, scalarStuff):
        if scalarStuff is None:
            return
        self.justI8 = scalarStuff.JustI8()
        self.maybeI8 = scalarStuff.MaybeI8()
        self.defaultI8 = scalarStuff.DefaultI8()
        self.justU8 = scalarStuff.JustU8()
        self.maybeU8 = scalarStuff.MaybeU8()
        self.defaultU8 = scalarStuff.DefaultU8()
        self.justI16 = scalarStuff.JustI16()
        self.maybeI16 = scalarStuff.MaybeI16()
        self.defaultI16 = scalarStuff.DefaultI16()
        self.justU16 = scalarStuff.JustU16()
        self.maybeU16 = scalarStuff.MaybeU16()
        self.defaultU16 = scalarStuff.DefaultU16()
        self.justI32 = scalarStuff.JustI32()
        self.maybeI32 = scalarStuff.MaybeI32()
        self.defaultI32 = scalarStuff.DefaultI32()
        self.justU32 = scalarStuff.JustU32()
        self.maybeU32 = scalarStuff.MaybeU32()
        self.defaultU32 = scalarStuff.DefaultU32()
        self.justI64 = scalarStuff.JustI64()
        self.maybeI64 = scalarStuff.MaybeI64()
        self.defaultI64 = scalarStuff.DefaultI64()
        self.justU64 = scalarStuff.JustU64()
        self.maybeU64 = scalarStuff.MaybeU64()
        self.defaultU64 = scalarStuff.DefaultU64()
        self.justF32 = scalarStuff.JustF32()
        self.maybeF32 = scalarStuff.MaybeF32()
        self.defaultF32 = scalarStuff.DefaultF32()
        self.justF64 = scalarStuff.JustF64()
        self.maybeF64 = scalarStuff.MaybeF64()
        self.defaultF64 = scalarStuff.DefaultF64()
        self.justBool = scalarStuff.JustBool()
        self.maybeBool = scalarStuff.MaybeBool()
        self.defaultBool = scalarStuff.DefaultBool()
        self.justEnum = scalarStuff.JustEnum()
        self.maybeEnum = scalarStuff.MaybeEnum()
        self.defaultEnum = scalarStuff.DefaultEnum()

    # ScalarStuffT
    def Pack(self, builder):
        ScalarStuffStart(builder)
        ScalarStuffAddJustI8(builder, self.justI8)
        ScalarStuffAddMaybeI8(builder, self.maybeI8)
        ScalarStuffAddDefaultI8(builder, self.defaultI8)
        ScalarStuffAddJustU8(builder, self.justU8)
        ScalarStuffAddMaybeU8(builder, self.maybeU8)
        ScalarStuffAddDefaultU8(builder, self.defaultU8)
        ScalarStuffAddJustI16(builder, self.justI16)
        ScalarStuffAddMaybeI16(builder, self.maybeI16)
        ScalarStuffAddDefaultI16(builder, self.defaultI16)
        ScalarStuffAddJustU16(builder, self.justU16)
        ScalarStuffAddMaybeU16(builder, self.maybeU16)
        ScalarStuffAddDefaultU16(builder, self.defaultU16)
        ScalarStuffAddJustI32(builder, self.justI32)
        ScalarStuffAddMaybeI32(builder, self.maybeI32)
        ScalarStuffAddDefaultI32(builder, self.defaultI32)
        ScalarStuffAddJustU32(builder, self.justU32)
        ScalarStuffAddMaybeU32(builder, self.maybeU32)
        ScalarStuffAddDefaultU32(builder, self.defaultU32)
        ScalarStuffAddJustI64(builder, self.justI64)
        ScalarStuffAddMaybeI64(builder, self.maybeI64)
        ScalarStuffAddDefaultI64(builder, self.defaultI64)
        ScalarStuffAddJustU64(builder, self.justU64)
        ScalarStuffAddMaybeU64(builder, self.maybeU64)
        ScalarStuffAddDefaultU64(builder, self.defaultU64)
        ScalarStuffAddJustF32(builder, self.justF32)
        ScalarStuffAddMaybeF32(builder, self.maybeF32)
        ScalarStuffAddDefaultF32(builder, self.defaultF32)
        ScalarStuffAddJustF64(builder, self.justF64)
        ScalarStuffAddMaybeF64(builder, self.maybeF64)
        ScalarStuffAddDefaultF64(builder, self.defaultF64)
        ScalarStuffAddJustBool(builder, self.justBool)
        ScalarStuffAddMaybeBool(builder, self.maybeBool)
        ScalarStuffAddDefaultBool(builder, self.defaultBool)
        ScalarStuffAddJustEnum(builder, self.justEnum)
        ScalarStuffAddMaybeEnum(builder, self.maybeEnum)
        ScalarStuffAddDefaultEnum(builder, self.defaultEnum)
        scalarStuff = ScalarStuffEnd(builder)
        return scalarStuff