diff --git a/tests/optional_scalars_generated.h b/tests/optional_scalars_generated.h
new file mode 100644
index 0000000..e7c7fc1
--- /dev/null
+++ b/tests/optional_scalars_generated.h
@@ -0,0 +1,982 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+
+#ifndef FLATBUFFERS_GENERATED_OPTIONALSCALARS_OPTIONAL_SCALARS_H_
+#define FLATBUFFERS_GENERATED_OPTIONALSCALARS_OPTIONAL_SCALARS_H_
+
+#include "flatbuffers/flatbuffers.h"
+
+namespace optional_scalars {
+
+struct ScalarStuff;
+struct ScalarStuffBuilder;
+struct ScalarStuffT;
+
+bool operator==(const ScalarStuffT &lhs, const ScalarStuffT &rhs);
+bool operator!=(const ScalarStuffT &lhs, const ScalarStuffT &rhs);
+
+inline const flatbuffers::TypeTable *ScalarStuffTypeTable();
+
+enum OptionalByte {
+  OptionalByte_None = 0,
+  OptionalByte_One = 1,
+  OptionalByte_Two = 2,
+  OptionalByte_MIN = OptionalByte_None,
+  OptionalByte_MAX = OptionalByte_Two
+};
+
+inline const OptionalByte (&EnumValuesOptionalByte())[3] {
+  static const OptionalByte values[] = {
+    OptionalByte_None,
+    OptionalByte_One,
+    OptionalByte_Two
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesOptionalByte() {
+  static const char * const names[4] = {
+    "None",
+    "One",
+    "Two",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameOptionalByte(OptionalByte e) {
+  if (flatbuffers::IsOutRange(e, OptionalByte_None, OptionalByte_Two)) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesOptionalByte()[index];
+}
+
+struct ScalarStuffT : public flatbuffers::NativeTable {
+  typedef ScalarStuff TableType;
+  int8_t just_i8;
+  flatbuffers::Optional<int8_t> maybe_i8;
+  int8_t default_i8;
+  uint8_t just_u8;
+  flatbuffers::Optional<uint8_t> maybe_u8;
+  uint8_t default_u8;
+  int16_t just_i16;
+  flatbuffers::Optional<int16_t> maybe_i16;
+  int16_t default_i16;
+  uint16_t just_u16;
+  flatbuffers::Optional<uint16_t> maybe_u16;
+  uint16_t default_u16;
+  int32_t just_i32;
+  flatbuffers::Optional<int32_t> maybe_i32;
+  int32_t default_i32;
+  uint32_t just_u32;
+  flatbuffers::Optional<uint32_t> maybe_u32;
+  uint32_t default_u32;
+  int64_t just_i64;
+  flatbuffers::Optional<int64_t> maybe_i64;
+  int64_t default_i64;
+  uint64_t just_u64;
+  flatbuffers::Optional<uint64_t> maybe_u64;
+  uint64_t default_u64;
+  float just_f32;
+  flatbuffers::Optional<float> maybe_f32;
+  float default_f32;
+  double just_f64;
+  flatbuffers::Optional<double> maybe_f64;
+  double default_f64;
+  bool just_bool;
+  flatbuffers::Optional<bool> maybe_bool;
+  bool default_bool;
+  optional_scalars::OptionalByte just_enum;
+  flatbuffers::Optional<optional_scalars::OptionalByte> maybe_enum;
+  optional_scalars::OptionalByte default_enum;
+  ScalarStuffT()
+      : just_i8(0),
+        maybe_i8(flatbuffers::nullopt),
+        default_i8(42),
+        just_u8(0),
+        maybe_u8(flatbuffers::nullopt),
+        default_u8(42),
+        just_i16(0),
+        maybe_i16(flatbuffers::nullopt),
+        default_i16(42),
+        just_u16(0),
+        maybe_u16(flatbuffers::nullopt),
+        default_u16(42),
+        just_i32(0),
+        maybe_i32(flatbuffers::nullopt),
+        default_i32(42),
+        just_u32(0),
+        maybe_u32(flatbuffers::nullopt),
+        default_u32(42),
+        just_i64(0),
+        maybe_i64(flatbuffers::nullopt),
+        default_i64(42LL),
+        just_u64(0),
+        maybe_u64(flatbuffers::nullopt),
+        default_u64(42ULL),
+        just_f32(0.0f),
+        maybe_f32(flatbuffers::nullopt),
+        default_f32(42.0f),
+        just_f64(0.0),
+        maybe_f64(flatbuffers::nullopt),
+        default_f64(42.0),
+        just_bool(false),
+        maybe_bool(flatbuffers::nullopt),
+        default_bool(true),
+        just_enum(optional_scalars::OptionalByte_None),
+        maybe_enum(flatbuffers::nullopt),
+        default_enum(optional_scalars::OptionalByte_One) {
+  }
+};
+
+inline bool operator==(const ScalarStuffT &lhs, const ScalarStuffT &rhs) {
+  return
+      (lhs.just_i8 == rhs.just_i8) &&
+      (lhs.maybe_i8 == rhs.maybe_i8) &&
+      (lhs.default_i8 == rhs.default_i8) &&
+      (lhs.just_u8 == rhs.just_u8) &&
+      (lhs.maybe_u8 == rhs.maybe_u8) &&
+      (lhs.default_u8 == rhs.default_u8) &&
+      (lhs.just_i16 == rhs.just_i16) &&
+      (lhs.maybe_i16 == rhs.maybe_i16) &&
+      (lhs.default_i16 == rhs.default_i16) &&
+      (lhs.just_u16 == rhs.just_u16) &&
+      (lhs.maybe_u16 == rhs.maybe_u16) &&
+      (lhs.default_u16 == rhs.default_u16) &&
+      (lhs.just_i32 == rhs.just_i32) &&
+      (lhs.maybe_i32 == rhs.maybe_i32) &&
+      (lhs.default_i32 == rhs.default_i32) &&
+      (lhs.just_u32 == rhs.just_u32) &&
+      (lhs.maybe_u32 == rhs.maybe_u32) &&
+      (lhs.default_u32 == rhs.default_u32) &&
+      (lhs.just_i64 == rhs.just_i64) &&
+      (lhs.maybe_i64 == rhs.maybe_i64) &&
+      (lhs.default_i64 == rhs.default_i64) &&
+      (lhs.just_u64 == rhs.just_u64) &&
+      (lhs.maybe_u64 == rhs.maybe_u64) &&
+      (lhs.default_u64 == rhs.default_u64) &&
+      (lhs.just_f32 == rhs.just_f32) &&
+      (lhs.maybe_f32 == rhs.maybe_f32) &&
+      (lhs.default_f32 == rhs.default_f32) &&
+      (lhs.just_f64 == rhs.just_f64) &&
+      (lhs.maybe_f64 == rhs.maybe_f64) &&
+      (lhs.default_f64 == rhs.default_f64) &&
+      (lhs.just_bool == rhs.just_bool) &&
+      (lhs.maybe_bool == rhs.maybe_bool) &&
+      (lhs.default_bool == rhs.default_bool) &&
+      (lhs.just_enum == rhs.just_enum) &&
+      (lhs.maybe_enum == rhs.maybe_enum) &&
+      (lhs.default_enum == rhs.default_enum);
+}
+
+inline bool operator!=(const ScalarStuffT &lhs, const ScalarStuffT &rhs) {
+    return !(lhs == rhs);
+}
+
+
+struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef ScalarStuffT NativeTableType;
+  typedef ScalarStuffBuilder Builder;
+  static const flatbuffers::TypeTable *MiniReflectTypeTable() {
+    return ScalarStuffTypeTable();
+  }
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_JUST_I8 = 4,
+    VT_MAYBE_I8 = 6,
+    VT_DEFAULT_I8 = 8,
+    VT_JUST_U8 = 10,
+    VT_MAYBE_U8 = 12,
+    VT_DEFAULT_U8 = 14,
+    VT_JUST_I16 = 16,
+    VT_MAYBE_I16 = 18,
+    VT_DEFAULT_I16 = 20,
+    VT_JUST_U16 = 22,
+    VT_MAYBE_U16 = 24,
+    VT_DEFAULT_U16 = 26,
+    VT_JUST_I32 = 28,
+    VT_MAYBE_I32 = 30,
+    VT_DEFAULT_I32 = 32,
+    VT_JUST_U32 = 34,
+    VT_MAYBE_U32 = 36,
+    VT_DEFAULT_U32 = 38,
+    VT_JUST_I64 = 40,
+    VT_MAYBE_I64 = 42,
+    VT_DEFAULT_I64 = 44,
+    VT_JUST_U64 = 46,
+    VT_MAYBE_U64 = 48,
+    VT_DEFAULT_U64 = 50,
+    VT_JUST_F32 = 52,
+    VT_MAYBE_F32 = 54,
+    VT_DEFAULT_F32 = 56,
+    VT_JUST_F64 = 58,
+    VT_MAYBE_F64 = 60,
+    VT_DEFAULT_F64 = 62,
+    VT_JUST_BOOL = 64,
+    VT_MAYBE_BOOL = 66,
+    VT_DEFAULT_BOOL = 68,
+    VT_JUST_ENUM = 70,
+    VT_MAYBE_ENUM = 72,
+    VT_DEFAULT_ENUM = 74
+  };
+  int8_t just_i8() const {
+    return GetField<int8_t>(VT_JUST_I8, 0);
+  }
+  bool mutate_just_i8(int8_t _just_i8) {
+    return SetField<int8_t>(VT_JUST_I8, _just_i8, 0);
+  }
+  flatbuffers::Optional<int8_t> maybe_i8() const {
+    return GetOptional<int8_t, int8_t>(VT_MAYBE_I8);
+  }
+  bool mutate_maybe_i8(int8_t _maybe_i8) {
+    return SetField<int8_t>(VT_MAYBE_I8, _maybe_i8);
+  }
+  int8_t default_i8() const {
+    return GetField<int8_t>(VT_DEFAULT_I8, 42);
+  }
+  bool mutate_default_i8(int8_t _default_i8) {
+    return SetField<int8_t>(VT_DEFAULT_I8, _default_i8, 42);
+  }
+  uint8_t just_u8() const {
+    return GetField<uint8_t>(VT_JUST_U8, 0);
+  }
+  bool mutate_just_u8(uint8_t _just_u8) {
+    return SetField<uint8_t>(VT_JUST_U8, _just_u8, 0);
+  }
+  flatbuffers::Optional<uint8_t> maybe_u8() const {
+    return GetOptional<uint8_t, uint8_t>(VT_MAYBE_U8);
+  }
+  bool mutate_maybe_u8(uint8_t _maybe_u8) {
+    return SetField<uint8_t>(VT_MAYBE_U8, _maybe_u8);
+  }
+  uint8_t default_u8() const {
+    return GetField<uint8_t>(VT_DEFAULT_U8, 42);
+  }
+  bool mutate_default_u8(uint8_t _default_u8) {
+    return SetField<uint8_t>(VT_DEFAULT_U8, _default_u8, 42);
+  }
+  int16_t just_i16() const {
+    return GetField<int16_t>(VT_JUST_I16, 0);
+  }
+  bool mutate_just_i16(int16_t _just_i16) {
+    return SetField<int16_t>(VT_JUST_I16, _just_i16, 0);
+  }
+  flatbuffers::Optional<int16_t> maybe_i16() const {
+    return GetOptional<int16_t, int16_t>(VT_MAYBE_I16);
+  }
+  bool mutate_maybe_i16(int16_t _maybe_i16) {
+    return SetField<int16_t>(VT_MAYBE_I16, _maybe_i16);
+  }
+  int16_t default_i16() const {
+    return GetField<int16_t>(VT_DEFAULT_I16, 42);
+  }
+  bool mutate_default_i16(int16_t _default_i16) {
+    return SetField<int16_t>(VT_DEFAULT_I16, _default_i16, 42);
+  }
+  uint16_t just_u16() const {
+    return GetField<uint16_t>(VT_JUST_U16, 0);
+  }
+  bool mutate_just_u16(uint16_t _just_u16) {
+    return SetField<uint16_t>(VT_JUST_U16, _just_u16, 0);
+  }
+  flatbuffers::Optional<uint16_t> maybe_u16() const {
+    return GetOptional<uint16_t, uint16_t>(VT_MAYBE_U16);
+  }
+  bool mutate_maybe_u16(uint16_t _maybe_u16) {
+    return SetField<uint16_t>(VT_MAYBE_U16, _maybe_u16);
+  }
+  uint16_t default_u16() const {
+    return GetField<uint16_t>(VT_DEFAULT_U16, 42);
+  }
+  bool mutate_default_u16(uint16_t _default_u16) {
+    return SetField<uint16_t>(VT_DEFAULT_U16, _default_u16, 42);
+  }
+  int32_t just_i32() const {
+    return GetField<int32_t>(VT_JUST_I32, 0);
+  }
+  bool mutate_just_i32(int32_t _just_i32) {
+    return SetField<int32_t>(VT_JUST_I32, _just_i32, 0);
+  }
+  flatbuffers::Optional<int32_t> maybe_i32() const {
+    return GetOptional<int32_t, int32_t>(VT_MAYBE_I32);
+  }
+  bool mutate_maybe_i32(int32_t _maybe_i32) {
+    return SetField<int32_t>(VT_MAYBE_I32, _maybe_i32);
+  }
+  int32_t default_i32() const {
+    return GetField<int32_t>(VT_DEFAULT_I32, 42);
+  }
+  bool mutate_default_i32(int32_t _default_i32) {
+    return SetField<int32_t>(VT_DEFAULT_I32, _default_i32, 42);
+  }
+  uint32_t just_u32() const {
+    return GetField<uint32_t>(VT_JUST_U32, 0);
+  }
+  bool mutate_just_u32(uint32_t _just_u32) {
+    return SetField<uint32_t>(VT_JUST_U32, _just_u32, 0);
+  }
+  flatbuffers::Optional<uint32_t> maybe_u32() const {
+    return GetOptional<uint32_t, uint32_t>(VT_MAYBE_U32);
+  }
+  bool mutate_maybe_u32(uint32_t _maybe_u32) {
+    return SetField<uint32_t>(VT_MAYBE_U32, _maybe_u32);
+  }
+  uint32_t default_u32() const {
+    return GetField<uint32_t>(VT_DEFAULT_U32, 42);
+  }
+  bool mutate_default_u32(uint32_t _default_u32) {
+    return SetField<uint32_t>(VT_DEFAULT_U32, _default_u32, 42);
+  }
+  int64_t just_i64() const {
+    return GetField<int64_t>(VT_JUST_I64, 0);
+  }
+  bool mutate_just_i64(int64_t _just_i64) {
+    return SetField<int64_t>(VT_JUST_I64, _just_i64, 0);
+  }
+  flatbuffers::Optional<int64_t> maybe_i64() const {
+    return GetOptional<int64_t, int64_t>(VT_MAYBE_I64);
+  }
+  bool mutate_maybe_i64(int64_t _maybe_i64) {
+    return SetField<int64_t>(VT_MAYBE_I64, _maybe_i64);
+  }
+  int64_t default_i64() const {
+    return GetField<int64_t>(VT_DEFAULT_I64, 42LL);
+  }
+  bool mutate_default_i64(int64_t _default_i64) {
+    return SetField<int64_t>(VT_DEFAULT_I64, _default_i64, 42LL);
+  }
+  uint64_t just_u64() const {
+    return GetField<uint64_t>(VT_JUST_U64, 0);
+  }
+  bool mutate_just_u64(uint64_t _just_u64) {
+    return SetField<uint64_t>(VT_JUST_U64, _just_u64, 0);
+  }
+  flatbuffers::Optional<uint64_t> maybe_u64() const {
+    return GetOptional<uint64_t, uint64_t>(VT_MAYBE_U64);
+  }
+  bool mutate_maybe_u64(uint64_t _maybe_u64) {
+    return SetField<uint64_t>(VT_MAYBE_U64, _maybe_u64);
+  }
+  uint64_t default_u64() const {
+    return GetField<uint64_t>(VT_DEFAULT_U64, 42ULL);
+  }
+  bool mutate_default_u64(uint64_t _default_u64) {
+    return SetField<uint64_t>(VT_DEFAULT_U64, _default_u64, 42ULL);
+  }
+  float just_f32() const {
+    return GetField<float>(VT_JUST_F32, 0.0f);
+  }
+  bool mutate_just_f32(float _just_f32) {
+    return SetField<float>(VT_JUST_F32, _just_f32, 0.0f);
+  }
+  flatbuffers::Optional<float> maybe_f32() const {
+    return GetOptional<float, float>(VT_MAYBE_F32);
+  }
+  bool mutate_maybe_f32(float _maybe_f32) {
+    return SetField<float>(VT_MAYBE_F32, _maybe_f32);
+  }
+  float default_f32() const {
+    return GetField<float>(VT_DEFAULT_F32, 42.0f);
+  }
+  bool mutate_default_f32(float _default_f32) {
+    return SetField<float>(VT_DEFAULT_F32, _default_f32, 42.0f);
+  }
+  double just_f64() const {
+    return GetField<double>(VT_JUST_F64, 0.0);
+  }
+  bool mutate_just_f64(double _just_f64) {
+    return SetField<double>(VT_JUST_F64, _just_f64, 0.0);
+  }
+  flatbuffers::Optional<double> maybe_f64() const {
+    return GetOptional<double, double>(VT_MAYBE_F64);
+  }
+  bool mutate_maybe_f64(double _maybe_f64) {
+    return SetField<double>(VT_MAYBE_F64, _maybe_f64);
+  }
+  double default_f64() const {
+    return GetField<double>(VT_DEFAULT_F64, 42.0);
+  }
+  bool mutate_default_f64(double _default_f64) {
+    return SetField<double>(VT_DEFAULT_F64, _default_f64, 42.0);
+  }
+  bool just_bool() const {
+    return GetField<uint8_t>(VT_JUST_BOOL, 0) != 0;
+  }
+  bool mutate_just_bool(bool _just_bool) {
+    return SetField<uint8_t>(VT_JUST_BOOL, static_cast<uint8_t>(_just_bool), 0);
+  }
+  flatbuffers::Optional<bool> maybe_bool() const {
+    return GetOptional<uint8_t, bool>(VT_MAYBE_BOOL);
+  }
+  bool mutate_maybe_bool(bool _maybe_bool) {
+    return SetField<uint8_t>(VT_MAYBE_BOOL, static_cast<uint8_t>(_maybe_bool));
+  }
+  bool default_bool() const {
+    return GetField<uint8_t>(VT_DEFAULT_BOOL, 1) != 0;
+  }
+  bool mutate_default_bool(bool _default_bool) {
+    return SetField<uint8_t>(VT_DEFAULT_BOOL, static_cast<uint8_t>(_default_bool), 1);
+  }
+  optional_scalars::OptionalByte just_enum() const {
+    return static_cast<optional_scalars::OptionalByte>(GetField<int8_t>(VT_JUST_ENUM, 0));
+  }
+  bool mutate_just_enum(optional_scalars::OptionalByte _just_enum) {
+    return SetField<int8_t>(VT_JUST_ENUM, static_cast<int8_t>(_just_enum), 0);
+  }
+  flatbuffers::Optional<optional_scalars::OptionalByte> maybe_enum() const {
+    return GetOptional<int8_t, optional_scalars::OptionalByte>(VT_MAYBE_ENUM);
+  }
+  bool mutate_maybe_enum(optional_scalars::OptionalByte _maybe_enum) {
+    return SetField<int8_t>(VT_MAYBE_ENUM, static_cast<int8_t>(_maybe_enum));
+  }
+  optional_scalars::OptionalByte default_enum() const {
+    return static_cast<optional_scalars::OptionalByte>(GetField<int8_t>(VT_DEFAULT_ENUM, 1));
+  }
+  bool mutate_default_enum(optional_scalars::OptionalByte _default_enum) {
+    return SetField<int8_t>(VT_DEFAULT_ENUM, static_cast<int8_t>(_default_enum), 1);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<int8_t>(verifier, VT_JUST_I8) &&
+           VerifyField<int8_t>(verifier, VT_MAYBE_I8) &&
+           VerifyField<int8_t>(verifier, VT_DEFAULT_I8) &&
+           VerifyField<uint8_t>(verifier, VT_JUST_U8) &&
+           VerifyField<uint8_t>(verifier, VT_MAYBE_U8) &&
+           VerifyField<uint8_t>(verifier, VT_DEFAULT_U8) &&
+           VerifyField<int16_t>(verifier, VT_JUST_I16) &&
+           VerifyField<int16_t>(verifier, VT_MAYBE_I16) &&
+           VerifyField<int16_t>(verifier, VT_DEFAULT_I16) &&
+           VerifyField<uint16_t>(verifier, VT_JUST_U16) &&
+           VerifyField<uint16_t>(verifier, VT_MAYBE_U16) &&
+           VerifyField<uint16_t>(verifier, VT_DEFAULT_U16) &&
+           VerifyField<int32_t>(verifier, VT_JUST_I32) &&
+           VerifyField<int32_t>(verifier, VT_MAYBE_I32) &&
+           VerifyField<int32_t>(verifier, VT_DEFAULT_I32) &&
+           VerifyField<uint32_t>(verifier, VT_JUST_U32) &&
+           VerifyField<uint32_t>(verifier, VT_MAYBE_U32) &&
+           VerifyField<uint32_t>(verifier, VT_DEFAULT_U32) &&
+           VerifyField<int64_t>(verifier, VT_JUST_I64) &&
+           VerifyField<int64_t>(verifier, VT_MAYBE_I64) &&
+           VerifyField<int64_t>(verifier, VT_DEFAULT_I64) &&
+           VerifyField<uint64_t>(verifier, VT_JUST_U64) &&
+           VerifyField<uint64_t>(verifier, VT_MAYBE_U64) &&
+           VerifyField<uint64_t>(verifier, VT_DEFAULT_U64) &&
+           VerifyField<float>(verifier, VT_JUST_F32) &&
+           VerifyField<float>(verifier, VT_MAYBE_F32) &&
+           VerifyField<float>(verifier, VT_DEFAULT_F32) &&
+           VerifyField<double>(verifier, VT_JUST_F64) &&
+           VerifyField<double>(verifier, VT_MAYBE_F64) &&
+           VerifyField<double>(verifier, VT_DEFAULT_F64) &&
+           VerifyField<uint8_t>(verifier, VT_JUST_BOOL) &&
+           VerifyField<uint8_t>(verifier, VT_MAYBE_BOOL) &&
+           VerifyField<uint8_t>(verifier, VT_DEFAULT_BOOL) &&
+           VerifyField<int8_t>(verifier, VT_JUST_ENUM) &&
+           VerifyField<int8_t>(verifier, VT_MAYBE_ENUM) &&
+           VerifyField<int8_t>(verifier, VT_DEFAULT_ENUM) &&
+           verifier.EndTable();
+  }
+  ScalarStuffT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(ScalarStuffT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<ScalarStuff> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ScalarStuffT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct ScalarStuffBuilder {
+  typedef ScalarStuff Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_just_i8(int8_t just_i8) {
+    fbb_.AddElement<int8_t>(ScalarStuff::VT_JUST_I8, just_i8, 0);
+  }
+  void add_maybe_i8(int8_t maybe_i8) {
+    fbb_.AddElement<int8_t>(ScalarStuff::VT_MAYBE_I8, maybe_i8);
+  }
+  void add_default_i8(int8_t default_i8) {
+    fbb_.AddElement<int8_t>(ScalarStuff::VT_DEFAULT_I8, default_i8, 42);
+  }
+  void add_just_u8(uint8_t just_u8) {
+    fbb_.AddElement<uint8_t>(ScalarStuff::VT_JUST_U8, just_u8, 0);
+  }
+  void add_maybe_u8(uint8_t maybe_u8) {
+    fbb_.AddElement<uint8_t>(ScalarStuff::VT_MAYBE_U8, maybe_u8);
+  }
+  void add_default_u8(uint8_t default_u8) {
+    fbb_.AddElement<uint8_t>(ScalarStuff::VT_DEFAULT_U8, default_u8, 42);
+  }
+  void add_just_i16(int16_t just_i16) {
+    fbb_.AddElement<int16_t>(ScalarStuff::VT_JUST_I16, just_i16, 0);
+  }
+  void add_maybe_i16(int16_t maybe_i16) {
+    fbb_.AddElement<int16_t>(ScalarStuff::VT_MAYBE_I16, maybe_i16);
+  }
+  void add_default_i16(int16_t default_i16) {
+    fbb_.AddElement<int16_t>(ScalarStuff::VT_DEFAULT_I16, default_i16, 42);
+  }
+  void add_just_u16(uint16_t just_u16) {
+    fbb_.AddElement<uint16_t>(ScalarStuff::VT_JUST_U16, just_u16, 0);
+  }
+  void add_maybe_u16(uint16_t maybe_u16) {
+    fbb_.AddElement<uint16_t>(ScalarStuff::VT_MAYBE_U16, maybe_u16);
+  }
+  void add_default_u16(uint16_t default_u16) {
+    fbb_.AddElement<uint16_t>(ScalarStuff::VT_DEFAULT_U16, default_u16, 42);
+  }
+  void add_just_i32(int32_t just_i32) {
+    fbb_.AddElement<int32_t>(ScalarStuff::VT_JUST_I32, just_i32, 0);
+  }
+  void add_maybe_i32(int32_t maybe_i32) {
+    fbb_.AddElement<int32_t>(ScalarStuff::VT_MAYBE_I32, maybe_i32);
+  }
+  void add_default_i32(int32_t default_i32) {
+    fbb_.AddElement<int32_t>(ScalarStuff::VT_DEFAULT_I32, default_i32, 42);
+  }
+  void add_just_u32(uint32_t just_u32) {
+    fbb_.AddElement<uint32_t>(ScalarStuff::VT_JUST_U32, just_u32, 0);
+  }
+  void add_maybe_u32(uint32_t maybe_u32) {
+    fbb_.AddElement<uint32_t>(ScalarStuff::VT_MAYBE_U32, maybe_u32);
+  }
+  void add_default_u32(uint32_t default_u32) {
+    fbb_.AddElement<uint32_t>(ScalarStuff::VT_DEFAULT_U32, default_u32, 42);
+  }
+  void add_just_i64(int64_t just_i64) {
+    fbb_.AddElement<int64_t>(ScalarStuff::VT_JUST_I64, just_i64, 0);
+  }
+  void add_maybe_i64(int64_t maybe_i64) {
+    fbb_.AddElement<int64_t>(ScalarStuff::VT_MAYBE_I64, maybe_i64);
+  }
+  void add_default_i64(int64_t default_i64) {
+    fbb_.AddElement<int64_t>(ScalarStuff::VT_DEFAULT_I64, default_i64, 42LL);
+  }
+  void add_just_u64(uint64_t just_u64) {
+    fbb_.AddElement<uint64_t>(ScalarStuff::VT_JUST_U64, just_u64, 0);
+  }
+  void add_maybe_u64(uint64_t maybe_u64) {
+    fbb_.AddElement<uint64_t>(ScalarStuff::VT_MAYBE_U64, maybe_u64);
+  }
+  void add_default_u64(uint64_t default_u64) {
+    fbb_.AddElement<uint64_t>(ScalarStuff::VT_DEFAULT_U64, default_u64, 42ULL);
+  }
+  void add_just_f32(float just_f32) {
+    fbb_.AddElement<float>(ScalarStuff::VT_JUST_F32, just_f32, 0.0f);
+  }
+  void add_maybe_f32(float maybe_f32) {
+    fbb_.AddElement<float>(ScalarStuff::VT_MAYBE_F32, maybe_f32);
+  }
+  void add_default_f32(float default_f32) {
+    fbb_.AddElement<float>(ScalarStuff::VT_DEFAULT_F32, default_f32, 42.0f);
+  }
+  void add_just_f64(double just_f64) {
+    fbb_.AddElement<double>(ScalarStuff::VT_JUST_F64, just_f64, 0.0);
+  }
+  void add_maybe_f64(double maybe_f64) {
+    fbb_.AddElement<double>(ScalarStuff::VT_MAYBE_F64, maybe_f64);
+  }
+  void add_default_f64(double default_f64) {
+    fbb_.AddElement<double>(ScalarStuff::VT_DEFAULT_F64, default_f64, 42.0);
+  }
+  void add_just_bool(bool just_bool) {
+    fbb_.AddElement<uint8_t>(ScalarStuff::VT_JUST_BOOL, static_cast<uint8_t>(just_bool), 0);
+  }
+  void add_maybe_bool(bool maybe_bool) {
+    fbb_.AddElement<uint8_t>(ScalarStuff::VT_MAYBE_BOOL, static_cast<uint8_t>(maybe_bool));
+  }
+  void add_default_bool(bool default_bool) {
+    fbb_.AddElement<uint8_t>(ScalarStuff::VT_DEFAULT_BOOL, static_cast<uint8_t>(default_bool), 1);
+  }
+  void add_just_enum(optional_scalars::OptionalByte just_enum) {
+    fbb_.AddElement<int8_t>(ScalarStuff::VT_JUST_ENUM, static_cast<int8_t>(just_enum), 0);
+  }
+  void add_maybe_enum(optional_scalars::OptionalByte maybe_enum) {
+    fbb_.AddElement<int8_t>(ScalarStuff::VT_MAYBE_ENUM, static_cast<int8_t>(maybe_enum));
+  }
+  void add_default_enum(optional_scalars::OptionalByte default_enum) {
+    fbb_.AddElement<int8_t>(ScalarStuff::VT_DEFAULT_ENUM, static_cast<int8_t>(default_enum), 1);
+  }
+  explicit ScalarStuffBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  flatbuffers::Offset<ScalarStuff> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<ScalarStuff>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<ScalarStuff> CreateScalarStuff(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    int8_t just_i8 = 0,
+    flatbuffers::Optional<int8_t> maybe_i8 = flatbuffers::nullopt,
+    int8_t default_i8 = 42,
+    uint8_t just_u8 = 0,
+    flatbuffers::Optional<uint8_t> maybe_u8 = flatbuffers::nullopt,
+    uint8_t default_u8 = 42,
+    int16_t just_i16 = 0,
+    flatbuffers::Optional<int16_t> maybe_i16 = flatbuffers::nullopt,
+    int16_t default_i16 = 42,
+    uint16_t just_u16 = 0,
+    flatbuffers::Optional<uint16_t> maybe_u16 = flatbuffers::nullopt,
+    uint16_t default_u16 = 42,
+    int32_t just_i32 = 0,
+    flatbuffers::Optional<int32_t> maybe_i32 = flatbuffers::nullopt,
+    int32_t default_i32 = 42,
+    uint32_t just_u32 = 0,
+    flatbuffers::Optional<uint32_t> maybe_u32 = flatbuffers::nullopt,
+    uint32_t default_u32 = 42,
+    int64_t just_i64 = 0,
+    flatbuffers::Optional<int64_t> maybe_i64 = flatbuffers::nullopt,
+    int64_t default_i64 = 42LL,
+    uint64_t just_u64 = 0,
+    flatbuffers::Optional<uint64_t> maybe_u64 = flatbuffers::nullopt,
+    uint64_t default_u64 = 42ULL,
+    float just_f32 = 0.0f,
+    flatbuffers::Optional<float> maybe_f32 = flatbuffers::nullopt,
+    float default_f32 = 42.0f,
+    double just_f64 = 0.0,
+    flatbuffers::Optional<double> maybe_f64 = flatbuffers::nullopt,
+    double default_f64 = 42.0,
+    bool just_bool = false,
+    flatbuffers::Optional<bool> maybe_bool = flatbuffers::nullopt,
+    bool default_bool = true,
+    optional_scalars::OptionalByte just_enum = optional_scalars::OptionalByte_None,
+    flatbuffers::Optional<optional_scalars::OptionalByte> maybe_enum = flatbuffers::nullopt,
+    optional_scalars::OptionalByte default_enum = optional_scalars::OptionalByte_One) {
+  ScalarStuffBuilder builder_(_fbb);
+  builder_.add_default_f64(default_f64);
+  if(maybe_f64) { builder_.add_maybe_f64(*maybe_f64); }
+  builder_.add_just_f64(just_f64);
+  builder_.add_default_u64(default_u64);
+  if(maybe_u64) { builder_.add_maybe_u64(*maybe_u64); }
+  builder_.add_just_u64(just_u64);
+  builder_.add_default_i64(default_i64);
+  if(maybe_i64) { builder_.add_maybe_i64(*maybe_i64); }
+  builder_.add_just_i64(just_i64);
+  builder_.add_default_f32(default_f32);
+  if(maybe_f32) { builder_.add_maybe_f32(*maybe_f32); }
+  builder_.add_just_f32(just_f32);
+  builder_.add_default_u32(default_u32);
+  if(maybe_u32) { builder_.add_maybe_u32(*maybe_u32); }
+  builder_.add_just_u32(just_u32);
+  builder_.add_default_i32(default_i32);
+  if(maybe_i32) { builder_.add_maybe_i32(*maybe_i32); }
+  builder_.add_just_i32(just_i32);
+  builder_.add_default_u16(default_u16);
+  if(maybe_u16) { builder_.add_maybe_u16(*maybe_u16); }
+  builder_.add_just_u16(just_u16);
+  builder_.add_default_i16(default_i16);
+  if(maybe_i16) { builder_.add_maybe_i16(*maybe_i16); }
+  builder_.add_just_i16(just_i16);
+  builder_.add_default_enum(default_enum);
+  if(maybe_enum) { builder_.add_maybe_enum(*maybe_enum); }
+  builder_.add_just_enum(just_enum);
+  builder_.add_default_bool(default_bool);
+  if(maybe_bool) { builder_.add_maybe_bool(*maybe_bool); }
+  builder_.add_just_bool(just_bool);
+  builder_.add_default_u8(default_u8);
+  if(maybe_u8) { builder_.add_maybe_u8(*maybe_u8); }
+  builder_.add_just_u8(just_u8);
+  builder_.add_default_i8(default_i8);
+  if(maybe_i8) { builder_.add_maybe_i8(*maybe_i8); }
+  builder_.add_just_i8(just_i8);
+  return builder_.Finish();
+}
+
+flatbuffers::Offset<ScalarStuff> CreateScalarStuff(flatbuffers::FlatBufferBuilder &_fbb, const ScalarStuffT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+inline ScalarStuffT *ScalarStuff::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  flatbuffers::unique_ptr<optional_scalars::ScalarStuffT> _o = flatbuffers::unique_ptr<optional_scalars::ScalarStuffT>(new ScalarStuffT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void ScalarStuff::UnPackTo(ScalarStuffT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = just_i8(); _o->just_i8 = _e; }
+  { auto _e = maybe_i8(); _o->maybe_i8 = _e; }
+  { auto _e = default_i8(); _o->default_i8 = _e; }
+  { auto _e = just_u8(); _o->just_u8 = _e; }
+  { auto _e = maybe_u8(); _o->maybe_u8 = _e; }
+  { auto _e = default_u8(); _o->default_u8 = _e; }
+  { auto _e = just_i16(); _o->just_i16 = _e; }
+  { auto _e = maybe_i16(); _o->maybe_i16 = _e; }
+  { auto _e = default_i16(); _o->default_i16 = _e; }
+  { auto _e = just_u16(); _o->just_u16 = _e; }
+  { auto _e = maybe_u16(); _o->maybe_u16 = _e; }
+  { auto _e = default_u16(); _o->default_u16 = _e; }
+  { auto _e = just_i32(); _o->just_i32 = _e; }
+  { auto _e = maybe_i32(); _o->maybe_i32 = _e; }
+  { auto _e = default_i32(); _o->default_i32 = _e; }
+  { auto _e = just_u32(); _o->just_u32 = _e; }
+  { auto _e = maybe_u32(); _o->maybe_u32 = _e; }
+  { auto _e = default_u32(); _o->default_u32 = _e; }
+  { auto _e = just_i64(); _o->just_i64 = _e; }
+  { auto _e = maybe_i64(); _o->maybe_i64 = _e; }
+  { auto _e = default_i64(); _o->default_i64 = _e; }
+  { auto _e = just_u64(); _o->just_u64 = _e; }
+  { auto _e = maybe_u64(); _o->maybe_u64 = _e; }
+  { auto _e = default_u64(); _o->default_u64 = _e; }
+  { auto _e = just_f32(); _o->just_f32 = _e; }
+  { auto _e = maybe_f32(); _o->maybe_f32 = _e; }
+  { auto _e = default_f32(); _o->default_f32 = _e; }
+  { auto _e = just_f64(); _o->just_f64 = _e; }
+  { auto _e = maybe_f64(); _o->maybe_f64 = _e; }
+  { auto _e = default_f64(); _o->default_f64 = _e; }
+  { auto _e = just_bool(); _o->just_bool = _e; }
+  { auto _e = maybe_bool(); _o->maybe_bool = _e; }
+  { auto _e = default_bool(); _o->default_bool = _e; }
+  { auto _e = just_enum(); _o->just_enum = _e; }
+  { auto _e = maybe_enum(); _o->maybe_enum = _e; }
+  { auto _e = default_enum(); _o->default_enum = _e; }
+}
+
+inline flatbuffers::Offset<ScalarStuff> ScalarStuff::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ScalarStuffT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreateScalarStuff(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<ScalarStuff> CreateScalarStuff(flatbuffers::FlatBufferBuilder &_fbb, const ScalarStuffT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ScalarStuffT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _just_i8 = _o->just_i8;
+  auto _maybe_i8 = _o->maybe_i8;
+  auto _default_i8 = _o->default_i8;
+  auto _just_u8 = _o->just_u8;
+  auto _maybe_u8 = _o->maybe_u8;
+  auto _default_u8 = _o->default_u8;
+  auto _just_i16 = _o->just_i16;
+  auto _maybe_i16 = _o->maybe_i16;
+  auto _default_i16 = _o->default_i16;
+  auto _just_u16 = _o->just_u16;
+  auto _maybe_u16 = _o->maybe_u16;
+  auto _default_u16 = _o->default_u16;
+  auto _just_i32 = _o->just_i32;
+  auto _maybe_i32 = _o->maybe_i32;
+  auto _default_i32 = _o->default_i32;
+  auto _just_u32 = _o->just_u32;
+  auto _maybe_u32 = _o->maybe_u32;
+  auto _default_u32 = _o->default_u32;
+  auto _just_i64 = _o->just_i64;
+  auto _maybe_i64 = _o->maybe_i64;
+  auto _default_i64 = _o->default_i64;
+  auto _just_u64 = _o->just_u64;
+  auto _maybe_u64 = _o->maybe_u64;
+  auto _default_u64 = _o->default_u64;
+  auto _just_f32 = _o->just_f32;
+  auto _maybe_f32 = _o->maybe_f32;
+  auto _default_f32 = _o->default_f32;
+  auto _just_f64 = _o->just_f64;
+  auto _maybe_f64 = _o->maybe_f64;
+  auto _default_f64 = _o->default_f64;
+  auto _just_bool = _o->just_bool;
+  auto _maybe_bool = _o->maybe_bool;
+  auto _default_bool = _o->default_bool;
+  auto _just_enum = _o->just_enum;
+  auto _maybe_enum = _o->maybe_enum;
+  auto _default_enum = _o->default_enum;
+  return optional_scalars::CreateScalarStuff(
+      _fbb,
+      _just_i8,
+      _maybe_i8,
+      _default_i8,
+      _just_u8,
+      _maybe_u8,
+      _default_u8,
+      _just_i16,
+      _maybe_i16,
+      _default_i16,
+      _just_u16,
+      _maybe_u16,
+      _default_u16,
+      _just_i32,
+      _maybe_i32,
+      _default_i32,
+      _just_u32,
+      _maybe_u32,
+      _default_u32,
+      _just_i64,
+      _maybe_i64,
+      _default_i64,
+      _just_u64,
+      _maybe_u64,
+      _default_u64,
+      _just_f32,
+      _maybe_f32,
+      _default_f32,
+      _just_f64,
+      _maybe_f64,
+      _default_f64,
+      _just_bool,
+      _maybe_bool,
+      _default_bool,
+      _just_enum,
+      _maybe_enum,
+      _default_enum);
+}
+
+inline const flatbuffers::TypeTable *OptionalByteTypeTable() {
+  static const flatbuffers::TypeCode type_codes[] = {
+    { flatbuffers::ET_CHAR, 0, 0 },
+    { flatbuffers::ET_CHAR, 0, 0 },
+    { flatbuffers::ET_CHAR, 0, 0 }
+  };
+  static const flatbuffers::TypeFunction type_refs[] = {
+    optional_scalars::OptionalByteTypeTable
+  };
+  static const char * const names[] = {
+    "None",
+    "One",
+    "Two"
+  };
+  static const flatbuffers::TypeTable tt = {
+    flatbuffers::ST_ENUM, 3, type_codes, type_refs, nullptr, nullptr, names
+  };
+  return &tt;
+}
+
+inline const flatbuffers::TypeTable *ScalarStuffTypeTable() {
+  static const flatbuffers::TypeCode type_codes[] = {
+    { flatbuffers::ET_CHAR, 0, -1 },
+    { flatbuffers::ET_CHAR, 0, -1 },
+    { flatbuffers::ET_CHAR, 0, -1 },
+    { flatbuffers::ET_UCHAR, 0, -1 },
+    { flatbuffers::ET_UCHAR, 0, -1 },
+    { flatbuffers::ET_UCHAR, 0, -1 },
+    { flatbuffers::ET_SHORT, 0, -1 },
+    { flatbuffers::ET_SHORT, 0, -1 },
+    { flatbuffers::ET_SHORT, 0, -1 },
+    { flatbuffers::ET_USHORT, 0, -1 },
+    { flatbuffers::ET_USHORT, 0, -1 },
+    { flatbuffers::ET_USHORT, 0, -1 },
+    { flatbuffers::ET_INT, 0, -1 },
+    { flatbuffers::ET_INT, 0, -1 },
+    { flatbuffers::ET_INT, 0, -1 },
+    { flatbuffers::ET_UINT, 0, -1 },
+    { flatbuffers::ET_UINT, 0, -1 },
+    { flatbuffers::ET_UINT, 0, -1 },
+    { flatbuffers::ET_LONG, 0, -1 },
+    { flatbuffers::ET_LONG, 0, -1 },
+    { flatbuffers::ET_LONG, 0, -1 },
+    { flatbuffers::ET_ULONG, 0, -1 },
+    { flatbuffers::ET_ULONG, 0, -1 },
+    { flatbuffers::ET_ULONG, 0, -1 },
+    { flatbuffers::ET_FLOAT, 0, -1 },
+    { flatbuffers::ET_FLOAT, 0, -1 },
+    { flatbuffers::ET_FLOAT, 0, -1 },
+    { flatbuffers::ET_DOUBLE, 0, -1 },
+    { flatbuffers::ET_DOUBLE, 0, -1 },
+    { flatbuffers::ET_DOUBLE, 0, -1 },
+    { flatbuffers::ET_BOOL, 0, -1 },
+    { flatbuffers::ET_BOOL, 0, -1 },
+    { flatbuffers::ET_BOOL, 0, -1 },
+    { flatbuffers::ET_CHAR, 0, 0 },
+    { flatbuffers::ET_CHAR, 0, 0 },
+    { flatbuffers::ET_CHAR, 0, 0 }
+  };
+  static const flatbuffers::TypeFunction type_refs[] = {
+    optional_scalars::OptionalByteTypeTable
+  };
+  static const char * const names[] = {
+    "just_i8",
+    "maybe_i8",
+    "default_i8",
+    "just_u8",
+    "maybe_u8",
+    "default_u8",
+    "just_i16",
+    "maybe_i16",
+    "default_i16",
+    "just_u16",
+    "maybe_u16",
+    "default_u16",
+    "just_i32",
+    "maybe_i32",
+    "default_i32",
+    "just_u32",
+    "maybe_u32",
+    "default_u32",
+    "just_i64",
+    "maybe_i64",
+    "default_i64",
+    "just_u64",
+    "maybe_u64",
+    "default_u64",
+    "just_f32",
+    "maybe_f32",
+    "default_f32",
+    "just_f64",
+    "maybe_f64",
+    "default_f64",
+    "just_bool",
+    "maybe_bool",
+    "default_bool",
+    "just_enum",
+    "maybe_enum",
+    "default_enum"
+  };
+  static const flatbuffers::TypeTable tt = {
+    flatbuffers::ST_TABLE, 36, type_codes, type_refs, nullptr, nullptr, names
+  };
+  return &tt;
+}
+
+inline const optional_scalars::ScalarStuff *GetScalarStuff(const void *buf) {
+  return flatbuffers::GetRoot<optional_scalars::ScalarStuff>(buf);
+}
+
+inline const optional_scalars::ScalarStuff *GetSizePrefixedScalarStuff(const void *buf) {
+  return flatbuffers::GetSizePrefixedRoot<optional_scalars::ScalarStuff>(buf);
+}
+
+inline ScalarStuff *GetMutableScalarStuff(void *buf) {
+  return flatbuffers::GetMutableRoot<ScalarStuff>(buf);
+}
+
+inline const char *ScalarStuffIdentifier() {
+  return "NULL";
+}
+
+inline bool ScalarStuffBufferHasIdentifier(const void *buf) {
+  return flatbuffers::BufferHasIdentifier(
+      buf, ScalarStuffIdentifier());
+}
+
+inline bool VerifyScalarStuffBuffer(
+    flatbuffers::Verifier &verifier) {
+  return verifier.VerifyBuffer<optional_scalars::ScalarStuff>(ScalarStuffIdentifier());
+}
+
+inline bool VerifySizePrefixedScalarStuffBuffer(
+    flatbuffers::Verifier &verifier) {
+  return verifier.VerifySizePrefixedBuffer<optional_scalars::ScalarStuff>(ScalarStuffIdentifier());
+}
+
+inline const char *ScalarStuffExtension() {
+  return "mon";
+}
+
+inline void FinishScalarStuffBuffer(
+    flatbuffers::FlatBufferBuilder &fbb,
+    flatbuffers::Offset<optional_scalars::ScalarStuff> root) {
+  fbb.Finish(root, ScalarStuffIdentifier());
+}
+
+inline void FinishSizePrefixedScalarStuffBuffer(
+    flatbuffers::FlatBufferBuilder &fbb,
+    flatbuffers::Offset<optional_scalars::ScalarStuff> root) {
+  fbb.FinishSizePrefixed(root, ScalarStuffIdentifier());
+}
+
+inline flatbuffers::unique_ptr<optional_scalars::ScalarStuffT> UnPackScalarStuff(
+    const void *buf,
+    const flatbuffers::resolver_function_t *res = nullptr) {
+  return flatbuffers::unique_ptr<optional_scalars::ScalarStuffT>(GetScalarStuff(buf)->UnPack(res));
+}
+
+inline flatbuffers::unique_ptr<optional_scalars::ScalarStuffT> UnPackSizePrefixedScalarStuff(
+    const void *buf,
+    const flatbuffers::resolver_function_t *res = nullptr) {
+  return flatbuffers::unique_ptr<optional_scalars::ScalarStuffT>(GetSizePrefixedScalarStuff(buf)->UnPack(res));
+}
+
+}  // namespace optional_scalars
+
+#endif  // FLATBUFFERS_GENERATED_OPTIONALSCALARS_OPTIONAL_SCALARS_H_