diff --git a/tests/optional_scalars/ScalarStuff.go b/tests/optional_scalars/ScalarStuff.go
new file mode 100644
index 0000000..2992f30
--- /dev/null
+++ b/tests/optional_scalars/ScalarStuff.go
@@ -0,0 +1,756 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package optional_scalars
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type ScalarStuffT struct {
+	JustI8 int8
+	MaybeI8 *int8
+	DefaultI8 int8
+	JustU8 byte
+	MaybeU8 *byte
+	DefaultU8 byte
+	JustI16 int16
+	MaybeI16 *int16
+	DefaultI16 int16
+	JustU16 uint16
+	MaybeU16 *uint16
+	DefaultU16 uint16
+	JustI32 int32
+	MaybeI32 *int32
+	DefaultI32 int32
+	JustU32 uint32
+	MaybeU32 *uint32
+	DefaultU32 uint32
+	JustI64 int64
+	MaybeI64 *int64
+	DefaultI64 int64
+	JustU64 uint64
+	MaybeU64 *uint64
+	DefaultU64 uint64
+	JustF32 float32
+	MaybeF32 *float32
+	DefaultF32 float32
+	JustF64 float64
+	MaybeF64 *float64
+	DefaultF64 float64
+	JustBool bool
+	MaybeBool *bool
+	DefaultBool bool
+	JustEnum OptionalByte
+	MaybeEnum *OptionalByte
+	DefaultEnum OptionalByte
+}
+
+func (t *ScalarStuffT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	if t == nil { return 0 }
+	ScalarStuffStart(builder)
+	ScalarStuffAddJustI8(builder, t.JustI8)
+	if t.MaybeI8 != nil {
+		ScalarStuffAddMaybeI8(builder, *t.MaybeI8)
+	}
+	ScalarStuffAddDefaultI8(builder, t.DefaultI8)
+	ScalarStuffAddJustU8(builder, t.JustU8)
+	if t.MaybeU8 != nil {
+		ScalarStuffAddMaybeU8(builder, *t.MaybeU8)
+	}
+	ScalarStuffAddDefaultU8(builder, t.DefaultU8)
+	ScalarStuffAddJustI16(builder, t.JustI16)
+	if t.MaybeI16 != nil {
+		ScalarStuffAddMaybeI16(builder, *t.MaybeI16)
+	}
+	ScalarStuffAddDefaultI16(builder, t.DefaultI16)
+	ScalarStuffAddJustU16(builder, t.JustU16)
+	if t.MaybeU16 != nil {
+		ScalarStuffAddMaybeU16(builder, *t.MaybeU16)
+	}
+	ScalarStuffAddDefaultU16(builder, t.DefaultU16)
+	ScalarStuffAddJustI32(builder, t.JustI32)
+	if t.MaybeI32 != nil {
+		ScalarStuffAddMaybeI32(builder, *t.MaybeI32)
+	}
+	ScalarStuffAddDefaultI32(builder, t.DefaultI32)
+	ScalarStuffAddJustU32(builder, t.JustU32)
+	if t.MaybeU32 != nil {
+		ScalarStuffAddMaybeU32(builder, *t.MaybeU32)
+	}
+	ScalarStuffAddDefaultU32(builder, t.DefaultU32)
+	ScalarStuffAddJustI64(builder, t.JustI64)
+	if t.MaybeI64 != nil {
+		ScalarStuffAddMaybeI64(builder, *t.MaybeI64)
+	}
+	ScalarStuffAddDefaultI64(builder, t.DefaultI64)
+	ScalarStuffAddJustU64(builder, t.JustU64)
+	if t.MaybeU64 != nil {
+		ScalarStuffAddMaybeU64(builder, *t.MaybeU64)
+	}
+	ScalarStuffAddDefaultU64(builder, t.DefaultU64)
+	ScalarStuffAddJustF32(builder, t.JustF32)
+	if t.MaybeF32 != nil {
+		ScalarStuffAddMaybeF32(builder, *t.MaybeF32)
+	}
+	ScalarStuffAddDefaultF32(builder, t.DefaultF32)
+	ScalarStuffAddJustF64(builder, t.JustF64)
+	if t.MaybeF64 != nil {
+		ScalarStuffAddMaybeF64(builder, *t.MaybeF64)
+	}
+	ScalarStuffAddDefaultF64(builder, t.DefaultF64)
+	ScalarStuffAddJustBool(builder, t.JustBool)
+	if t.MaybeBool != nil {
+		ScalarStuffAddMaybeBool(builder, *t.MaybeBool)
+	}
+	ScalarStuffAddDefaultBool(builder, t.DefaultBool)
+	ScalarStuffAddJustEnum(builder, t.JustEnum)
+	if t.MaybeEnum != nil {
+		ScalarStuffAddMaybeEnum(builder, *t.MaybeEnum)
+	}
+	ScalarStuffAddDefaultEnum(builder, t.DefaultEnum)
+	return ScalarStuffEnd(builder)
+}
+
+func (rcv *ScalarStuff) UnPackTo(t *ScalarStuffT) {
+	t.JustI8 = rcv.JustI8()
+	t.MaybeI8 = rcv.MaybeI8()
+	t.DefaultI8 = rcv.DefaultI8()
+	t.JustU8 = rcv.JustU8()
+	t.MaybeU8 = rcv.MaybeU8()
+	t.DefaultU8 = rcv.DefaultU8()
+	t.JustI16 = rcv.JustI16()
+	t.MaybeI16 = rcv.MaybeI16()
+	t.DefaultI16 = rcv.DefaultI16()
+	t.JustU16 = rcv.JustU16()
+	t.MaybeU16 = rcv.MaybeU16()
+	t.DefaultU16 = rcv.DefaultU16()
+	t.JustI32 = rcv.JustI32()
+	t.MaybeI32 = rcv.MaybeI32()
+	t.DefaultI32 = rcv.DefaultI32()
+	t.JustU32 = rcv.JustU32()
+	t.MaybeU32 = rcv.MaybeU32()
+	t.DefaultU32 = rcv.DefaultU32()
+	t.JustI64 = rcv.JustI64()
+	t.MaybeI64 = rcv.MaybeI64()
+	t.DefaultI64 = rcv.DefaultI64()
+	t.JustU64 = rcv.JustU64()
+	t.MaybeU64 = rcv.MaybeU64()
+	t.DefaultU64 = rcv.DefaultU64()
+	t.JustF32 = rcv.JustF32()
+	t.MaybeF32 = rcv.MaybeF32()
+	t.DefaultF32 = rcv.DefaultF32()
+	t.JustF64 = rcv.JustF64()
+	t.MaybeF64 = rcv.MaybeF64()
+	t.DefaultF64 = rcv.DefaultF64()
+	t.JustBool = rcv.JustBool()
+	t.MaybeBool = rcv.MaybeBool()
+	t.DefaultBool = rcv.DefaultBool()
+	t.JustEnum = rcv.JustEnum()
+	t.MaybeEnum = rcv.MaybeEnum()
+	t.DefaultEnum = rcv.DefaultEnum()
+}
+
+func (rcv *ScalarStuff) UnPack() *ScalarStuffT {
+	if rcv == nil { return nil }
+	t := &ScalarStuffT{}
+	rcv.UnPackTo(t)
+	return t
+}
+
+type ScalarStuff struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsScalarStuff(buf []byte, offset flatbuffers.UOffsetT) *ScalarStuff {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &ScalarStuff{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func GetSizePrefixedRootAsScalarStuff(buf []byte, offset flatbuffers.UOffsetT) *ScalarStuff {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &ScalarStuff{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func (rcv *ScalarStuff) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *ScalarStuff) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *ScalarStuff) JustI8() int8 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.GetInt8(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *ScalarStuff) MutateJustI8(n int8) bool {
+	return rcv._tab.MutateInt8Slot(4, n)
+}
+
+func (rcv *ScalarStuff) MaybeI8() *int8 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		v := rcv._tab.GetInt8(o + rcv._tab.Pos)
+		return &v
+	}
+	return nil
+}
+
+func (rcv *ScalarStuff) MutateMaybeI8(n int8) bool {
+	return rcv._tab.MutateInt8Slot(6, n)
+}
+
+func (rcv *ScalarStuff) DefaultI8() int8 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.GetInt8(o + rcv._tab.Pos)
+	}
+	return 42
+}
+
+func (rcv *ScalarStuff) MutateDefaultI8(n int8) bool {
+	return rcv._tab.MutateInt8Slot(8, n)
+}
+
+func (rcv *ScalarStuff) JustU8() byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		return rcv._tab.GetByte(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *ScalarStuff) MutateJustU8(n byte) bool {
+	return rcv._tab.MutateByteSlot(10, n)
+}
+
+func (rcv *ScalarStuff) MaybeU8() *byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		v := rcv._tab.GetByte(o + rcv._tab.Pos)
+		return &v
+	}
+	return nil
+}
+
+func (rcv *ScalarStuff) MutateMaybeU8(n byte) bool {
+	return rcv._tab.MutateByteSlot(12, n)
+}
+
+func (rcv *ScalarStuff) DefaultU8() byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
+	if o != 0 {
+		return rcv._tab.GetByte(o + rcv._tab.Pos)
+	}
+	return 42
+}
+
+func (rcv *ScalarStuff) MutateDefaultU8(n byte) bool {
+	return rcv._tab.MutateByteSlot(14, n)
+}
+
+func (rcv *ScalarStuff) JustI16() int16 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
+	if o != 0 {
+		return rcv._tab.GetInt16(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *ScalarStuff) MutateJustI16(n int16) bool {
+	return rcv._tab.MutateInt16Slot(16, n)
+}
+
+func (rcv *ScalarStuff) MaybeI16() *int16 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(18))
+	if o != 0 {
+		v := rcv._tab.GetInt16(o + rcv._tab.Pos)
+		return &v
+	}
+	return nil
+}
+
+func (rcv *ScalarStuff) MutateMaybeI16(n int16) bool {
+	return rcv._tab.MutateInt16Slot(18, n)
+}
+
+func (rcv *ScalarStuff) DefaultI16() int16 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(20))
+	if o != 0 {
+		return rcv._tab.GetInt16(o + rcv._tab.Pos)
+	}
+	return 42
+}
+
+func (rcv *ScalarStuff) MutateDefaultI16(n int16) bool {
+	return rcv._tab.MutateInt16Slot(20, n)
+}
+
+func (rcv *ScalarStuff) JustU16() uint16 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(22))
+	if o != 0 {
+		return rcv._tab.GetUint16(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *ScalarStuff) MutateJustU16(n uint16) bool {
+	return rcv._tab.MutateUint16Slot(22, n)
+}
+
+func (rcv *ScalarStuff) MaybeU16() *uint16 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(24))
+	if o != 0 {
+		v := rcv._tab.GetUint16(o + rcv._tab.Pos)
+		return &v
+	}
+	return nil
+}
+
+func (rcv *ScalarStuff) MutateMaybeU16(n uint16) bool {
+	return rcv._tab.MutateUint16Slot(24, n)
+}
+
+func (rcv *ScalarStuff) DefaultU16() uint16 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(26))
+	if o != 0 {
+		return rcv._tab.GetUint16(o + rcv._tab.Pos)
+	}
+	return 42
+}
+
+func (rcv *ScalarStuff) MutateDefaultU16(n uint16) bool {
+	return rcv._tab.MutateUint16Slot(26, n)
+}
+
+func (rcv *ScalarStuff) JustI32() int32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(28))
+	if o != 0 {
+		return rcv._tab.GetInt32(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *ScalarStuff) MutateJustI32(n int32) bool {
+	return rcv._tab.MutateInt32Slot(28, n)
+}
+
+func (rcv *ScalarStuff) MaybeI32() *int32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(30))
+	if o != 0 {
+		v := rcv._tab.GetInt32(o + rcv._tab.Pos)
+		return &v
+	}
+	return nil
+}
+
+func (rcv *ScalarStuff) MutateMaybeI32(n int32) bool {
+	return rcv._tab.MutateInt32Slot(30, n)
+}
+
+func (rcv *ScalarStuff) DefaultI32() int32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(32))
+	if o != 0 {
+		return rcv._tab.GetInt32(o + rcv._tab.Pos)
+	}
+	return 42
+}
+
+func (rcv *ScalarStuff) MutateDefaultI32(n int32) bool {
+	return rcv._tab.MutateInt32Slot(32, n)
+}
+
+func (rcv *ScalarStuff) JustU32() uint32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(34))
+	if o != 0 {
+		return rcv._tab.GetUint32(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *ScalarStuff) MutateJustU32(n uint32) bool {
+	return rcv._tab.MutateUint32Slot(34, n)
+}
+
+func (rcv *ScalarStuff) MaybeU32() *uint32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(36))
+	if o != 0 {
+		v := rcv._tab.GetUint32(o + rcv._tab.Pos)
+		return &v
+	}
+	return nil
+}
+
+func (rcv *ScalarStuff) MutateMaybeU32(n uint32) bool {
+	return rcv._tab.MutateUint32Slot(36, n)
+}
+
+func (rcv *ScalarStuff) DefaultU32() uint32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(38))
+	if o != 0 {
+		return rcv._tab.GetUint32(o + rcv._tab.Pos)
+	}
+	return 42
+}
+
+func (rcv *ScalarStuff) MutateDefaultU32(n uint32) bool {
+	return rcv._tab.MutateUint32Slot(38, n)
+}
+
+func (rcv *ScalarStuff) JustI64() int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(40))
+	if o != 0 {
+		return rcv._tab.GetInt64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *ScalarStuff) MutateJustI64(n int64) bool {
+	return rcv._tab.MutateInt64Slot(40, n)
+}
+
+func (rcv *ScalarStuff) MaybeI64() *int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(42))
+	if o != 0 {
+		v := rcv._tab.GetInt64(o + rcv._tab.Pos)
+		return &v
+	}
+	return nil
+}
+
+func (rcv *ScalarStuff) MutateMaybeI64(n int64) bool {
+	return rcv._tab.MutateInt64Slot(42, n)
+}
+
+func (rcv *ScalarStuff) DefaultI64() int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(44))
+	if o != 0 {
+		return rcv._tab.GetInt64(o + rcv._tab.Pos)
+	}
+	return 42
+}
+
+func (rcv *ScalarStuff) MutateDefaultI64(n int64) bool {
+	return rcv._tab.MutateInt64Slot(44, n)
+}
+
+func (rcv *ScalarStuff) JustU64() uint64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(46))
+	if o != 0 {
+		return rcv._tab.GetUint64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *ScalarStuff) MutateJustU64(n uint64) bool {
+	return rcv._tab.MutateUint64Slot(46, n)
+}
+
+func (rcv *ScalarStuff) MaybeU64() *uint64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(48))
+	if o != 0 {
+		v := rcv._tab.GetUint64(o + rcv._tab.Pos)
+		return &v
+	}
+	return nil
+}
+
+func (rcv *ScalarStuff) MutateMaybeU64(n uint64) bool {
+	return rcv._tab.MutateUint64Slot(48, n)
+}
+
+func (rcv *ScalarStuff) DefaultU64() uint64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(50))
+	if o != 0 {
+		return rcv._tab.GetUint64(o + rcv._tab.Pos)
+	}
+	return 42
+}
+
+func (rcv *ScalarStuff) MutateDefaultU64(n uint64) bool {
+	return rcv._tab.MutateUint64Slot(50, n)
+}
+
+func (rcv *ScalarStuff) JustF32() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(52))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *ScalarStuff) MutateJustF32(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(52, n)
+}
+
+func (rcv *ScalarStuff) MaybeF32() *float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(54))
+	if o != 0 {
+		v := rcv._tab.GetFloat32(o + rcv._tab.Pos)
+		return &v
+	}
+	return nil
+}
+
+func (rcv *ScalarStuff) MutateMaybeF32(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(54, n)
+}
+
+func (rcv *ScalarStuff) DefaultF32() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(56))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return 42.0
+}
+
+func (rcv *ScalarStuff) MutateDefaultF32(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(56, n)
+}
+
+func (rcv *ScalarStuff) JustF64() float64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(58))
+	if o != 0 {
+		return rcv._tab.GetFloat64(o + rcv._tab.Pos)
+	}
+	return 0.0
+}
+
+func (rcv *ScalarStuff) MutateJustF64(n float64) bool {
+	return rcv._tab.MutateFloat64Slot(58, n)
+}
+
+func (rcv *ScalarStuff) MaybeF64() *float64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(60))
+	if o != 0 {
+		v := rcv._tab.GetFloat64(o + rcv._tab.Pos)
+		return &v
+	}
+	return nil
+}
+
+func (rcv *ScalarStuff) MutateMaybeF64(n float64) bool {
+	return rcv._tab.MutateFloat64Slot(60, n)
+}
+
+func (rcv *ScalarStuff) DefaultF64() float64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(62))
+	if o != 0 {
+		return rcv._tab.GetFloat64(o + rcv._tab.Pos)
+	}
+	return 42.0
+}
+
+func (rcv *ScalarStuff) MutateDefaultF64(n float64) bool {
+	return rcv._tab.MutateFloat64Slot(62, n)
+}
+
+func (rcv *ScalarStuff) JustBool() bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(64))
+	if o != 0 {
+		return rcv._tab.GetBool(o + rcv._tab.Pos)
+	}
+	return false
+}
+
+func (rcv *ScalarStuff) MutateJustBool(n bool) bool {
+	return rcv._tab.MutateBoolSlot(64, n)
+}
+
+func (rcv *ScalarStuff) MaybeBool() *bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(66))
+	if o != 0 {
+		v := rcv._tab.GetBool(o + rcv._tab.Pos)
+		return &v
+	}
+	return nil
+}
+
+func (rcv *ScalarStuff) MutateMaybeBool(n bool) bool {
+	return rcv._tab.MutateBoolSlot(66, n)
+}
+
+func (rcv *ScalarStuff) DefaultBool() bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(68))
+	if o != 0 {
+		return rcv._tab.GetBool(o + rcv._tab.Pos)
+	}
+	return true
+}
+
+func (rcv *ScalarStuff) MutateDefaultBool(n bool) bool {
+	return rcv._tab.MutateBoolSlot(68, n)
+}
+
+func (rcv *ScalarStuff) JustEnum() OptionalByte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(70))
+	if o != 0 {
+		return OptionalByte(rcv._tab.GetInt8(o + rcv._tab.Pos))
+	}
+	return 0
+}
+
+func (rcv *ScalarStuff) MutateJustEnum(n OptionalByte) bool {
+	return rcv._tab.MutateInt8Slot(70, int8(n))
+}
+
+func (rcv *ScalarStuff) MaybeEnum() *OptionalByte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(72))
+	if o != 0 {
+		v := OptionalByte(rcv._tab.GetInt8(o + rcv._tab.Pos))
+		return &v
+	}
+	return nil
+}
+
+func (rcv *ScalarStuff) MutateMaybeEnum(n OptionalByte) bool {
+	return rcv._tab.MutateInt8Slot(72, int8(n))
+}
+
+func (rcv *ScalarStuff) DefaultEnum() OptionalByte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(74))
+	if o != 0 {
+		return OptionalByte(rcv._tab.GetInt8(o + rcv._tab.Pos))
+	}
+	return 1
+}
+
+func (rcv *ScalarStuff) MutateDefaultEnum(n OptionalByte) bool {
+	return rcv._tab.MutateInt8Slot(74, int8(n))
+}
+
+func ScalarStuffStart(builder *flatbuffers.Builder) {
+	builder.StartObject(36)
+}
+func ScalarStuffAddJustI8(builder *flatbuffers.Builder, justI8 int8) {
+	builder.PrependInt8Slot(0, justI8, 0)
+}
+func ScalarStuffAddMaybeI8(builder *flatbuffers.Builder, maybeI8 int8) {
+	builder.PrependInt8(maybeI8)
+	builder.Slot(1)
+}
+func ScalarStuffAddDefaultI8(builder *flatbuffers.Builder, defaultI8 int8) {
+	builder.PrependInt8Slot(2, defaultI8, 42)
+}
+func ScalarStuffAddJustU8(builder *flatbuffers.Builder, justU8 byte) {
+	builder.PrependByteSlot(3, justU8, 0)
+}
+func ScalarStuffAddMaybeU8(builder *flatbuffers.Builder, maybeU8 byte) {
+	builder.PrependByte(maybeU8)
+	builder.Slot(4)
+}
+func ScalarStuffAddDefaultU8(builder *flatbuffers.Builder, defaultU8 byte) {
+	builder.PrependByteSlot(5, defaultU8, 42)
+}
+func ScalarStuffAddJustI16(builder *flatbuffers.Builder, justI16 int16) {
+	builder.PrependInt16Slot(6, justI16, 0)
+}
+func ScalarStuffAddMaybeI16(builder *flatbuffers.Builder, maybeI16 int16) {
+	builder.PrependInt16(maybeI16)
+	builder.Slot(7)
+}
+func ScalarStuffAddDefaultI16(builder *flatbuffers.Builder, defaultI16 int16) {
+	builder.PrependInt16Slot(8, defaultI16, 42)
+}
+func ScalarStuffAddJustU16(builder *flatbuffers.Builder, justU16 uint16) {
+	builder.PrependUint16Slot(9, justU16, 0)
+}
+func ScalarStuffAddMaybeU16(builder *flatbuffers.Builder, maybeU16 uint16) {
+	builder.PrependUint16(maybeU16)
+	builder.Slot(10)
+}
+func ScalarStuffAddDefaultU16(builder *flatbuffers.Builder, defaultU16 uint16) {
+	builder.PrependUint16Slot(11, defaultU16, 42)
+}
+func ScalarStuffAddJustI32(builder *flatbuffers.Builder, justI32 int32) {
+	builder.PrependInt32Slot(12, justI32, 0)
+}
+func ScalarStuffAddMaybeI32(builder *flatbuffers.Builder, maybeI32 int32) {
+	builder.PrependInt32(maybeI32)
+	builder.Slot(13)
+}
+func ScalarStuffAddDefaultI32(builder *flatbuffers.Builder, defaultI32 int32) {
+	builder.PrependInt32Slot(14, defaultI32, 42)
+}
+func ScalarStuffAddJustU32(builder *flatbuffers.Builder, justU32 uint32) {
+	builder.PrependUint32Slot(15, justU32, 0)
+}
+func ScalarStuffAddMaybeU32(builder *flatbuffers.Builder, maybeU32 uint32) {
+	builder.PrependUint32(maybeU32)
+	builder.Slot(16)
+}
+func ScalarStuffAddDefaultU32(builder *flatbuffers.Builder, defaultU32 uint32) {
+	builder.PrependUint32Slot(17, defaultU32, 42)
+}
+func ScalarStuffAddJustI64(builder *flatbuffers.Builder, justI64 int64) {
+	builder.PrependInt64Slot(18, justI64, 0)
+}
+func ScalarStuffAddMaybeI64(builder *flatbuffers.Builder, maybeI64 int64) {
+	builder.PrependInt64(maybeI64)
+	builder.Slot(19)
+}
+func ScalarStuffAddDefaultI64(builder *flatbuffers.Builder, defaultI64 int64) {
+	builder.PrependInt64Slot(20, defaultI64, 42)
+}
+func ScalarStuffAddJustU64(builder *flatbuffers.Builder, justU64 uint64) {
+	builder.PrependUint64Slot(21, justU64, 0)
+}
+func ScalarStuffAddMaybeU64(builder *flatbuffers.Builder, maybeU64 uint64) {
+	builder.PrependUint64(maybeU64)
+	builder.Slot(22)
+}
+func ScalarStuffAddDefaultU64(builder *flatbuffers.Builder, defaultU64 uint64) {
+	builder.PrependUint64Slot(23, defaultU64, 42)
+}
+func ScalarStuffAddJustF32(builder *flatbuffers.Builder, justF32 float32) {
+	builder.PrependFloat32Slot(24, justF32, 0.0)
+}
+func ScalarStuffAddMaybeF32(builder *flatbuffers.Builder, maybeF32 float32) {
+	builder.PrependFloat32(maybeF32)
+	builder.Slot(25)
+}
+func ScalarStuffAddDefaultF32(builder *flatbuffers.Builder, defaultF32 float32) {
+	builder.PrependFloat32Slot(26, defaultF32, 42.0)
+}
+func ScalarStuffAddJustF64(builder *flatbuffers.Builder, justF64 float64) {
+	builder.PrependFloat64Slot(27, justF64, 0.0)
+}
+func ScalarStuffAddMaybeF64(builder *flatbuffers.Builder, maybeF64 float64) {
+	builder.PrependFloat64(maybeF64)
+	builder.Slot(28)
+}
+func ScalarStuffAddDefaultF64(builder *flatbuffers.Builder, defaultF64 float64) {
+	builder.PrependFloat64Slot(29, defaultF64, 42.0)
+}
+func ScalarStuffAddJustBool(builder *flatbuffers.Builder, justBool bool) {
+	builder.PrependBoolSlot(30, justBool, false)
+}
+func ScalarStuffAddMaybeBool(builder *flatbuffers.Builder, maybeBool bool) {
+	builder.PrependBool(maybeBool)
+	builder.Slot(31)
+}
+func ScalarStuffAddDefaultBool(builder *flatbuffers.Builder, defaultBool bool) {
+	builder.PrependBoolSlot(32, defaultBool, true)
+}
+func ScalarStuffAddJustEnum(builder *flatbuffers.Builder, justEnum OptionalByte) {
+	builder.PrependInt8Slot(33, int8(justEnum), 0)
+}
+func ScalarStuffAddMaybeEnum(builder *flatbuffers.Builder, maybeEnum OptionalByte) {
+	builder.PrependInt8(int8(maybeEnum))
+	builder.Slot(34)
+}
+func ScalarStuffAddDefaultEnum(builder *flatbuffers.Builder, defaultEnum OptionalByte) {
+	builder.PrependInt8Slot(35, int8(defaultEnum), 1)
+}
+func ScalarStuffEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}