Merge branch 'master' into master

tests/.gitignore

@@ -0,0 +1,2 @@
+# Generated files shouldn't be checked in for tests.
+**_generated.h

tests/64bit/evolution/v1.fbs

@@ -0,0 +1,8 @@
+namespace v1;
+
+table RootTable {
+  a:float;
+  b:[uint8];
+}
+
+root_type RootTable;

tests/64bit/evolution/v1_generated.h

@@ -0,0 +1,219 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+
+#ifndef FLATBUFFERS_GENERATED_V1_V1_H_
+#define FLATBUFFERS_GENERATED_V1_V1_H_
+
+#include "flatbuffers/flatbuffers.h"
+
+// Ensure the included flatbuffers.h is the same version as when this file was
+// generated, otherwise it may not be compatible.
+static_assert(FLATBUFFERS_VERSION_MAJOR == 23 &&
+              FLATBUFFERS_VERSION_MINOR == 5 &&
+              FLATBUFFERS_VERSION_REVISION == 26,
+             "Non-compatible flatbuffers version included");
+
+namespace v1 {
+
+struct RootTable;
+struct RootTableBuilder;
+struct RootTableT;
+
+bool operator==(const RootTableT &lhs, const RootTableT &rhs);
+bool operator!=(const RootTableT &lhs, const RootTableT &rhs);
+
+inline const ::flatbuffers::TypeTable *RootTableTypeTable();
+
+struct RootTableT : public ::flatbuffers::NativeTable {
+  typedef RootTable TableType;
+  float a = 0.0f;
+  std::vector<uint8_t> b{};
+};
+
+struct RootTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef RootTableT NativeTableType;
+  typedef RootTableBuilder Builder;
+  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
+    return RootTableTypeTable();
+  }
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_A = 4,
+    VT_B = 6
+  };
+  float a() const {
+    return GetField<float>(VT_A, 0.0f);
+  }
+  bool mutate_a(float _a = 0.0f) {
+    return SetField<float>(VT_A, _a, 0.0f);
+  }
+  const ::flatbuffers::Vector<uint8_t> *b() const {
+    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_B);
+  }
+  ::flatbuffers::Vector<uint8_t> *mutable_b() {
+    return GetPointer<::flatbuffers::Vector<uint8_t> *>(VT_B);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<float>(verifier, VT_A, 4) &&
+           VerifyOffset(verifier, VT_B) &&
+           verifier.VerifyVector(b()) &&
+           verifier.EndTable();
+  }
+  RootTableT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(RootTableT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static ::flatbuffers::Offset<RootTable> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const RootTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct RootTableBuilder {
+  typedef RootTable Table;
+  ::flatbuffers::FlatBufferBuilder &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_a(float a) {
+    fbb_.AddElement<float>(RootTable::VT_A, a, 0.0f);
+  }
+  void add_b(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> b) {
+    fbb_.AddOffset(RootTable::VT_B, b);
+  }
+  explicit RootTableBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<RootTable> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<RootTable>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<RootTable> CreateRootTable(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    float a = 0.0f,
+    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> b = 0) {
+  RootTableBuilder builder_(_fbb);
+  builder_.add_b(b);
+  builder_.add_a(a);
+  return builder_.Finish();
+}
+
+inline ::flatbuffers::Offset<RootTable> CreateRootTableDirect(
+    ::flatbuffers::FlatBufferBuilder &_fbb,
+    float a = 0.0f,
+    const std::vector<uint8_t> *b = nullptr) {
+  auto b__ = b ? _fbb.CreateVector<uint8_t>(*b) : 0;
+  return v1::CreateRootTable(
+      _fbb,
+      a,
+      b__);
+}
+
+::flatbuffers::Offset<RootTable> CreateRootTable(::flatbuffers::FlatBufferBuilder &_fbb, const RootTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+
+inline bool operator==(const RootTableT &lhs, const RootTableT &rhs) {
+  return
+      (lhs.a == rhs.a) &&
+      (lhs.b == rhs.b);
+}
+
+inline bool operator!=(const RootTableT &lhs, const RootTableT &rhs) {
+    return !(lhs == rhs);
+}
+
+
+inline RootTableT *RootTable::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
+  auto _o = std::unique_ptr<RootTableT>(new RootTableT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void RootTable::UnPackTo(RootTableT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = a(); _o->a = _e; }
+  { auto _e = b(); if (_e) { _o->b.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->b.begin()); } }
+}
+
+inline ::flatbuffers::Offset<RootTable> RootTable::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const RootTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
+  return CreateRootTable(_fbb, _o, _rehasher);
+}
+
+inline ::flatbuffers::Offset<RootTable> CreateRootTable(::flatbuffers::FlatBufferBuilder &_fbb, const RootTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const RootTableT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _a = _o->a;
+  auto _b = _o->b.size() ? _fbb.CreateVector(_o->b) : 0;
+  return v1::CreateRootTable(
+      _fbb,
+      _a,
+      _b);
+}
+
+inline const ::flatbuffers::TypeTable *RootTableTypeTable() {
+  static const ::flatbuffers::TypeCode type_codes[] = {
+    { ::flatbuffers::ET_FLOAT, 0, -1 },
+    { ::flatbuffers::ET_UCHAR, 1, -1 }
+  };
+  static const char * const names[] = {
+    "a",
+    "b"
+  };
+  static const ::flatbuffers::TypeTable tt = {
+    ::flatbuffers::ST_TABLE, 2, type_codes, nullptr, nullptr, nullptr, names
+  };
+  return &tt;
+}
+
+inline const v1::RootTable *GetRootTable(const void *buf) {
+  return ::flatbuffers::GetRoot<v1::RootTable>(buf);
+}
+
+inline const v1::RootTable *GetSizePrefixedRootTable(const void *buf) {
+  return ::flatbuffers::GetSizePrefixedRoot<v1::RootTable>(buf);
+}
+
+inline RootTable *GetMutableRootTable(void *buf) {
+  return ::flatbuffers::GetMutableRoot<RootTable>(buf);
+}
+
+inline v1::RootTable *GetMutableSizePrefixedRootTable(void *buf) {
+  return ::flatbuffers::GetMutableSizePrefixedRoot<v1::RootTable>(buf);
+}
+
+inline bool VerifyRootTableBuffer(
+    ::flatbuffers::Verifier &verifier) {
+  return verifier.VerifyBuffer<v1::RootTable>(nullptr);
+}
+
+inline bool VerifySizePrefixedRootTableBuffer(
+    ::flatbuffers::Verifier &verifier) {
+  return verifier.VerifySizePrefixedBuffer<v1::RootTable>(nullptr);
+}
+
+inline void FinishRootTableBuffer(
+    ::flatbuffers::FlatBufferBuilder &fbb,
+    ::flatbuffers::Offset<v1::RootTable> root) {
+  fbb.Finish(root);
+}
+
+inline void FinishSizePrefixedRootTableBuffer(
+    ::flatbuffers::FlatBufferBuilder &fbb,
+    ::flatbuffers::Offset<v1::RootTable> root) {
+  fbb.FinishSizePrefixed(root);
+}
+
+inline std::unique_ptr<v1::RootTableT> UnPackRootTable(
+    const void *buf,
+    const ::flatbuffers::resolver_function_t *res = nullptr) {
+  return std::unique_ptr<v1::RootTableT>(GetRootTable(buf)->UnPack(res));
+}
+
+inline std::unique_ptr<v1::RootTableT> UnPackSizePrefixedRootTable(
+    const void *buf,
+    const ::flatbuffers::resolver_function_t *res = nullptr) {
+  return std::unique_ptr<v1::RootTableT>(GetSizePrefixedRootTable(buf)->UnPack(res));
+}
+
+}  // namespace v1
+
+#endif  // FLATBUFFERS_GENERATED_V1_V1_H_

tests/64bit/evolution/v2.fbs

@@ -0,0 +1,9 @@
+namespace v2;
+
+table RootTable {
+  a:float;
+  b:[uint8];
+  big_vector:[uint8] (vector64);
+}
+
+root_type RootTable;

tests/64bit/evolution/v2_generated.h

@@ -0,0 +1,243 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+
+#ifndef FLATBUFFERS_GENERATED_V2_V2_H_
+#define FLATBUFFERS_GENERATED_V2_V2_H_
+
+#include "flatbuffers/flatbuffers.h"
+
+// Ensure the included flatbuffers.h is the same version as when this file was
+// generated, otherwise it may not be compatible.
+static_assert(FLATBUFFERS_VERSION_MAJOR == 23 &&
+              FLATBUFFERS_VERSION_MINOR == 5 &&
+              FLATBUFFERS_VERSION_REVISION == 26,
+             "Non-compatible flatbuffers version included");
+
+namespace v2 {
+
+struct RootTable;
+struct RootTableBuilder;
+struct RootTableT;
+
+bool operator==(const RootTableT &lhs, const RootTableT &rhs);
+bool operator!=(const RootTableT &lhs, const RootTableT &rhs);
+
+inline const ::flatbuffers::TypeTable *RootTableTypeTable();
+
+struct RootTableT : public ::flatbuffers::NativeTable {
+  typedef RootTable TableType;
+  float a = 0.0f;
+  std::vector<uint8_t> b{};
+  std::vector<uint8_t> big_vector{};
+};
+
+struct RootTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef RootTableT NativeTableType;
+  typedef RootTableBuilder Builder;
+  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
+    return RootTableTypeTable();
+  }
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_A = 4,
+    VT_B = 6,
+    VT_BIG_VECTOR = 8
+  };
+  float a() const {
+    return GetField<float>(VT_A, 0.0f);
+  }
+  bool mutate_a(float _a = 0.0f) {
+    return SetField<float>(VT_A, _a, 0.0f);
+  }
+  const ::flatbuffers::Vector<uint8_t> *b() const {
+    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_B);
+  }
+  ::flatbuffers::Vector<uint8_t> *mutable_b() {
+    return GetPointer<::flatbuffers::Vector<uint8_t> *>(VT_B);
+  }
+  const ::flatbuffers::Vector64<uint8_t> *big_vector() const {
+    return GetPointer64<const ::flatbuffers::Vector64<uint8_t> *>(VT_BIG_VECTOR);
+  }
+  ::flatbuffers::Vector64<uint8_t> *mutable_big_vector() {
+    return GetPointer64<::flatbuffers::Vector64<uint8_t> *>(VT_BIG_VECTOR);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<float>(verifier, VT_A, 4) &&
+           VerifyOffset(verifier, VT_B) &&
+           verifier.VerifyVector(b()) &&
+           VerifyOffset64(verifier, VT_BIG_VECTOR) &&
+           verifier.VerifyVector(big_vector()) &&
+           verifier.EndTable();
+  }
+  RootTableT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(RootTableT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static ::flatbuffers::Offset<RootTable> Pack(::flatbuffers::FlatBufferBuilder64 &_fbb, const RootTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct RootTableBuilder {
+  typedef RootTable Table;
+  ::flatbuffers::FlatBufferBuilder64 &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_a(float a) {
+    fbb_.AddElement<float>(RootTable::VT_A, a, 0.0f);
+  }
+  void add_b(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> b) {
+    fbb_.AddOffset(RootTable::VT_B, b);
+  }
+  void add_big_vector(::flatbuffers::Offset64<::flatbuffers::Vector64<uint8_t>> big_vector) {
+    fbb_.AddOffset(RootTable::VT_BIG_VECTOR, big_vector);
+  }
+  explicit RootTableBuilder(::flatbuffers::FlatBufferBuilder64 &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<RootTable> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<RootTable>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<RootTable> CreateRootTable(
+    ::flatbuffers::FlatBufferBuilder64 &_fbb,
+    float a = 0.0f,
+    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> b = 0,
+    ::flatbuffers::Offset64<::flatbuffers::Vector64<uint8_t>> big_vector = 0) {
+  RootTableBuilder builder_(_fbb);
+  builder_.add_big_vector(big_vector);
+  builder_.add_b(b);
+  builder_.add_a(a);
+  return builder_.Finish();
+}
+
+inline ::flatbuffers::Offset<RootTable> CreateRootTableDirect(
+    ::flatbuffers::FlatBufferBuilder64 &_fbb,
+    float a = 0.0f,
+    const std::vector<uint8_t> *b = nullptr,
+    const std::vector<uint8_t> *big_vector = nullptr) {
+  auto big_vector__ = big_vector ? _fbb.CreateVector64(*big_vector) : 0;
+  auto b__ = b ? _fbb.CreateVector<uint8_t>(*b) : 0;
+  return v2::CreateRootTable(
+      _fbb,
+      a,
+      b__,
+      big_vector__);
+}
+
+::flatbuffers::Offset<RootTable> CreateRootTable(::flatbuffers::FlatBufferBuilder64 &_fbb, const RootTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+
+inline bool operator==(const RootTableT &lhs, const RootTableT &rhs) {
+  return
+      (lhs.a == rhs.a) &&
+      (lhs.b == rhs.b) &&
+      (lhs.big_vector == rhs.big_vector);
+}
+
+inline bool operator!=(const RootTableT &lhs, const RootTableT &rhs) {
+    return !(lhs == rhs);
+}
+
+
+inline RootTableT *RootTable::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
+  auto _o = std::unique_ptr<RootTableT>(new RootTableT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void RootTable::UnPackTo(RootTableT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = a(); _o->a = _e; }
+  { auto _e = b(); if (_e) { _o->b.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->b.begin()); } }
+  { auto _e = big_vector(); if (_e) { _o->big_vector.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->big_vector.begin()); } }
+}
+
+inline ::flatbuffers::Offset<RootTable> RootTable::Pack(::flatbuffers::FlatBufferBuilder64 &_fbb, const RootTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
+  return CreateRootTable(_fbb, _o, _rehasher);
+}
+
+inline ::flatbuffers::Offset<RootTable> CreateRootTable(::flatbuffers::FlatBufferBuilder64 &_fbb, const RootTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { ::flatbuffers::FlatBufferBuilder64 *__fbb; const RootTableT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _a = _o->a;
+  auto _b = _o->b.size() ? _fbb.CreateVector(_o->b) : 0;
+  auto _big_vector = _o->big_vector.size() ? _fbb.CreateVector64(_o->big_vector) : 0;
+  return v2::CreateRootTable(
+      _fbb,
+      _a,
+      _b,
+      _big_vector);
+}
+
+inline const ::flatbuffers::TypeTable *RootTableTypeTable() {
+  static const ::flatbuffers::TypeCode type_codes[] = {
+    { ::flatbuffers::ET_FLOAT, 0, -1 },
+    { ::flatbuffers::ET_UCHAR, 1, -1 },
+    { ::flatbuffers::ET_UCHAR, 1, -1 }
+  };
+  static const char * const names[] = {
+    "a",
+    "b",
+    "big_vector"
+  };
+  static const ::flatbuffers::TypeTable tt = {
+    ::flatbuffers::ST_TABLE, 3, type_codes, nullptr, nullptr, nullptr, names
+  };
+  return &tt;
+}
+
+inline const v2::RootTable *GetRootTable(const void *buf) {
+  return ::flatbuffers::GetRoot<v2::RootTable>(buf);
+}
+
+inline const v2::RootTable *GetSizePrefixedRootTable(const void *buf) {
+  return ::flatbuffers::GetSizePrefixedRoot<v2::RootTable,::flatbuffers::uoffset64_t>(buf);
+}
+
+inline RootTable *GetMutableRootTable(void *buf) {
+  return ::flatbuffers::GetMutableRoot<RootTable>(buf);
+}
+
+inline v2::RootTable *GetMutableSizePrefixedRootTable(void *buf) {
+  return ::flatbuffers::GetMutableSizePrefixedRoot<v2::RootTable,::flatbuffers::uoffset64_t>(buf);
+}
+
+inline bool VerifyRootTableBuffer(
+    ::flatbuffers::Verifier &verifier) {
+  return verifier.VerifyBuffer<v2::RootTable>(nullptr);
+}
+
+inline bool VerifySizePrefixedRootTableBuffer(
+    ::flatbuffers::Verifier &verifier) {
+  return verifier.VerifySizePrefixedBuffer<v2::RootTable,::flatbuffers::uoffset64_t>(nullptr);
+}
+
+inline void FinishRootTableBuffer(
+    ::flatbuffers::FlatBufferBuilder64 &fbb,
+    ::flatbuffers::Offset<v2::RootTable> root) {
+  fbb.Finish(root);
+}
+
+inline void FinishSizePrefixedRootTableBuffer(
+    ::flatbuffers::FlatBufferBuilder64 &fbb,
+    ::flatbuffers::Offset<v2::RootTable> root) {
+  fbb.FinishSizePrefixed(root);
+}
+
+inline std::unique_ptr<v2::RootTableT> UnPackRootTable(
+    const void *buf,
+    const ::flatbuffers::resolver_function_t *res = nullptr) {
+  return std::unique_ptr<v2::RootTableT>(GetRootTable(buf)->UnPack(res));
+}
+
+inline std::unique_ptr<v2::RootTableT> UnPackSizePrefixedRootTable(
+    const void *buf,
+    const ::flatbuffers::resolver_function_t *res = nullptr) {
+  return std::unique_ptr<v2::RootTableT>(GetSizePrefixedRootTable(buf)->UnPack(res));
+}
+
+}  // namespace v2
+
+#endif  // FLATBUFFERS_GENERATED_V2_V2_H_

tests/64bit/offset64_test.cpp

@@ -0,0 +1,458 @@
+#include "offset64_test.h"
+
+#include <stdint.h>
+
+#include <cstdint>
+#include <fstream>
+#include <limits>
+#include <ostream>
+
+#include "flatbuffers/base.h"
+#include "flatbuffers/buffer.h"
+#include "flatbuffers/flatbuffer_builder.h"
+#include "flatbuffers/flatbuffers.h"
+#include "tests/64bit/evolution/v1_generated.h"
+#include "tests/64bit/evolution/v2_generated.h"
+#include "tests/64bit/test_64bit_generated.h"
+#include "tests/test_assert.h"
+
+namespace flatbuffers {
+namespace tests {
+
+void Offset64Test() {
+  FlatBufferBuilder64 builder;
+
+  const size_t far_vector_size = 1LL << 2;
+  // Make a large number if wanting to test a real large buffer.
+  const size_t big_vector_size = 1LL << 2;
+
+  {
+    // First create the vectors that will be copied to the buffer.
+    std::vector<uint8_t> far_data;
+    far_data.resize(far_vector_size);
+    far_data[0] = 4;
+    far_data[far_vector_size - 1] = 2;
+
+    std::vector<uint8_t> big_data;
+    big_data.resize(big_vector_size);
+    big_data[0] = 8;
+    big_data[big_vector_size - 1] = 3;
+
+    // Then serialize all the fields that have 64-bit offsets, as these must be
+    // serialized before any 32-bit fields are added to the buffer.
+    const Offset64<Vector<uint8_t>> far_vector_offset =
+        builder.CreateVector64<Vector>(far_data);
+
+    const Offset64<String> far_string_offset =
+        builder.CreateString<Offset64>("some far string");
+
+    const Offset64<Vector64<uint8_t>> big_vector_offset =
+        builder.CreateVector64(big_data);
+
+    // Now that we are done with the 64-bit fields, we can create and add the
+    // normal fields.
+    const Offset<String> near_string_offset =
+        builder.CreateString("some near string");
+
+    // Finish by building the root table by passing in all the offsets.
+    const Offset<RootTable> root_table_offset =
+        CreateRootTable(builder, far_vector_offset, 0, far_string_offset,
+                        big_vector_offset, near_string_offset);
+
+    // Finish the buffer.
+    builder.Finish(root_table_offset);
+
+    Verifier::Options options;
+    // Allow the verifier to verify 64-bit buffers.
+    options.max_size = FLATBUFFERS_MAX_64_BUFFER_SIZE;
+    options.assert = true;
+
+    Verifier verifier(builder.GetBufferPointer(), builder.GetSize(), options);
+
+    TEST_EQ(VerifyRootTableBuffer(verifier), true);
+  }
+
+  {
+    const RootTable *root_table = GetRootTable(builder.GetBufferPointer());
+
+    // Expect the far vector to be properly sized.
+    TEST_EQ(root_table->far_vector()->size(), far_vector_size);
+    TEST_EQ(root_table->far_vector()->Get(0), 4);
+    TEST_EQ(root_table->far_vector()->Get(far_vector_size - 1), 2);
+
+    TEST_EQ_STR(root_table->far_string()->c_str(), "some far string");
+
+    // Expect the big vector to be properly sized.
+    TEST_EQ(root_table->big_vector()->size(), big_vector_size);
+    TEST_EQ(root_table->big_vector()->Get(0), 8);
+    TEST_EQ(root_table->big_vector()->Get(big_vector_size - 1), 3);
+
+    TEST_EQ_STR(root_table->near_string()->c_str(), "some near string");
+  }
+}
+
+void Offset64SerializedFirst() {
+  FlatBufferBuilder64 fbb;
+
+  // First create the vectors that will be copied to the buffer.
+  std::vector<uint8_t> data;
+  data.resize(64);
+
+  // Then serialize all the fields that have 64-bit offsets, as these must be
+  // serialized before any 32-bit fields are added to the buffer.
+  fbb.CreateVector64(data);
+
+  // TODO(derekbailey): figure out how to test assertions.
+  // Uncommenting this line should fail the test with an assertion.
+  // fbb.CreateString("some near string");
+
+  fbb.CreateVector64(data);
+}
+
+void Offset64NestedFlatBuffer() {
+  FlatBufferBuilder64 fbb;
+
+  // First serialize a nested buffer.
+  const Offset<String> near_string_offset =
+      fbb.CreateString("nested: some near string");
+
+  // Finish by building the root table by passing in all the offsets.
+  const Offset<RootTable> root_table_offset =
+      CreateRootTable(fbb, 0, 0, 0, 0, near_string_offset, 0);
+
+  // Finish the buffer.
+  fbb.Finish(root_table_offset);
+
+  // Ensure the buffer is valid.
+  const RootTable *root_table = GetRootTable(fbb.GetBufferPointer());
+  TEST_EQ_STR(root_table->near_string()->c_str(), "nested: some near string");
+
+  // Copy the data out of the builder.
+  std::vector<uint8_t> nested_data{ fbb.GetBufferPointer(),
+                                    fbb.GetBufferPointer() + fbb.GetSize() };
+
+  {
+    // Clear so we can reuse the builder.
+    fbb.Clear();
+
+    const Offset64<Vector64<uint8_t>> nested_flatbuffer_offset =
+        fbb.CreateVector64<Vector64>(nested_data);
+
+    // Now that we are done with the 64-bit fields, we can create and add the
+    // normal fields.
+    const Offset<String> near_string_offset =
+        fbb.CreateString("some near string");
+
+    // Finish by building the root table by passing in all the offsets.
+    const Offset<RootTable> root_table_offset = CreateRootTable(
+        fbb, 0, 0, 0, 0, near_string_offset, nested_flatbuffer_offset);
+
+    // Finish the buffer.
+    fbb.Finish(root_table_offset);
+
+    Verifier::Options options;
+    // Allow the verifier to verify 64-bit buffers.
+    options.max_size = FLATBUFFERS_MAX_64_BUFFER_SIZE;
+    options.assert = true;
+
+    Verifier verifier(fbb.GetBufferPointer(), fbb.GetSize(), options);
+
+    TEST_EQ(VerifyRootTableBuffer(verifier), true);
+  }
+
+  {
+    const RootTable *root_table = GetRootTable(fbb.GetBufferPointer());
+
+    // Test that the parent buffer field is ok.
+    TEST_EQ_STR(root_table->near_string()->c_str(), "some near string");
+
+    // Expect nested buffer to be properly sized.
+    TEST_EQ(root_table->nested_root()->size(), nested_data.size());
+
+    // Expect the direct accessors to the nested buffer work.
+    TEST_EQ_STR(root_table->nested_root_nested_root()->near_string()->c_str(),
+                "nested: some near string");
+  }
+}
+
+void Offset64CreateDirect() {
+  FlatBufferBuilder64 fbb;
+
+  // Create a vector of some data
+  std::vector<uint8_t> data{ 0, 1, 2 };
+
+  // Call the "Direct" creation method to ensure that things are added to the
+  // buffer in the correct order, Offset64 first followed by any Offsets.
+  const Offset<RootTable> root_table_offset = CreateRootTableDirect(
+      fbb, &data, 0, "some far string", &data, "some near string");
+
+  // Finish the buffer.
+  fbb.Finish(root_table_offset);
+
+  Verifier::Options options;
+  // Allow the verifier to verify 64-bit buffers.
+  options.max_size = FLATBUFFERS_MAX_64_BUFFER_SIZE;
+  options.assert = true;
+
+  Verifier verifier(fbb.GetBufferPointer(), fbb.GetSize(), options);
+
+  TEST_EQ(VerifyRootTableBuffer(verifier), true);
+
+  // Verify the data.
+  const RootTable *root_table = GetRootTable(fbb.GetBufferPointer());
+  TEST_EQ(root_table->far_vector()->size(), data.size());
+  TEST_EQ(root_table->big_vector()->size(), data.size());
+  TEST_EQ_STR(root_table->far_string()->c_str(), "some far string");
+  TEST_EQ_STR(root_table->near_string()->c_str(), "some near string");
+}
+
+void Offset64Evolution() {
+  // Some common data for the tests.
+  const std::vector<uint8_t> data = { 1, 2, 3, 4 };
+  const std::vector<uint8_t> big_data = { 6, 7, 8, 9, 10 };
+
+  // Built V1 read V2
+  {
+    // Use the 32-bit builder since V1 doesn't have any 64-bit offsets.
+    FlatBufferBuilder builder;
+
+    builder.Finish(v1::CreateRootTableDirect(builder, 1234, &data));
+
+    // Use each version to get a view at the root table.
+    auto v1_root = v1::GetRootTable(builder.GetBufferPointer());
+    auto v2_root = v2::GetRootTable(builder.GetBufferPointer());
+
+    // Test field equivalents for fields common to V1 and V2.
+    TEST_EQ(v1_root->a(), v2_root->a());
+
+    TEST_EQ(v1_root->b(), v2_root->b());
+    TEST_EQ(v1_root->b()->Get(2), 3);
+    TEST_EQ(v2_root->b()->Get(2), 3);
+
+    // This field is added in V2, so it should be null since V1 couldn't have
+    // written it.
+    TEST_ASSERT(v2_root->big_vector() == nullptr);
+  }
+
+  // Built V2 read V1
+  {
+    // Use the 64-bit builder since V2 has 64-bit offsets.
+    FlatBufferBuilder64 builder;
+
+    builder.Finish(v2::CreateRootTableDirect(builder, 1234, &data, &big_data));
+
+    // Use each version to get a view at the root table.
+    auto v1_root = v1::GetRootTable(builder.GetBufferPointer());
+    auto v2_root = v2::GetRootTable(builder.GetBufferPointer());
+
+    // Test field equivalents for fields common to V1 and V2.
+    TEST_EQ(v1_root->a(), v2_root->a());
+
+    TEST_EQ(v1_root->b(), v2_root->b());
+    TEST_EQ(v1_root->b()->Get(2), 3);
+    TEST_EQ(v2_root->b()->Get(2), 3);
+
+    // Test that V2 can read the big vector, which V1 doesn't even have
+    // accessors for (i.e. v1_root->big_vector() doesn't exist).
+    TEST_ASSERT(v2_root->big_vector() != nullptr);
+    TEST_EQ(v2_root->big_vector()->size(), big_data.size());
+    TEST_EQ(v2_root->big_vector()->Get(2), 8);
+  }
+
+  // Built V2 read V1, bigger than max 32-bit buffer sized.
+  // This checks that even a large buffer can still be read by V1.
+  {
+    // Use the 64-bit builder since V2 has 64-bit offsets.
+    FlatBufferBuilder64 builder;
+
+    std::vector<uint8_t> giant_data;
+    giant_data.resize(1LL << 3);
+    giant_data[2] = 42;
+
+    builder.Finish(
+        v2::CreateRootTableDirect(builder, 1234, &data, &giant_data));
+
+    // Use each version to get a view at the root table.
+    auto v1_root = v1::GetRootTable(builder.GetBufferPointer());
+    auto v2_root = v2::GetRootTable(builder.GetBufferPointer());
+
+    // Test field equivalents for fields common to V1 and V2.
+    TEST_EQ(v1_root->a(), v2_root->a());
+
+    TEST_EQ(v1_root->b(), v2_root->b());
+    TEST_EQ(v1_root->b()->Get(2), 3);
+    TEST_EQ(v2_root->b()->Get(2), 3);
+
+    // Test that V2 can read the big vector, which V1 doesn't even have
+    // accessors for (i.e. v1_root->big_vector() doesn't exist).
+    TEST_ASSERT(v2_root->big_vector() != nullptr);
+    TEST_EQ(v2_root->big_vector()->size(), giant_data.size());
+    TEST_EQ(v2_root->big_vector()->Get(2), 42);
+  }
+}
+
+void Offset64VectorOfStructs() {
+  FlatBufferBuilder64 builder;
+
+  std::vector<LeafStruct> far_leaves;
+  far_leaves.emplace_back(LeafStruct{ 123, 4.567 });
+  far_leaves.emplace_back(LeafStruct{ 987, 6.543 });
+
+  std::vector<LeafStruct> big_leaves;
+  big_leaves.emplace_back(LeafStruct{ 72, 72.8 });
+  big_leaves.emplace_back(LeafStruct{ 82, 82.8 });
+  big_leaves.emplace_back(LeafStruct{ 92, 92.8 });
+
+  // Add the two vectors of leaf structs.
+  const Offset<RootTable> root_table_offset =
+      CreateRootTableDirect(builder, nullptr, 0, nullptr, nullptr, nullptr,
+                            nullptr, &far_leaves, &big_leaves);
+
+  // Finish the buffer.
+  builder.Finish(root_table_offset);
+
+  Verifier::Options options;
+  // Allow the verifier to verify 64-bit buffers.
+  options.max_size = FLATBUFFERS_MAX_64_BUFFER_SIZE;
+  options.assert = true;
+
+  Verifier verifier(builder.GetBufferPointer(), builder.GetSize(), options);
+
+  TEST_EQ(VerifyRootTableBuffer(verifier), true);
+
+  // Verify the data.
+  const RootTable *root_table = GetRootTable(builder.GetBufferPointer());
+  TEST_EQ(root_table->far_struct_vector()->size(), far_leaves.size());
+  TEST_EQ(root_table->far_struct_vector()->Get(0)->a(), 123);
+  TEST_EQ(root_table->far_struct_vector()->Get(0)->b(), 4.567);
+  TEST_EQ(root_table->far_struct_vector()->Get(1)->a(), 987);
+  TEST_EQ(root_table->far_struct_vector()->Get(1)->b(), 6.543);
+
+  TEST_EQ(root_table->big_struct_vector()->size(), big_leaves.size());
+  TEST_EQ(root_table->big_struct_vector()->Get(0)->a(), 72);
+  TEST_EQ(root_table->big_struct_vector()->Get(0)->b(), 72.8);
+  TEST_EQ(root_table->big_struct_vector()->Get(1)->a(), 82);
+  TEST_EQ(root_table->big_struct_vector()->Get(1)->b(), 82.8);
+  TEST_EQ(root_table->big_struct_vector()->Get(2)->a(), 92);
+  TEST_EQ(root_table->big_struct_vector()->Get(2)->b(), 92.8);
+}
+
+void Offset64SizePrefix() {
+  FlatBufferBuilder64 builder;
+
+  // First serialize a nested buffer.
+  const Offset<String> near_string_offset =
+      builder.CreateString("some near string");
+
+  // Finish by building the root table by passing in all the offsets.
+  const Offset<RootTable> root_table_offset =
+      CreateRootTable(builder, 0, 0, 0, 0, near_string_offset, 0);
+
+  // Finish the buffer.
+  FinishSizePrefixedRootTableBuffer(builder, root_table_offset);
+
+  TEST_EQ(GetPrefixedSize<uoffset64_t>(builder.GetBufferPointer()),
+          builder.GetSize() - sizeof(uoffset64_t));
+
+  Verifier::Options options;
+  // Allow the verifier to verify 64-bit buffers.
+  options.max_size = FLATBUFFERS_MAX_64_BUFFER_SIZE;
+  options.assert = true;
+
+  Verifier verifier(builder.GetBufferPointer(), builder.GetSize(), options);
+
+  TEST_EQ(VerifySizePrefixedRootTableBuffer(verifier), true);
+
+  const RootTable *root_table =
+      GetSizePrefixedRootTable(builder.GetBufferPointer());
+
+  // Verify the fields.
+  TEST_EQ_STR(root_table->near_string()->c_str(), "some near string");
+}
+
+void Offset64ManyVectors() {
+  FlatBufferBuilder64 builder;
+
+  // Setup some data to serialize.
+  std::vector<int8_t> data;
+  data.resize(20);
+  data.front() = 42;
+  data.back() = 18;
+
+  const size_t kNumVectors = 20;
+
+  // First serialize all the 64-bit address vectors. We need to store all the
+  // offsets to later add to a wrapper table. We cannot serialize one vector and
+  // then add it to a table immediately, as it would violate the strict ordering
+  // of putting all 64-bit things at the tail of the buffer.
+  std::array<Offset64<Vector<int8_t>>, kNumVectors> offsets_64bit;
+  for (size_t i = 0; i < kNumVectors; ++i) {
+    offsets_64bit[i] = builder.CreateVector64<Vector>(data);
+  }
+
+  // Create some unrelated, 64-bit offset value for later testing.
+  const Offset64<String> far_string_offset =
+      builder.CreateString<Offset64>("some far string");
+
+  // Now place all the offsets into their own wrapper tables. Again, we have to
+  // store the offsets before we can add them to the root table vector.
+  std::array<Offset<WrapperTable>, kNumVectors> offsets_wrapper;
+  for (size_t i = 0; i < kNumVectors; ++i) {
+    offsets_wrapper[i] = CreateWrapperTable(builder, offsets_64bit[i]);
+  }
+
+  // Now create the 32-bit vector that is stored in the root table.
+  // TODO(derekbailey): the array type wasn't auto deduced, see if that could be
+  // fixed.
+  const Offset<Vector<Offset<WrapperTable>>> many_vectors_offset =
+      builder.CreateVector<Offset<WrapperTable>>(offsets_wrapper);
+
+  // Finish by building using the root table builder, to exercise a different
+  // code path than the other tests.
+  RootTableBuilder root_table_builder(builder);
+  root_table_builder.add_many_vectors(many_vectors_offset);
+  root_table_builder.add_far_string(far_string_offset);
+  const Offset<RootTable> root_table_offset = root_table_builder.Finish();
+
+  // Finish the buffer.
+  FinishRootTableBuffer(builder, root_table_offset);
+
+  Verifier::Options options;
+  // Allow the verifier to verify 64-bit buffers.
+  options.max_size = FLATBUFFERS_MAX_64_BUFFER_SIZE;
+  options.assert = true;
+
+  Verifier verifier(builder.GetBufferPointer(), builder.GetSize(), options);
+
+  TEST_EQ(VerifyRootTableBuffer(verifier), true);
+
+  const RootTable *root_table = GetRootTable(builder.GetBufferPointer());
+
+  // Verify the fields.
+  TEST_EQ_STR(root_table->far_string()->c_str(), "some far string");
+  TEST_EQ(root_table->many_vectors()->size(), kNumVectors);
+
+  // Spot check one of the vectors.
+  TEST_EQ(root_table->many_vectors()->Get(12)->vector()->size(), 20);
+  TEST_EQ(root_table->many_vectors()->Get(12)->vector()->Get(0), 42);
+  TEST_EQ(root_table->many_vectors()->Get(12)->vector()->Get(19), 18);
+}
+
+void Offset64ForceAlign() {
+  FlatBufferBuilder64 builder;
+
+  // Setup some data to serialize that is less than the force_align size of 32
+  // bytes.
+  std::vector<uint8_t> data{ 1, 2, 3 };
+
+  // Use the CreateDirect which calls the ForceVectorAlign
+  const auto root_table_offset =
+      CreateRootTableDirect(builder, nullptr, 0, nullptr, nullptr, nullptr,
+                            nullptr, nullptr, nullptr, nullptr, &data);
+
+  // Finish the buffer.
+  FinishRootTableBuffer(builder, root_table_offset);
+}
+
+}  // namespace tests
+}  // namespace flatbuffers

tests/64bit/offset64_test.h

@@ -0,0 +1,20 @@
+#ifndef TESTS_64BIT_OFFSET64_TEST_H
+#define TESTS_64BIT_OFFSET64_TEST_H
+
+namespace flatbuffers {
+namespace tests {
+
+void Offset64Test();
+void Offset64SerializedFirst();
+void Offset64NestedFlatBuffer();
+void Offset64CreateDirect();
+void Offset64Evolution();
+void Offset64VectorOfStructs();
+void Offset64SizePrefix();
+void Offset64ManyVectors();
+void Offset64ForceAlign();
+
+}  // namespace tests
+}  // namespace flatbuffers
+
+#endif // TESTS_64BIT_OFFSET64_TEST_H

tests/64bit/test_64bit.afb

@@ -0,0 +1,74 @@
+// Annotated Flatbuffer Binary
+//
+// Schema file: tests/64bit/test_64bit.fbs
+// Binary file: tests/64bit/test_64bit.bin
+
+header:
+  +0x00 | 1C 00 00 00             | UOffset32  | 0x0000001C (28) Loc: 0x1C          | offset to root table `RootTable`
+
+padding:
+  +0x04 | 00 00 00 00             | uint8_t[4] | ....                               | padding
+
+vtable (RootTable):
+  +0x08 | 14 00                   | uint16_t   | 0x0014 (20)                        | size of this vtable
+  +0x0A | 34 00                   | uint16_t   | 0x0034 (52)                        | size of referring table
+  +0x0C | 04 00                   | VOffset16  | 0x0004 (4)                         | offset to field `far_vector` (id: 0)
+  +0x0E | 10 00                   | VOffset16  | 0x0010 (16)                        | offset to field `a` (id: 1)
+  +0x10 | 14 00                   | VOffset16  | 0x0014 (20)                        | offset to field `far_string` (id: 2)
+  +0x12 | 24 00                   | VOffset16  | 0x0024 (36)                        | offset to field `big_vector` (id: 3)
+  +0x14 | 20 00                   | VOffset16  | 0x0020 (32)                        | offset to field `near_string` (id: 4)
+  +0x16 | 00 00                   | VOffset16  | 0x0000 (0)                         | offset to field `nested_root` (id: 5) <null> (Vector64)
+  +0x18 | 00 00                   | VOffset16  | 0x0000 (0)                         | offset to field `far_struct_vector` (id: 6) <null> (Vector)
+  +0x1A | 2C 00                   | VOffset16  | 0x002C (44)                        | offset to field `big_struct_vector` (id: 7)
+
+root_table (RootTable):
+  +0x1C | 14 00 00 00             | SOffset32  | 0x00000014 (20) Loc: 0x08          | offset to vtable
+  +0x20 | D0 00 00 00 00 00 00 00 | UOffset64  | 0x00000000000000D0 (208) Loc: 0xF0 | offset to field `far_vector` (vector)
+  +0x28 | 00 00 00 00             | uint8_t[4] | ....                               | padding
+  +0x2C | D2 04 00 00             | uint32_t   | 0x000004D2 (1234)                  | table field `a` (Int)
+  +0x30 | 8C 00 00 00 00 00 00 00 | UOffset64  | 0x000000000000008C (140) Loc: 0xBC | offset to field `far_string` (string)
+  +0x38 | 00 00 00 00             | uint8_t[4] | ....                               | padding
+  +0x3C | 40 00 00 00             | UOffset32  | 0x00000040 (64) Loc: 0x7C          | offset to field `near_string` (string)
+  +0x40 | 70 00 00 00 00 00 00 00 | UOffset64  | 0x0000000000000070 (112) Loc: 0xB0 | offset to field `big_vector` (vector64)
+  +0x48 | 08 00 00 00 00 00 00 00 | UOffset64  | 0x0000000000000008 (8) Loc: 0x50   | offset to field `big_struct_vector` (vector64)
+
+vector64 (RootTable.big_struct_vector):
+  +0x50 | 02 00 00 00 00 00 00 00 | uint64_t   | 0x0000000000000002 (2)             | length of vector (# items)
+  +0x58 | 0C 00 00 00             | uint32_t   | 0x0000000C (12)                    | struct field `[0].a` of 'LeafStruct' (Int)
+  <4 regions omitted>
+  +0x70 | 33 33 33 33 33 33 22 40 | double     | 0x4022333333333333 (9.1)           | struct field `[1].b` of 'LeafStruct' (Double)
+
+padding:
+  +0x78 | 00 00 00 00             | uint8_t[4] | ....                               | padding
+
+string (RootTable.near_string):
+  +0x7C | 2F 00 00 00             | uint32_t   | 0x0000002F (47)                    | length of string
+  +0x80 | 74 68 69 73 20 69 73 20 | char[47]   | this is                            | string literal
+  +0x88 | 61 20 6E 65 61 72 20 73 |            | a near s
+  +0x90 | 74 72 69 6E 67 20 77 68 |            | tring wh
+  +0x98 | 69 63 68 20 68 61 73 20 |            | ich has 
+  +0xA0 | 61 20 33 32 2D 62 69 74 |            | a 32-bit
+  +0xA8 | 20 6F 66 66 73 65 74    |            |  offset
+  +0xAF | 00                      | char       | 0x00 (0)                           | string terminator
+
+vector64 (RootTable.big_vector):
+  +0xB0 | 04 00 00 00 00 00 00 00 | uint64_t   | 0x0000000000000004 (4)             | length of vector (# items)
+  +0xB8 | 05                      | uint8_t    | 0x05 (5)                           | value[0]
+  <2 regions omitted>
+  +0xBB | 08                      | uint8_t    | 0x08 (8)                           | value[3]
+
+string (RootTable.far_string):
+  +0xBC | 2E 00 00 00             | uint32_t   | 0x0000002E (46)                    | length of string
+  +0xC0 | 74 68 69 73 20 69 73 20 | char[46]   | this is                            | string literal
+  +0xC8 | 61 20 66 61 72 20 73 74 |            | a far st
+  +0xD0 | 72 69 6E 67 20 77 68 69 |            | ring whi
+  +0xD8 | 63 68 20 68 61 73 20 61 |            | ch has a
+  +0xE0 | 20 36 34 2D 62 69 74 20 |            |  64-bit 
+  +0xE8 | 6F 66 66 73 65 74       |            | offset
+  +0xEE | 00                      | char       | 0x00 (0)                           | string terminator
+
+vector (RootTable.far_vector):
+  +0xF0 | 03 00 00 00             | uint32_t   | 0x00000003 (3)                     | length of vector (# items)
+  +0xF4 | 01                      | uint8_t    | 0x01 (1)                           | value[0]
+  +0xF5 | 02                      | uint8_t    | 0x02 (2)                           | value[1]
+  +0xF6 | 03                      | uint8_t    | 0x03 (3)                           | value[2]

tests/64bit/test_64bit.fbs

@@ -0,0 +1,53 @@
+struct LeafStruct {
+  a:int;
+  b:double;
+}
+
+table WrapperTable {
+  // A normal 32-bit sized vector that could be very far away (64-bit address).
+  vector:[int8] (offset64);
+}
+
+table RootTable {
+  // A normal 32-bit sized vector, that could be very far away (64-bit address).
+  far_vector:[ubyte] (offset64);
+
+  // An inplace value just to check that vtable offsets are correct.
+  a:int;
+
+  // A normal 32-bit sized string, that could be very far away (64-bit address).
+  far_string:string (offset64);
+
+  // A big 64-bit sized vector, that could be very far away (64-bit address).
+  big_vector:[ubyte] (vector64);
+
+  // A normal 32-bit sized string that is no far away (32-bit address).
+  near_string:string;
+
+  // A big 64-bit sized vector that is a nested flatbuffers (64-bit address).
+  nested_root:[ubyte] (vector64, nested_flatbuffer: "RootTable");
+
+  // A normal 32-bit size vector of structs, that could be very far away 
+  // (64-bit address)
+  far_struct_vector:[LeafStruct] (offset64);
+
+  // A big 64-bit size vector of structs that could be very far away 
+  // (64-bit address)
+  big_struct_vector:[LeafStruct] (vector64);
+
+  // A normal 32-bit size vector of tables. Currently 64-bit vectors don't 
+  // support tables as it would require serializing a table (32-bit) before the
+  // vector (64-bit), which is not allowed.
+  //
+  // This demonstrates how you could have many vectors in the buffer, by 
+  // effectively having a vector of 64-bit vectors. The IDL doesn't support
+  // nested vecotrs (e.g.: [[type]] ), so going through a wrapper table allows
+  // this.
+  many_vectors:[WrapperTable];
+
+  // A vector that has force_align to test that the 32/64 bit region of the
+  // builder is respected.
+  forced_aligned_vector:[ubyte] (vector64, force_align:32);
+}
+
+root_type RootTable; 

tests/64bit/test_64bit.json

@@ -0,0 +1,17 @@
+{
+  "far_vector": [1, 2, 3],
+  "a": 1234,
+  "far_string": "this is a far string which has a 64-bit offset",
+  "big_vector": [5, 6, 7, 8],
+  "near_string": "this is a near string which has a 32-bit offset",
+  "big_struct_vector": [
+    {
+      "a": 12,
+      "b": 3.456
+    },
+    { 
+      "a": 78,
+      "b": 9.10
+    }
+  ]
+}

tests/64bit/test_64bit_bfbs_generated.h

@@ -0,0 +1,90 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+
+#ifndef FLATBUFFERS_GENERATED_TEST64BIT_BFBS_H_
+#define FLATBUFFERS_GENERATED_TEST64BIT_BFBS_H_
+
+#include <cstddef>
+#include <cstdint>
+struct RootTableBinarySchema {
+  static const uint8_t *data() {
+    // Buffer containing the binary schema.
+    static const uint8_t bfbsData[1248] = {
+      0x1C,0x00,0x00,0x00,0x42,0x46,0x42,0x53,0x14,0x00,0x20,0x00,0x04,0x00,0x08,0x00,0x0C,0x00,0x10,0x00,
+      0x14,0x00,0x18,0x00,0x00,0x00,0x1C,0x00,0x14,0x00,0x00,0x00,0x34,0x00,0x00,0x00,0x2C,0x00,0x00,0x00,
+      0x20,0x00,0x00,0x00,0x14,0x00,0x00,0x00,0x54,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x2C,0x00,0x00,0x00,
+      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+      0x00,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0xA4,0x03,0x00,0x00,0x28,0x00,0x00,0x00,0x00,0x03,0x00,0x00,
+      0x01,0x00,0x00,0x00,0x0C,0x00,0x00,0x00,0x08,0x00,0x0C,0x00,0x04,0x00,0x08,0x00,0x08,0x00,0x00,0x00,
+      0xA0,0x03,0x00,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x38,0xFD,0xFF,0xFF,0x3C,0x00,0x00,0x00,
+      0x0C,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x84,0x03,0x00,0x00,0x0A,0x00,0x00,0x00,0x60,0x02,0x00,0x00,
+      0xAC,0x00,0x00,0x00,0xC4,0x01,0x00,0x00,0x24,0x02,0x00,0x00,0xF0,0x00,0x00,0x00,0x70,0x02,0x00,0x00,
+      0x20,0x00,0x00,0x00,0x5C,0x00,0x00,0x00,0x7C,0x01,0x00,0x00,0x28,0x01,0x00,0x00,0x09,0x00,0x00,0x00,
+      0x52,0x6F,0x6F,0x74,0x54,0x61,0x62,0x6C,0x65,0x00,0x00,0x00,0x28,0xFE,0xFF,0xFF,0x00,0x00,0x01,0x01,
+      0x09,0x00,0x16,0x00,0x18,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x6C,0xFE,0xFF,0xFF,0x00,0x00,0x12,0x04,
+      0x08,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x15,0x00,0x00,0x00,0x66,0x6F,0x72,0x63,0x65,0x64,0x5F,0x61,
+      0x6C,0x69,0x67,0x6E,0x65,0x64,0x5F,0x76,0x65,0x63,0x74,0x6F,0x72,0x00,0x00,0x00,0xF8,0xFE,0xFF,0xFF,
+      0x00,0x00,0x00,0x01,0x08,0x00,0x14,0x00,0x18,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x78,0xFF,0xFF,0xFF,
+      0x00,0x00,0x0E,0x0F,0x02,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x0C,0x00,0x00,0x00,0x6D,0x61,0x6E,0x79,
+      0x5F,0x76,0x65,0x63,0x74,0x6F,0x72,0x73,0x00,0x00,0x00,0x00,0xA0,0xFE,0xFF,0xFF,0x00,0x00,0x01,0x01,
+      0x07,0x00,0x12,0x00,0x2C,0x00,0x00,0x00,0x14,0x00,0x00,0x00,0x10,0x00,0x14,0x00,0x06,0x00,0x07,0x00,
+      0x08,0x00,0x00,0x00,0x0C,0x00,0x10,0x00,0x10,0x00,0x00,0x00,0x00,0x00,0x12,0x0F,0x00,0x00,0x00,0x00,
+      0x08,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x11,0x00,0x00,0x00,0x62,0x69,0x67,0x5F,0x73,0x74,0x72,0x75,
+      0x63,0x74,0x5F,0x76,0x65,0x63,0x74,0x6F,0x72,0x00,0x00,0x00,0xF0,0xFE,0xFF,0xFF,0x00,0x00,0x01,0x01,
+      0x06,0x00,0x10,0x00,0x28,0x00,0x00,0x00,0x14,0x00,0x00,0x00,0x10,0x00,0x10,0x00,0x06,0x00,0x07,0x00,
+      0x08,0x00,0x00,0x00,0x00,0x00,0x0C,0x00,0x10,0x00,0x00,0x00,0x00,0x00,0x0E,0x0F,0x00,0x00,0x00,0x00,
+      0x10,0x00,0x00,0x00,0x11,0x00,0x00,0x00,0x66,0x61,0x72,0x5F,0x73,0x74,0x72,0x75,0x63,0x74,0x5F,0x76,
+      0x65,0x63,0x74,0x6F,0x72,0x00,0x00,0x00,0x3C,0xFF,0xFF,0xFF,0x00,0x00,0x01,0x01,0x05,0x00,0x0E,0x00,
+      0x18,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x80,0xFF,0xFF,0xFF,0x00,0x00,0x12,0x04,0x08,0x00,0x00,0x00,
+      0x01,0x00,0x00,0x00,0x0B,0x00,0x00,0x00,0x6E,0x65,0x73,0x74,0x65,0x64,0x5F,0x72,0x6F,0x6F,0x74,0x00,
+      0x1C,0x00,0x14,0x00,0x0C,0x00,0x10,0x00,0x08,0x00,0x0A,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+      0x00,0x00,0x00,0x00,0x00,0x00,0x07,0x00,0x1C,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x04,0x00,0x0C,0x00,
+      0x14,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x90,0xFD,0xFF,0xFF,0x00,0x00,0x00,0x0D,0x01,0x00,0x00,0x00,
+      0x0B,0x00,0x00,0x00,0x6E,0x65,0x61,0x72,0x5F,0x73,0x74,0x72,0x69,0x6E,0x67,0x00,0xBC,0xFF,0xFF,0xFF,
+      0x00,0x00,0x01,0x01,0x03,0x00,0x0A,0x00,0x28,0x00,0x00,0x00,0x14,0x00,0x00,0x00,0x10,0x00,0x10,0x00,
+      0x06,0x00,0x07,0x00,0x00,0x00,0x00,0x00,0x08,0x00,0x0C,0x00,0x10,0x00,0x00,0x00,0x00,0x00,0x12,0x04,
+      0x08,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x0A,0x00,0x00,0x00,0x62,0x69,0x67,0x5F,0x76,0x65,0x63,0x74,
+      0x6F,0x72,0x00,0x00,0x20,0x00,0x14,0x00,0x0C,0x00,0x10,0x00,0x08,0x00,0x0A,0x00,0x00,0x00,0x00,0x00,
+      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x07,0x00,0x20,0x00,0x00,0x00,
+      0x00,0x00,0x01,0x01,0x02,0x00,0x08,0x00,0x14,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x24,0xFE,0xFF,0xFF,
+      0x00,0x00,0x00,0x0D,0x01,0x00,0x00,0x00,0x0A,0x00,0x00,0x00,0x66,0x61,0x72,0x5F,0x73,0x74,0x72,0x69,
+      0x6E,0x67,0x00,0x00,0xB0,0xFE,0xFF,0xFF,0x01,0x00,0x06,0x00,0x14,0x00,0x00,0x00,0x04,0x00,0x00,0x00,
+      0x50,0xFE,0xFF,0xFF,0x00,0x00,0x00,0x07,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x61,0x00,0x00,0x00,
+      0x90,0xFF,0xFF,0xFF,0x01,0x01,0x04,0x00,0x14,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x70,0xFF,0xFF,0xFF,
+      0x00,0x00,0x0E,0x04,0x01,0x00,0x00,0x00,0x0A,0x00,0x00,0x00,0x66,0x61,0x72,0x5F,0x76,0x65,0x63,0x74,
+      0x6F,0x72,0x00,0x00,0x14,0x00,0x14,0x00,0x04,0x00,0x08,0x00,0x00,0x00,0x0C,0x00,0x00,0x00,0x00,0x00,
+      0x00,0x00,0x10,0x00,0x14,0x00,0x00,0x00,0x18,0x00,0x00,0x00,0x0C,0x00,0x00,0x00,0x01,0x00,0x00,0x00,
+      0xA8,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x38,0x00,0x00,0x00,0x0C,0x00,0x00,0x00,0x57,0x72,0x61,0x70,
+      0x70,0x65,0x72,0x54,0x61,0x62,0x6C,0x65,0x00,0x00,0x00,0x00,0x20,0x00,0x10,0x00,0x08,0x00,0x0C,0x00,
+      0x00,0x00,0x06,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x00,
+      0x00,0x00,0x05,0x00,0x20,0x00,0x00,0x00,0x01,0x01,0x04,0x00,0x24,0x00,0x00,0x00,0x14,0x00,0x00,0x00,
+      0x10,0x00,0x0C,0x00,0x06,0x00,0x07,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x00,0x10,0x00,0x00,0x00,
+      0x00,0x00,0x0E,0x03,0x01,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x76,0x65,0x63,0x74,0x6F,0x72,0x00,0x00,
+      0x14,0x00,0x1C,0x00,0x08,0x00,0x0C,0x00,0x07,0x00,0x10,0x00,0x14,0x00,0x00,0x00,0x00,0x00,0x18,0x00,
+      0x14,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x38,0x00,0x00,0x00,0x28,0x00,0x00,0x00,0x08,0x00,0x00,0x00,
+      0x10,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x10,0x00,0x00,0x00,0x2F,0x2F,0x74,0x65,0x73,0x74,0x5F,0x36,
+      0x34,0x62,0x69,0x74,0x2E,0x66,0x62,0x73,0x00,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x78,0x00,0x00,0x00,
+      0x20,0x00,0x00,0x00,0x0A,0x00,0x00,0x00,0x4C,0x65,0x61,0x66,0x53,0x74,0x72,0x75,0x63,0x74,0x00,0x00,
+      0x0C,0x00,0x10,0x00,0x08,0x00,0x0C,0x00,0x04,0x00,0x06,0x00,0x0C,0x00,0x00,0x00,0x01,0x00,0x08,0x00,
+      0x28,0x00,0x00,0x00,0x14,0x00,0x00,0x00,0x10,0x00,0x10,0x00,0x07,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+      0x08,0x00,0x0C,0x00,0x10,0x00,0x00,0x00,0x00,0x00,0x00,0x0C,0x08,0x00,0x00,0x00,0x01,0x00,0x00,0x00,
+      0x01,0x00,0x00,0x00,0x62,0x00,0x1E,0x00,0x10,0x00,0x08,0x00,0x0C,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+      0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x06,0x00,0x1E,0x00,0x00,0x00,
+      0x00,0x00,0x04,0x00,0x24,0x00,0x00,0x00,0x14,0x00,0x00,0x00,0x10,0x00,0x0C,0x00,0x07,0x00,0x00,0x00,
+      0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x00,0x10,0x00,0x00,0x00,0x00,0x00,0x00,0x07,0x01,0x00,0x00,0x00,
+      0x01,0x00,0x00,0x00,0x61,0x00,0x00,0x00
+    };
+    return bfbsData;
+  }
+  static size_t size() {
+    return 1248;
+  }
+  const uint8_t *begin() {
+    return data();
+  }
+  const uint8_t *end() {
+    return data() + size();
+  }
+};
+
+#endif  // FLATBUFFERS_GENERATED_TEST64BIT_BFBS_H_

tests/64bit/test_64bit_generated.h

@@ -0,0 +1,653 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+
+#ifndef FLATBUFFERS_GENERATED_TEST64BIT_H_
+#define FLATBUFFERS_GENERATED_TEST64BIT_H_
+
+#include "flatbuffers/flatbuffers.h"
+
+// Ensure the included flatbuffers.h is the same version as when this file was
+// generated, otherwise it may not be compatible.
+static_assert(FLATBUFFERS_VERSION_MAJOR == 23 &&
+              FLATBUFFERS_VERSION_MINOR == 5 &&
+              FLATBUFFERS_VERSION_REVISION == 26,
+             "Non-compatible flatbuffers version included");
+
+// For access to the binary schema that produced this file.
+#include "test_64bit_bfbs_generated.h"
+
+struct LeafStruct;
+
+struct WrapperTable;
+struct WrapperTableBuilder;
+struct WrapperTableT;
+
+struct RootTable;
+struct RootTableBuilder;
+struct RootTableT;
+
+bool operator==(const LeafStruct &lhs, const LeafStruct &rhs);
+bool operator!=(const LeafStruct &lhs, const LeafStruct &rhs);
+bool operator==(const WrapperTableT &lhs, const WrapperTableT &rhs);
+bool operator!=(const WrapperTableT &lhs, const WrapperTableT &rhs);
+bool operator==(const RootTableT &lhs, const RootTableT &rhs);
+bool operator!=(const RootTableT &lhs, const RootTableT &rhs);
+
+inline const ::flatbuffers::TypeTable *LeafStructTypeTable();
+
+inline const ::flatbuffers::TypeTable *WrapperTableTypeTable();
+
+inline const ::flatbuffers::TypeTable *RootTableTypeTable();
+
+FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) LeafStruct FLATBUFFERS_FINAL_CLASS {
+ private:
+  int32_t a_;
+  int32_t padding0__;
+  double b_;
+
+ public:
+  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
+    return LeafStructTypeTable();
+  }
+  LeafStruct()
+      : a_(0),
+        padding0__(0),
+        b_(0) {
+    (void)padding0__;
+  }
+  LeafStruct(int32_t _a, double _b)
+      : a_(::flatbuffers::EndianScalar(_a)),
+        padding0__(0),
+        b_(::flatbuffers::EndianScalar(_b)) {
+    (void)padding0__;
+  }
+  int32_t a() const {
+    return ::flatbuffers::EndianScalar(a_);
+  }
+  void mutate_a(int32_t _a) {
+    ::flatbuffers::WriteScalar(&a_, _a);
+  }
+  double b() const {
+    return ::flatbuffers::EndianScalar(b_);
+  }
+  void mutate_b(double _b) {
+    ::flatbuffers::WriteScalar(&b_, _b);
+  }
+};
+FLATBUFFERS_STRUCT_END(LeafStruct, 16);
+
+inline bool operator==(const LeafStruct &lhs, const LeafStruct &rhs) {
+  return
+      (lhs.a() == rhs.a()) &&
+      (lhs.b() == rhs.b());
+}
+
+inline bool operator!=(const LeafStruct &lhs, const LeafStruct &rhs) {
+    return !(lhs == rhs);
+}
+
+
+struct WrapperTableT : public ::flatbuffers::NativeTable {
+  typedef WrapperTable TableType;
+  std::vector<int8_t> vector{};
+};
+
+struct WrapperTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef WrapperTableT NativeTableType;
+  typedef WrapperTableBuilder Builder;
+  typedef RootTableBinarySchema BinarySchema;
+  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
+    return WrapperTableTypeTable();
+  }
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_VECTOR = 4
+  };
+  const ::flatbuffers::Vector<int8_t> *vector() const {
+    return GetPointer64<const ::flatbuffers::Vector<int8_t> *>(VT_VECTOR);
+  }
+  ::flatbuffers::Vector<int8_t> *mutable_vector() {
+    return GetPointer64<::flatbuffers::Vector<int8_t> *>(VT_VECTOR);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset64(verifier, VT_VECTOR) &&
+           verifier.VerifyVector(vector()) &&
+           verifier.EndTable();
+  }
+  WrapperTableT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(WrapperTableT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static ::flatbuffers::Offset<WrapperTable> Pack(::flatbuffers::FlatBufferBuilder64 &_fbb, const WrapperTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct WrapperTableBuilder {
+  typedef WrapperTable Table;
+  ::flatbuffers::FlatBufferBuilder64 &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_vector(::flatbuffers::Offset64<::flatbuffers::Vector<int8_t>> vector) {
+    fbb_.AddOffset(WrapperTable::VT_VECTOR, vector);
+  }
+  explicit WrapperTableBuilder(::flatbuffers::FlatBufferBuilder64 &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<WrapperTable> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<WrapperTable>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<WrapperTable> CreateWrapperTable(
+    ::flatbuffers::FlatBufferBuilder64 &_fbb,
+    ::flatbuffers::Offset64<::flatbuffers::Vector<int8_t>> vector = 0) {
+  WrapperTableBuilder builder_(_fbb);
+  builder_.add_vector(vector);
+  return builder_.Finish();
+}
+
+inline ::flatbuffers::Offset<WrapperTable> CreateWrapperTableDirect(
+    ::flatbuffers::FlatBufferBuilder64 &_fbb,
+    const std::vector<int8_t> *vector = nullptr) {
+  auto vector__ = vector ? _fbb.CreateVector64<::flatbuffers::Vector>(*vector) : 0;
+  return CreateWrapperTable(
+      _fbb,
+      vector__);
+}
+
+::flatbuffers::Offset<WrapperTable> CreateWrapperTable(::flatbuffers::FlatBufferBuilder64 &_fbb, const WrapperTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct RootTableT : public ::flatbuffers::NativeTable {
+  typedef RootTable TableType;
+  std::vector<uint8_t> far_vector{};
+  int32_t a = 0;
+  std::string far_string{};
+  std::vector<uint8_t> big_vector{};
+  std::string near_string{};
+  std::vector<uint8_t> nested_root{};
+  std::vector<LeafStruct> far_struct_vector{};
+  std::vector<LeafStruct> big_struct_vector{};
+  std::vector<std::unique_ptr<WrapperTableT>> many_vectors{};
+  std::vector<uint8_t> forced_aligned_vector{};
+  RootTableT() = default;
+  RootTableT(const RootTableT &o);
+  RootTableT(RootTableT&&) FLATBUFFERS_NOEXCEPT = default;
+  RootTableT &operator=(RootTableT o) FLATBUFFERS_NOEXCEPT;
+};
+
+struct RootTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
+  typedef RootTableT NativeTableType;
+  typedef RootTableBuilder Builder;
+  typedef RootTableBinarySchema BinarySchema;
+  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
+    return RootTableTypeTable();
+  }
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_FAR_VECTOR = 4,
+    VT_A = 6,
+    VT_FAR_STRING = 8,
+    VT_BIG_VECTOR = 10,
+    VT_NEAR_STRING = 12,
+    VT_NESTED_ROOT = 14,
+    VT_FAR_STRUCT_VECTOR = 16,
+    VT_BIG_STRUCT_VECTOR = 18,
+    VT_MANY_VECTORS = 20,
+    VT_FORCED_ALIGNED_VECTOR = 22
+  };
+  const ::flatbuffers::Vector<uint8_t> *far_vector() const {
+    return GetPointer64<const ::flatbuffers::Vector<uint8_t> *>(VT_FAR_VECTOR);
+  }
+  ::flatbuffers::Vector<uint8_t> *mutable_far_vector() {
+    return GetPointer64<::flatbuffers::Vector<uint8_t> *>(VT_FAR_VECTOR);
+  }
+  int32_t a() const {
+    return GetField<int32_t>(VT_A, 0);
+  }
+  bool mutate_a(int32_t _a = 0) {
+    return SetField<int32_t>(VT_A, _a, 0);
+  }
+  const ::flatbuffers::String *far_string() const {
+    return GetPointer64<const ::flatbuffers::String *>(VT_FAR_STRING);
+  }
+  ::flatbuffers::String *mutable_far_string() {
+    return GetPointer64<::flatbuffers::String *>(VT_FAR_STRING);
+  }
+  const ::flatbuffers::Vector64<uint8_t> *big_vector() const {
+    return GetPointer64<const ::flatbuffers::Vector64<uint8_t> *>(VT_BIG_VECTOR);
+  }
+  ::flatbuffers::Vector64<uint8_t> *mutable_big_vector() {
+    return GetPointer64<::flatbuffers::Vector64<uint8_t> *>(VT_BIG_VECTOR);
+  }
+  const ::flatbuffers::String *near_string() const {
+    return GetPointer<const ::flatbuffers::String *>(VT_NEAR_STRING);
+  }
+  ::flatbuffers::String *mutable_near_string() {
+    return GetPointer<::flatbuffers::String *>(VT_NEAR_STRING);
+  }
+  const ::flatbuffers::Vector64<uint8_t> *nested_root() const {
+    return GetPointer64<const ::flatbuffers::Vector64<uint8_t> *>(VT_NESTED_ROOT);
+  }
+  ::flatbuffers::Vector64<uint8_t> *mutable_nested_root() {
+    return GetPointer64<::flatbuffers::Vector64<uint8_t> *>(VT_NESTED_ROOT);
+  }
+  const RootTable *nested_root_nested_root() const {
+    const auto _f = nested_root();
+    return _f ? ::flatbuffers::GetRoot<RootTable>(_f->Data())
+              : nullptr;
+  }
+  const ::flatbuffers::Vector<const LeafStruct *> *far_struct_vector() const {
+    return GetPointer64<const ::flatbuffers::Vector<const LeafStruct *> *>(VT_FAR_STRUCT_VECTOR);
+  }
+  ::flatbuffers::Vector<const LeafStruct *> *mutable_far_struct_vector() {
+    return GetPointer64<::flatbuffers::Vector<const LeafStruct *> *>(VT_FAR_STRUCT_VECTOR);
+  }
+  const ::flatbuffers::Vector64<const LeafStruct *> *big_struct_vector() const {
+    return GetPointer64<const ::flatbuffers::Vector64<const LeafStruct *> *>(VT_BIG_STRUCT_VECTOR);
+  }
+  ::flatbuffers::Vector64<const LeafStruct *> *mutable_big_struct_vector() {
+    return GetPointer64<::flatbuffers::Vector64<const LeafStruct *> *>(VT_BIG_STRUCT_VECTOR);
+  }
+  const ::flatbuffers::Vector<::flatbuffers::Offset<WrapperTable>> *many_vectors() const {
+    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<WrapperTable>> *>(VT_MANY_VECTORS);
+  }
+  ::flatbuffers::Vector<::flatbuffers::Offset<WrapperTable>> *mutable_many_vectors() {
+    return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<WrapperTable>> *>(VT_MANY_VECTORS);
+  }
+  const ::flatbuffers::Vector64<uint8_t> *forced_aligned_vector() const {
+    return GetPointer64<const ::flatbuffers::Vector64<uint8_t> *>(VT_FORCED_ALIGNED_VECTOR);
+  }
+  ::flatbuffers::Vector64<uint8_t> *mutable_forced_aligned_vector() {
+    return GetPointer64<::flatbuffers::Vector64<uint8_t> *>(VT_FORCED_ALIGNED_VECTOR);
+  }
+  bool Verify(::flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset64(verifier, VT_FAR_VECTOR) &&
+           verifier.VerifyVector(far_vector()) &&
+           VerifyField<int32_t>(verifier, VT_A, 4) &&
+           VerifyOffset64(verifier, VT_FAR_STRING) &&
+           verifier.VerifyString(far_string()) &&
+           VerifyOffset64(verifier, VT_BIG_VECTOR) &&
+           verifier.VerifyVector(big_vector()) &&
+           VerifyOffset(verifier, VT_NEAR_STRING) &&
+           verifier.VerifyString(near_string()) &&
+           VerifyOffset64(verifier, VT_NESTED_ROOT) &&
+           verifier.VerifyVector(nested_root()) &&
+           verifier.VerifyNestedFlatBuffer<RootTable>(nested_root(), nullptr) &&
+           VerifyOffset64(verifier, VT_FAR_STRUCT_VECTOR) &&
+           verifier.VerifyVector(far_struct_vector()) &&
+           VerifyOffset64(verifier, VT_BIG_STRUCT_VECTOR) &&
+           verifier.VerifyVector(big_struct_vector()) &&
+           VerifyOffset(verifier, VT_MANY_VECTORS) &&
+           verifier.VerifyVector(many_vectors()) &&
+           verifier.VerifyVectorOfTables(many_vectors()) &&
+           VerifyOffset64(verifier, VT_FORCED_ALIGNED_VECTOR) &&
+           verifier.VerifyVector(forced_aligned_vector()) &&
+           verifier.EndTable();
+  }
+  RootTableT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(RootTableT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static ::flatbuffers::Offset<RootTable> Pack(::flatbuffers::FlatBufferBuilder64 &_fbb, const RootTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct RootTableBuilder {
+  typedef RootTable Table;
+  ::flatbuffers::FlatBufferBuilder64 &fbb_;
+  ::flatbuffers::uoffset_t start_;
+  void add_far_vector(::flatbuffers::Offset64<::flatbuffers::Vector<uint8_t>> far_vector) {
+    fbb_.AddOffset(RootTable::VT_FAR_VECTOR, far_vector);
+  }
+  void add_a(int32_t a) {
+    fbb_.AddElement<int32_t>(RootTable::VT_A, a, 0);
+  }
+  void add_far_string(::flatbuffers::Offset64<::flatbuffers::String> far_string) {
+    fbb_.AddOffset(RootTable::VT_FAR_STRING, far_string);
+  }
+  void add_big_vector(::flatbuffers::Offset64<::flatbuffers::Vector64<uint8_t>> big_vector) {
+    fbb_.AddOffset(RootTable::VT_BIG_VECTOR, big_vector);
+  }
+  void add_near_string(::flatbuffers::Offset<::flatbuffers::String> near_string) {
+    fbb_.AddOffset(RootTable::VT_NEAR_STRING, near_string);
+  }
+  void add_nested_root(::flatbuffers::Offset64<::flatbuffers::Vector64<uint8_t>> nested_root) {
+    fbb_.AddOffset(RootTable::VT_NESTED_ROOT, nested_root);
+  }
+  void add_far_struct_vector(::flatbuffers::Offset64<::flatbuffers::Vector<const LeafStruct *>> far_struct_vector) {
+    fbb_.AddOffset(RootTable::VT_FAR_STRUCT_VECTOR, far_struct_vector);
+  }
+  void add_big_struct_vector(::flatbuffers::Offset64<::flatbuffers::Vector64<const LeafStruct *>> big_struct_vector) {
+    fbb_.AddOffset(RootTable::VT_BIG_STRUCT_VECTOR, big_struct_vector);
+  }
+  void add_many_vectors(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<WrapperTable>>> many_vectors) {
+    fbb_.AddOffset(RootTable::VT_MANY_VECTORS, many_vectors);
+  }
+  void add_forced_aligned_vector(::flatbuffers::Offset64<::flatbuffers::Vector64<uint8_t>> forced_aligned_vector) {
+    fbb_.AddOffset(RootTable::VT_FORCED_ALIGNED_VECTOR, forced_aligned_vector);
+  }
+  explicit RootTableBuilder(::flatbuffers::FlatBufferBuilder64 &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ::flatbuffers::Offset<RootTable> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = ::flatbuffers::Offset<RootTable>(end);
+    return o;
+  }
+};
+
+inline ::flatbuffers::Offset<RootTable> CreateRootTable(
+    ::flatbuffers::FlatBufferBuilder64 &_fbb,
+    ::flatbuffers::Offset64<::flatbuffers::Vector<uint8_t>> far_vector = 0,
+    int32_t a = 0,
+    ::flatbuffers::Offset64<::flatbuffers::String> far_string = 0,
+    ::flatbuffers::Offset64<::flatbuffers::Vector64<uint8_t>> big_vector = 0,
+    ::flatbuffers::Offset<::flatbuffers::String> near_string = 0,
+    ::flatbuffers::Offset64<::flatbuffers::Vector64<uint8_t>> nested_root = 0,
+    ::flatbuffers::Offset64<::flatbuffers::Vector<const LeafStruct *>> far_struct_vector = 0,
+    ::flatbuffers::Offset64<::flatbuffers::Vector64<const LeafStruct *>> big_struct_vector = 0,
+    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<WrapperTable>>> many_vectors = 0,
+    ::flatbuffers::Offset64<::flatbuffers::Vector64<uint8_t>> forced_aligned_vector = 0) {
+  RootTableBuilder builder_(_fbb);
+  builder_.add_forced_aligned_vector(forced_aligned_vector);
+  builder_.add_big_struct_vector(big_struct_vector);
+  builder_.add_nested_root(nested_root);
+  builder_.add_big_vector(big_vector);
+  builder_.add_many_vectors(many_vectors);
+  builder_.add_far_struct_vector(far_struct_vector);
+  builder_.add_near_string(near_string);
+  builder_.add_far_string(far_string);
+  builder_.add_a(a);
+  builder_.add_far_vector(far_vector);
+  return builder_.Finish();
+}
+
+inline ::flatbuffers::Offset<RootTable> CreateRootTableDirect(
+    ::flatbuffers::FlatBufferBuilder64 &_fbb,
+    const std::vector<uint8_t> *far_vector = nullptr,
+    int32_t a = 0,
+    const char *far_string = nullptr,
+    const std::vector<uint8_t> *big_vector = nullptr,
+    const char *near_string = nullptr,
+    const std::vector<uint8_t> *nested_root = nullptr,
+    const std::vector<LeafStruct> *far_struct_vector = nullptr,
+    const std::vector<LeafStruct> *big_struct_vector = nullptr,
+    const std::vector<::flatbuffers::Offset<WrapperTable>> *many_vectors = nullptr,
+    const std::vector<uint8_t> *forced_aligned_vector = nullptr) {
+  auto far_vector__ = far_vector ? _fbb.CreateVector64<::flatbuffers::Vector>(*far_vector) : 0;
+  auto far_string__ = far_string ? _fbb.CreateString<::flatbuffers::Offset64>(far_string) : 0;
+  auto big_vector__ = big_vector ? _fbb.CreateVector64(*big_vector) : 0;
+  auto nested_root__ = nested_root ? _fbb.CreateVector64(*nested_root) : 0;
+  auto far_struct_vector__ = far_struct_vector ? _fbb.CreateVectorOfStructs64<::flatbuffers::Vector>(*far_struct_vector) : 0;
+  auto big_struct_vector__ = big_struct_vector ? _fbb.CreateVectorOfStructs64(*big_struct_vector) : 0;
+  if (forced_aligned_vector) { _fbb.ForceVectorAlignment64(forced_aligned_vector->size(), sizeof(uint8_t), 32); }
+  auto forced_aligned_vector__ = forced_aligned_vector ? _fbb.CreateVector64(*forced_aligned_vector) : 0;
+  auto near_string__ = near_string ? _fbb.CreateString(near_string) : 0;
+  auto many_vectors__ = many_vectors ? _fbb.CreateVector<::flatbuffers::Offset<WrapperTable>>(*many_vectors) : 0;
+  return CreateRootTable(
+      _fbb,
+      far_vector__,
+      a,
+      far_string__,
+      big_vector__,
+      near_string__,
+      nested_root__,
+      far_struct_vector__,
+      big_struct_vector__,
+      many_vectors__,
+      forced_aligned_vector__);
+}
+
+::flatbuffers::Offset<RootTable> CreateRootTable(::flatbuffers::FlatBufferBuilder64 &_fbb, const RootTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+
+inline bool operator==(const WrapperTableT &lhs, const WrapperTableT &rhs) {
+  return
+      (lhs.vector == rhs.vector);
+}
+
+inline bool operator!=(const WrapperTableT &lhs, const WrapperTableT &rhs) {
+    return !(lhs == rhs);
+}
+
+
+inline WrapperTableT *WrapperTable::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
+  auto _o = std::unique_ptr<WrapperTableT>(new WrapperTableT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void WrapperTable::UnPackTo(WrapperTableT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = vector(); if (_e) { _o->vector.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->vector.begin()); } }
+}
+
+inline ::flatbuffers::Offset<WrapperTable> WrapperTable::Pack(::flatbuffers::FlatBufferBuilder64 &_fbb, const WrapperTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
+  return CreateWrapperTable(_fbb, _o, _rehasher);
+}
+
+inline ::flatbuffers::Offset<WrapperTable> CreateWrapperTable(::flatbuffers::FlatBufferBuilder64 &_fbb, const WrapperTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { ::flatbuffers::FlatBufferBuilder64 *__fbb; const WrapperTableT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _vector = _o->vector.size() ? _fbb.CreateVector64<::flatbuffers::Vector>(_o->vector) : 0;
+  return CreateWrapperTable(
+      _fbb,
+      _vector);
+}
+
+
+inline bool operator==(const RootTableT &lhs, const RootTableT &rhs) {
+  return
+      (lhs.far_vector == rhs.far_vector) &&
+      (lhs.a == rhs.a) &&
+      (lhs.far_string == rhs.far_string) &&
+      (lhs.big_vector == rhs.big_vector) &&
+      (lhs.near_string == rhs.near_string) &&
+      (lhs.nested_root == rhs.nested_root) &&
+      (lhs.far_struct_vector == rhs.far_struct_vector) &&
+      (lhs.big_struct_vector == rhs.big_struct_vector) &&
+      (lhs.many_vectors.size() == rhs.many_vectors.size() && std::equal(lhs.many_vectors.cbegin(), lhs.many_vectors.cend(), rhs.many_vectors.cbegin(), [](std::unique_ptr<WrapperTableT> const &a, std::unique_ptr<WrapperTableT> const &b) { return (a == b) || (a && b && *a == *b); })) &&
+      (lhs.forced_aligned_vector == rhs.forced_aligned_vector);
+}
+
+inline bool operator!=(const RootTableT &lhs, const RootTableT &rhs) {
+    return !(lhs == rhs);
+}
+
+
+inline RootTableT::RootTableT(const RootTableT &o)
+      : far_vector(o.far_vector),
+        a(o.a),
+        far_string(o.far_string),
+        big_vector(o.big_vector),
+        near_string(o.near_string),
+        nested_root(o.nested_root),
+        far_struct_vector(o.far_struct_vector),
+        big_struct_vector(o.big_struct_vector),
+        forced_aligned_vector(o.forced_aligned_vector) {
+  many_vectors.reserve(o.many_vectors.size());
+  for (const auto &many_vectors_ : o.many_vectors) { many_vectors.emplace_back((many_vectors_) ? new WrapperTableT(*many_vectors_) : nullptr); }
+}
+
+inline RootTableT &RootTableT::operator=(RootTableT o) FLATBUFFERS_NOEXCEPT {
+  std::swap(far_vector, o.far_vector);
+  std::swap(a, o.a);
+  std::swap(far_string, o.far_string);
+  std::swap(big_vector, o.big_vector);
+  std::swap(near_string, o.near_string);
+  std::swap(nested_root, o.nested_root);
+  std::swap(far_struct_vector, o.far_struct_vector);
+  std::swap(big_struct_vector, o.big_struct_vector);
+  std::swap(many_vectors, o.many_vectors);
+  std::swap(forced_aligned_vector, o.forced_aligned_vector);
+  return *this;
+}
+
+inline RootTableT *RootTable::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
+  auto _o = std::unique_ptr<RootTableT>(new RootTableT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void RootTable::UnPackTo(RootTableT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = far_vector(); if (_e) { _o->far_vector.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->far_vector.begin()); } }
+  { auto _e = a(); _o->a = _e; }
+  { auto _e = far_string(); if (_e) _o->far_string = _e->str(); }
+  { auto _e = big_vector(); if (_e) { _o->big_vector.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->big_vector.begin()); } }
+  { auto _e = near_string(); if (_e) _o->near_string = _e->str(); }
+  { auto _e = nested_root(); if (_e) { _o->nested_root.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->nested_root.begin()); } }
+  { auto _e = far_struct_vector(); if (_e) { _o->far_struct_vector.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->far_struct_vector[_i] = *_e->Get(_i); } } else { _o->far_struct_vector.resize(0); } }
+  { auto _e = big_struct_vector(); if (_e) { _o->big_struct_vector.resize(_e->size()); for (::flatbuffers::uoffset64_t _i = 0; _i < _e->size(); _i++) { _o->big_struct_vector[_i] = *_e->Get(_i); } } else { _o->big_struct_vector.resize(0); } }
+  { auto _e = many_vectors(); if (_e) { _o->many_vectors.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->many_vectors[_i]) { _e->Get(_i)->UnPackTo(_o->many_vectors[_i].get(), _resolver); } else { _o->many_vectors[_i] = std::unique_ptr<WrapperTableT>(_e->Get(_i)->UnPack(_resolver)); }; } } else { _o->many_vectors.resize(0); } }
+  { auto _e = forced_aligned_vector(); if (_e) { _o->forced_aligned_vector.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->forced_aligned_vector.begin()); } }
+}
+
+inline ::flatbuffers::Offset<RootTable> RootTable::Pack(::flatbuffers::FlatBufferBuilder64 &_fbb, const RootTableT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
+  return CreateRootTable(_fbb, _o, _rehasher);
+}
+
+inline ::flatbuffers::Offset<RootTable> CreateRootTable(::flatbuffers::FlatBufferBuilder64 &_fbb, const RootTableT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { ::flatbuffers::FlatBufferBuilder64 *__fbb; const RootTableT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _far_vector = _o->far_vector.size() ? _fbb.CreateVector64<::flatbuffers::Vector>(_o->far_vector) : 0;
+  auto _a = _o->a;
+  auto _far_string = _o->far_string.empty() ? 0 : _fbb.CreateString<::flatbuffers::Offset64>(_o->far_string);
+  auto _big_vector = _o->big_vector.size() ? _fbb.CreateVector64(_o->big_vector) : 0;
+  auto _near_string = _o->near_string.empty() ? 0 : _fbb.CreateString(_o->near_string);
+  auto _nested_root = _o->nested_root.size() ? _fbb.CreateVector64(_o->nested_root) : 0;
+  auto _far_struct_vector = _o->far_struct_vector.size() ? _fbb.CreateVectorOfStructs64<::flatbuffers::Vector>(_o->far_struct_vector) : 0;
+  auto _big_struct_vector = _o->big_struct_vector.size() ? _fbb.CreateVectorOfStructs64(_o->big_struct_vector) : 0;
+  auto _many_vectors = _o->many_vectors.size() ? _fbb.CreateVector<::flatbuffers::Offset<WrapperTable>> (_o->many_vectors.size(), [](size_t i, _VectorArgs *__va) { return CreateWrapperTable(*__va->__fbb, __va->__o->many_vectors[i].get(), __va->__rehasher); }, &_va ) : 0;
+  _fbb.ForceVectorAlignment64(_o->forced_aligned_vector.size(), sizeof(uint8_t), 32);
+  auto _forced_aligned_vector = _o->forced_aligned_vector.size() ? _fbb.CreateVector64(_o->forced_aligned_vector) : 0;
+  return CreateRootTable(
+      _fbb,
+      _far_vector,
+      _a,
+      _far_string,
+      _big_vector,
+      _near_string,
+      _nested_root,
+      _far_struct_vector,
+      _big_struct_vector,
+      _many_vectors,
+      _forced_aligned_vector);
+}
+
+inline const ::flatbuffers::TypeTable *LeafStructTypeTable() {
+  static const ::flatbuffers::TypeCode type_codes[] = {
+    { ::flatbuffers::ET_INT, 0, -1 },
+    { ::flatbuffers::ET_DOUBLE, 0, -1 }
+  };
+  static const int64_t values[] = { 0, 8, 16 };
+  static const char * const names[] = {
+    "a",
+    "b"
+  };
+  static const ::flatbuffers::TypeTable tt = {
+    ::flatbuffers::ST_STRUCT, 2, type_codes, nullptr, nullptr, values, names
+  };
+  return &tt;
+}
+
+inline const ::flatbuffers::TypeTable *WrapperTableTypeTable() {
+  static const ::flatbuffers::TypeCode type_codes[] = {
+    { ::flatbuffers::ET_CHAR, 1, -1 }
+  };
+  static const char * const names[] = {
+    "vector"
+  };
+  static const ::flatbuffers::TypeTable tt = {
+    ::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
+  };
+  return &tt;
+}
+
+inline const ::flatbuffers::TypeTable *RootTableTypeTable() {
+  static const ::flatbuffers::TypeCode type_codes[] = {
+    { ::flatbuffers::ET_UCHAR, 1, -1 },
+    { ::flatbuffers::ET_INT, 0, -1 },
+    { ::flatbuffers::ET_STRING, 0, -1 },
+    { ::flatbuffers::ET_UCHAR, 1, -1 },
+    { ::flatbuffers::ET_STRING, 0, -1 },
+    { ::flatbuffers::ET_UCHAR, 1, -1 },
+    { ::flatbuffers::ET_SEQUENCE, 1, 0 },
+    { ::flatbuffers::ET_SEQUENCE, 1, 0 },
+    { ::flatbuffers::ET_SEQUENCE, 1, 1 },
+    { ::flatbuffers::ET_UCHAR, 1, -1 }
+  };
+  static const ::flatbuffers::TypeFunction type_refs[] = {
+    LeafStructTypeTable,
+    WrapperTableTypeTable
+  };
+  static const char * const names[] = {
+    "far_vector",
+    "a",
+    "far_string",
+    "big_vector",
+    "near_string",
+    "nested_root",
+    "far_struct_vector",
+    "big_struct_vector",
+    "many_vectors",
+    "forced_aligned_vector"
+  };
+  static const ::flatbuffers::TypeTable tt = {
+    ::flatbuffers::ST_TABLE, 10, type_codes, type_refs, nullptr, nullptr, names
+  };
+  return &tt;
+}
+
+inline const RootTable *GetRootTable(const void *buf) {
+  return ::flatbuffers::GetRoot<RootTable>(buf);
+}
+
+inline const RootTable *GetSizePrefixedRootTable(const void *buf) {
+  return ::flatbuffers::GetSizePrefixedRoot<RootTable,::flatbuffers::uoffset64_t>(buf);
+}
+
+inline RootTable *GetMutableRootTable(void *buf) {
+  return ::flatbuffers::GetMutableRoot<RootTable>(buf);
+}
+
+inline RootTable *GetMutableSizePrefixedRootTable(void *buf) {
+  return ::flatbuffers::GetMutableSizePrefixedRoot<RootTable,::flatbuffers::uoffset64_t>(buf);
+}
+
+inline bool VerifyRootTableBuffer(
+    ::flatbuffers::Verifier &verifier) {
+  return verifier.VerifyBuffer<RootTable>(nullptr);
+}
+
+inline bool VerifySizePrefixedRootTableBuffer(
+    ::flatbuffers::Verifier &verifier) {
+  return verifier.VerifySizePrefixedBuffer<RootTable,::flatbuffers::uoffset64_t>(nullptr);
+}
+
+inline void FinishRootTableBuffer(
+    ::flatbuffers::FlatBufferBuilder64 &fbb,
+    ::flatbuffers::Offset<RootTable> root) {
+  fbb.Finish(root);
+}
+
+inline void FinishSizePrefixedRootTableBuffer(
+    ::flatbuffers::FlatBufferBuilder64 &fbb,
+    ::flatbuffers::Offset<RootTable> root) {
+  fbb.FinishSizePrefixed(root);
+}
+
+inline std::unique_ptr<RootTableT> UnPackRootTable(
+    const void *buf,
+    const ::flatbuffers::resolver_function_t *res = nullptr) {
+  return std::unique_ptr<RootTableT>(GetRootTable(buf)->UnPack(res));
+}
+
+inline std::unique_ptr<RootTableT> UnPackSizePrefixedRootTable(
+    const void *buf,
+    const ::flatbuffers::resolver_function_t *res = nullptr) {
+  return std::unique_ptr<RootTableT>(GetSizePrefixedRootTable(buf)->UnPack(res));
+}
+
+#endif  // FLATBUFFERS_GENERATED_TEST64BIT_H_

tests/Abc.nim

@@ -2,7 +2,7 @@
   Automatically generated by the FlatBuffers compiler, do not modify.
   Or modify. I'm a message, not a cop.
 
-  flatc version: 23.3.3
+  flatc version: 23.5.26
 
   Declared by  : 
 ]#

tests/BUILD.bazel

@@ -1,6 +1,6 @@
 load("@aspect_bazel_lib//lib:copy_to_bin.bzl", "copy_to_bin")
 load("@rules_cc//cc:defs.bzl", "cc_test")
-load("//:build_defs.bzl", "flatbuffer_cc_library")
+load("//:build_defs.bzl", "DEFAULT_FLATC_ARGS", "flatbuffer_cc_library")
 
 package(default_visibility = ["//visibility:private"])
 
@@ -20,6 +20,12 @@ cc_test(
     name = "flatbuffers_test",
     testonly = 1,
     srcs = [
+        "64bit/evolution/v1_generated.h",
+        "64bit/evolution/v2_generated.h",
+        "64bit/offset64_test.cpp",
+        "64bit/offset64_test.h",
+        "64bit/test_64bit_bfbs_generated.h",
+        "64bit/test_64bit_generated.h",
         "alignment_test.cpp",
         "alignment_test.h",
         "alignment_test_generated.h",
@@ -59,13 +65,13 @@ cc_test(
         "test_assert.h",
         "test_builder.cpp",
         "test_builder.h",
+        "union_underlying_type_test_generated.h",
         "union_vector/union_vector_generated.h",
         "util_test.cpp",
         "util_test.h",
     ],
     copts = [
         "-DFLATBUFFERS_TRACK_VERIFIER_BUFFER_SIZE",
-        "-DBAZEL_TEST_DATA_PATH",
     ],
     data = [
         ":alignment_test.fbs",
@@ -125,6 +131,7 @@ cc_test(
         ":monster_test_cc_fbs",
         ":native_type_test_cc_fbs",
         "//:flatbuffers",
+        "//src:generate_fbs",
     ],
 )
 
@@ -159,6 +166,7 @@ cc_library(
     ],
     hdrs = [
         "monster_test.grpc.fb.h",
+        "monster_test_bfbs_generated.h",
         "monster_test_generated.h",
     ],
     includes = ["."],
@@ -181,6 +189,13 @@ flatbuffer_cc_library(
 flatbuffer_cc_library(
     name = "monster_test_cc_fbs",
     srcs = ["monster_test.fbs"],
+    outs = ["monster_test_bfbs_generated.h"],
+    flatc_args = DEFAULT_FLATC_ARGS + [
+        "--bfbs-comments",
+        "--bfbs-builtins",
+        "--bfbs-gen-embed",
+        "--bfbs-filenames tests",
+    ],
     include_paths = ["tests/include_test"],
     visibility = ["//grpc/tests:__subpackages__"],
     deps = [":include_test_fbs"],

tests/DictionaryLookup/LongFloatEntry.java

@@ -21,7 +21,7 @@ import java.nio.ByteOrder;
 
 @SuppressWarnings("unused")
 public final class LongFloatEntry extends Table {
-  public static void ValidateVersion() { Constants.FLATBUFFERS_23_3_3(); }
+  public static void ValidateVersion() { Constants.FLATBUFFERS_23_5_26(); }
   public static LongFloatEntry getRootAsLongFloatEntry(ByteBuffer _bb) { return getRootAsLongFloatEntry(_bb, new LongFloatEntry()); }
   public static LongFloatEntry getRootAsLongFloatEntry(ByteBuffer _bb, LongFloatEntry obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
   public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }

tests/DictionaryLookup/LongFloatEntry.kt

@@ -44,7 +44,7 @@ class LongFloatEntry : Table() {
         return (val_1 - val_2).sign
     }
     companion object {
-        fun validateVersion() = Constants.FLATBUFFERS_23_3_3()
+        fun validateVersion() = Constants.FLATBUFFERS_23_5_26()
         fun getRootAsLongFloatEntry(_bb: ByteBuffer): LongFloatEntry = getRootAsLongFloatEntry(_bb, LongFloatEntry())
         fun getRootAsLongFloatEntry(_bb: ByteBuffer, obj: LongFloatEntry): LongFloatEntry {
             _bb.order(ByteOrder.LITTLE_ENDIAN)

tests/DictionaryLookup/LongFloatMap.java

@@ -21,7 +21,7 @@ import java.nio.ByteOrder;
 
 @SuppressWarnings("unused")
 public final class LongFloatMap extends Table {
-  public static void ValidateVersion() { Constants.FLATBUFFERS_23_3_3(); }
+  public static void ValidateVersion() { Constants.FLATBUFFERS_23_5_26(); }
   public static LongFloatMap getRootAsLongFloatMap(ByteBuffer _bb) { return getRootAsLongFloatMap(_bb, new LongFloatMap()); }
   public static LongFloatMap getRootAsLongFloatMap(ByteBuffer _bb, LongFloatMap obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
   public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }

tests/DictionaryLookup/LongFloatMap.kt

@@ -58,7 +58,7 @@ class LongFloatMap : Table() {
         }
     }
     companion object {
-        fun validateVersion() = Constants.FLATBUFFERS_23_3_3()
+        fun validateVersion() = Constants.FLATBUFFERS_23_5_26()
         fun getRootAsLongFloatMap(_bb: ByteBuffer): LongFloatMap = getRootAsLongFloatMap(_bb, LongFloatMap())
         fun getRootAsLongFloatMap(_bb: ByteBuffer, obj: LongFloatMap): LongFloatMap {
             _bb.order(ByteOrder.LITTLE_ENDIAN)

tests/KeywordTest/KeywordsInTable.cs

@@ -13,7 +13,7 @@ public struct KeywordsInTable : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
-  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_3_3(); }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_26(); }
   public static KeywordsInTable GetRootAsKeywordsInTable(ByteBuffer _bb) { return GetRootAsKeywordsInTable(_bb, new KeywordsInTable()); }
   public static KeywordsInTable GetRootAsKeywordsInTable(ByteBuffer _bb, KeywordsInTable obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
   public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }

tests/KeywordTest/Table2.cs

@@ -13,7 +13,7 @@ public struct Table2 : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
-  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_3_3(); }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_26(); }
   public static Table2 GetRootAsTable2(ByteBuffer _bb) { return GetRootAsTable2(_bb, new Table2()); }
   public static Table2 GetRootAsTable2(ByteBuffer _bb, Table2 obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
   public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }

tests/KotlinTest.sh

@@ -34,7 +34,7 @@ fi
 all_kt_files=`find . -name "*.kt" -print`
 
 # Compile java FlatBuffer library 
-javac ${testdir}/../java/com/google/flatbuffers/*.java -d $targetdir
+javac ${testdir}/../java/src/main/java/com/google/flatbuffers/*.java -d $targetdir
 # Compile Kotlin files
 kotlinc $all_kt_files -classpath $targetdir -include-runtime -d $targetdir
 # Make jar

tests/MoreDefaults.nim

@@ -2,7 +2,7 @@
   Automatically generated by the FlatBuffers compiler, do not modify.
   Or modify. I'm a message, not a cop.
 
-  flatc version: 23.3.3
+  flatc version: 23.5.26
 
   Declared by  : 
 ]#

tests/MyGame/Example/Ability.lua

@@ -3,7 +3,7 @@
   Automatically generated by the FlatBuffers compiler, do not modify.
   Or modify. I'm a message, not a cop.
 
-  flatc version: 23.3.3
+  flatc version: 23.5.26
 
   Declared by  : //monster_test.fbs
   Rooting type : MyGame.Example.Monster (//monster_test.fbs)

tests/MyGame/Example/Ability.nim

@@ -2,7 +2,7 @@
   Automatically generated by the FlatBuffers compiler, do not modify.
   Or modify. I'm a message, not a cop.
 
-  flatc version: 23.3.3
+  flatc version: 23.5.26
 
   Declared by  : 
   Rooting type : MyGame.Example.Monster ()

tests/MyGame/Example/Any.lua

@@ -3,7 +3,7 @@
   Automatically generated by the FlatBuffers compiler, do not modify.
   Or modify. I'm a message, not a cop.
 
-  flatc version: 23.3.3
+  flatc version: 23.5.26
 
   Declared by  : //monster_test.fbs
   Rooting type : MyGame.Example.Monster (//monster_test.fbs)

tests/MyGame/Example/Any.nim

@@ -2,7 +2,7 @@
   Automatically generated by the FlatBuffers compiler, do not modify.
   Or modify. I'm a message, not a cop.
 
-  flatc version: 23.3.3
+  flatc version: 23.5.26
 
   Declared by  : 
   Rooting type : MyGame.Example.Monster ()

tests/MyGame/Example/AnyAmbiguousAliases.lua

@@ -3,7 +3,7 @@
   Automatically generated by the FlatBuffers compiler, do not modify.
   Or modify. I'm a message, not a cop.
 
-  flatc version: 23.3.3
+  flatc version: 23.5.26
 
   Declared by  : //monster_test.fbs
   Rooting type : MyGame.Example.Monster (//monster_test.fbs)

tests/MyGame/Example/AnyAmbiguousAliases.nim

@@ -2,7 +2,7 @@
   Automatically generated by the FlatBuffers compiler, do not modify.
   Or modify. I'm a message, not a cop.
 
-  flatc version: 23.3.3
+  flatc version: 23.5.26
 
   Declared by  : 
   Rooting type : MyGame.Example.Monster ()

tests/MyGame/Example/AnyUniqueAliases.lua

@@ -3,7 +3,7 @@
   Automatically generated by the FlatBuffers compiler, do not modify.
   Or modify. I'm a message, not a cop.
 
-  flatc version: 23.3.3
+  flatc version: 23.5.26
 
   Declared by  : //monster_test.fbs
   Rooting type : MyGame.Example.Monster (//monster_test.fbs)

tests/MyGame/Example/AnyUniqueAliases.nim

@@ -2,7 +2,7 @@
   Automatically generated by the FlatBuffers compiler, do not modify.
   Or modify. I'm a message, not a cop.
 
-  flatc version: 23.3.3
+  flatc version: 23.5.26
 
   Declared by  : 
   Rooting type : MyGame.Example.Monster ()

tests/MyGame/Example/ArrayStruct.py

@@ -5,7 +5,7 @@
 import flatbuffers
 from flatbuffers.compat import import_numpy
 from typing import Any
-from .MyGame.Example.NestedStruct import NestedStruct
+from MyGame.Example.NestedStruct import NestedStruct
 np = import_numpy()
 
 class ArrayStruct(object):

tests/MyGame/Example/ArrayTable.cs

@@ -13,7 +13,7 @@ public struct ArrayTable : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
-  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_3_3(); }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_26(); }
   public static ArrayTable GetRootAsArrayTable(ByteBuffer _bb) { return GetRootAsArrayTable(_bb, new ArrayTable()); }
   public static ArrayTable GetRootAsArrayTable(ByteBuffer _bb, ArrayTable obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
   public static bool ArrayTableBufferHasIdentifier(ByteBuffer _bb) { return Table.__has_identifier(_bb, "ARRT"); }

tests/MyGame/Example/ArrayTable.java

@@ -21,7 +21,7 @@ import java.nio.ByteOrder;
 
 @SuppressWarnings("unused")
 public final class ArrayTable extends Table {
-  public static void ValidateVersion() { Constants.FLATBUFFERS_23_3_3(); }
+  public static void ValidateVersion() { Constants.FLATBUFFERS_23_5_26(); }
   public static ArrayTable getRootAsArrayTable(ByteBuffer _bb) { return getRootAsArrayTable(_bb, new ArrayTable()); }
   public static ArrayTable getRootAsArrayTable(ByteBuffer _bb, ArrayTable obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
   public static boolean ArrayTableBufferHasIdentifier(ByteBuffer _bb) { return __has_identifier(_bb, "ARRT"); }

tests/MyGame/Example/ArrayTable.py

@@ -5,7 +5,7 @@
 import flatbuffers
 from flatbuffers.compat import import_numpy
 from typing import Any
-from .MyGame.Example.ArrayStruct import ArrayStruct
+from MyGame.Example.ArrayStruct import ArrayStruct
 from typing import Optional
 np = import_numpy()
 

tests/MyGame/Example/Color.lua

@@ -3,7 +3,7 @@
   Automatically generated by the FlatBuffers compiler, do not modify.
   Or modify. I'm a message, not a cop.
 
-  flatc version: 23.3.3
+  flatc version: 23.5.26
 
   Declared by  : //monster_test.fbs
   Rooting type : MyGame.Example.Monster (//monster_test.fbs)

tests/MyGame/Example/Color.nim

@@ -2,7 +2,7 @@
   Automatically generated by the FlatBuffers compiler, do not modify.
   Or modify. I'm a message, not a cop.
 
-  flatc version: 23.3.3
+  flatc version: 23.5.26
 
   Declared by  : 
   Rooting type : MyGame.Example.Monster ()

tests/MyGame/Example/LongEnum.lua

@@ -3,7 +3,7 @@
   Automatically generated by the FlatBuffers compiler, do not modify.
   Or modify. I'm a message, not a cop.
 
-  flatc version: 23.3.3
+  flatc version: 23.5.26
 
   Declared by  : //monster_test.fbs
   Rooting type : MyGame.Example.Monster (//monster_test.fbs)

tests/MyGame/Example/LongEnum.nim

@@ -2,7 +2,7 @@
   Automatically generated by the FlatBuffers compiler, do not modify.
   Or modify. I'm a message, not a cop.
 
-  flatc version: 23.3.3
+  flatc version: 23.5.26
 
   Declared by  : 
   Rooting type : MyGame.Example.Monster ()

tests/MyGame/Example/Monster.cs

@@ -14,7 +14,7 @@ public struct Monster : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
-  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_3_3(); }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_26(); }
   public static Monster GetRootAsMonster(ByteBuffer _bb) { return GetRootAsMonster(_bb, new Monster()); }
   public static Monster GetRootAsMonster(ByteBuffer _bb, Monster obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
   public static bool MonsterBufferHasIdentifier(ByteBuffer _bb) { return Table.__has_identifier(_bb, "MONS"); }

tests/MyGame/Example/Monster.java

@@ -24,7 +24,7 @@ import java.nio.ByteOrder;
  */
 @SuppressWarnings("unused")
 public final class Monster extends Table {
-  public static void ValidateVersion() { Constants.FLATBUFFERS_23_3_3(); }
+  public static void ValidateVersion() { Constants.FLATBUFFERS_23_5_26(); }
   public static Monster getRootAsMonster(ByteBuffer _bb) { return getRootAsMonster(_bb, new Monster()); }
   public static Monster getRootAsMonster(ByteBuffer _bb, Monster obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
   public static boolean MonsterBufferHasIdentifier(ByteBuffer _bb) { return __has_identifier(_bb, "MONS"); }

tests/MyGame/Example/Monster.kt

@@ -1002,7 +1002,7 @@ class Monster : Table() {
          return compareStrings(__offset(10, o1, _bb), __offset(10, o2, _bb), _bb)
     }
     companion object {
-        fun validateVersion() = Constants.FLATBUFFERS_23_3_3()
+        fun validateVersion() = Constants.FLATBUFFERS_23_5_26()
         fun getRootAsMonster(_bb: ByteBuffer): Monster = getRootAsMonster(_bb, Monster())
         fun getRootAsMonster(_bb: ByteBuffer, obj: Monster): Monster {
             _bb.order(ByteOrder.LITTLE_ENDIAN)

tests/MyGame/Example/Monster.lua

@@ -3,7 +3,7 @@
   Automatically generated by the FlatBuffers compiler, do not modify.
   Or modify. I'm a message, not a cop.
 
-  flatc version: 23.3.3
+  flatc version: 23.5.26
 
   Declared by  : //monster_test.fbs
   Rooting type : MyGame.Example.Monster (//monster_test.fbs)

tests/MyGame/Example/Monster.nim

@@ -2,7 +2,7 @@
   Automatically generated by the FlatBuffers compiler, do not modify.
   Or modify. I'm a message, not a cop.
 
-  flatc version: 23.3.3
+  flatc version: 23.5.26
 
   Declared by  : 
   Rooting type : MyGame.Example.Monster ()

tests/MyGame/Example/Monster.php

@@ -910,7 +910,7 @@ class Monster extends Table
 
     /**
      * @param FlatBufferBuilder $builder
-     * @param int
+     * @param VectorOffset
      * @return void
      */
     public static function addPos(FlatBufferBuilder $builder, $pos)
@@ -1111,7 +1111,7 @@ class Monster extends Table
 
     /**
      * @param FlatBufferBuilder $builder
-     * @param int
+     * @param VectorOffset
      * @return void
      */
     public static function addEnemy(FlatBufferBuilder $builder, $enemy)
@@ -1155,7 +1155,7 @@ class Monster extends Table
 
     /**
      * @param FlatBufferBuilder $builder
-     * @param int
+     * @param VectorOffset
      * @return void
      */
     public static function addTestempty(FlatBufferBuilder $builder, $testempty)
@@ -1523,7 +1523,7 @@ class Monster extends Table
 
     /**
      * @param FlatBufferBuilder $builder
-     * @param int
+     * @param VectorOffset
      * @return void
      */
     public static function addParentNamespaceTest(FlatBufferBuilder $builder, $parentNamespaceTest)
@@ -1875,7 +1875,7 @@ class Monster extends Table
 
     /**
      * @param FlatBufferBuilder $builder
-     * @param int
+     * @param VectorOffset
      * @return void
      */
     public static function addNativeInline(FlatBufferBuilder $builder, $nativeInline)

tests/MyGame/Example/Monster.py

@@ -34,7 +34,7 @@ class Monster(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
         if o != 0:
             x = o + self._tab.Pos
-            from .MyGame.Example.Vec3 import Vec3
+            from MyGame.Example.Vec3 import Vec3
             obj = Vec3()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -118,7 +118,7 @@ class Monster(object):
         if o != 0:
             x = self._tab.Vector(o)
             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
-            from .MyGame.Example.Test import Test
+            from MyGame.Example.Test import Test
             obj = Test()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -165,7 +165,7 @@ class Monster(object):
             x = self._tab.Vector(o)
             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
             x = self._tab.Indirect(x)
-            from .MyGame.Example.Monster import Monster
+            from MyGame.Example.Monster import Monster
             obj = Monster()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -188,7 +188,7 @@ class Monster(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
         if o != 0:
             x = self._tab.Indirect(o + self._tab.Pos)
-            from .MyGame.Example.Monster import Monster
+            from MyGame.Example.Monster import Monster
             obj = Monster()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -213,7 +213,7 @@ class Monster(object):
     def TestnestedflatbufferNestedRoot(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
         if o != 0:
-            from .MyGame.Example.Monster import Monster
+            from MyGame.Example.Monster import Monster
             return Monster.GetRootAs(self._tab.Bytes, self._tab.Vector(o))
         return 0
 
@@ -234,7 +234,7 @@ class Monster(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
         if o != 0:
             x = self._tab.Indirect(o + self._tab.Pos)
-            from .MyGame.Example.Stat import Stat
+            from MyGame.Example.Stat import Stat
             obj = Stat()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -377,7 +377,7 @@ class Monster(object):
         if o != 0:
             x = self._tab.Vector(o)
             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 8
-            from .MyGame.Example.Ability import Ability
+            from MyGame.Example.Ability import Ability
             obj = Ability()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -428,7 +428,7 @@ class Monster(object):
         if o != 0:
             x = self._tab.Vector(o)
             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
-            from .MyGame.Example.Test import Test
+            from MyGame.Example.Test import Test
             obj = Test()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -505,7 +505,7 @@ class Monster(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(72))
         if o != 0:
             x = self._tab.Indirect(o + self._tab.Pos)
-            from .MyGame.InParentNamespace import InParentNamespace
+            from MyGame.InParentNamespace import InParentNamespace
             obj = InParentNamespace()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -518,7 +518,7 @@ class Monster(object):
             x = self._tab.Vector(o)
             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
             x = self._tab.Indirect(x)
-            from .MyGame.Example.Referrable import Referrable
+            from MyGame.Example.Referrable import Referrable
             obj = Referrable()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -577,7 +577,7 @@ class Monster(object):
             x = self._tab.Vector(o)
             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
             x = self._tab.Indirect(x)
-            from .MyGame.Example.Referrable import Referrable
+            from MyGame.Example.Referrable import Referrable
             obj = Referrable()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -750,7 +750,7 @@ class Monster(object):
     def TestrequirednestedflatbufferNestedRoot(self):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
         if o != 0:
-            from .MyGame.Example.Monster import Monster
+            from MyGame.Example.Monster import Monster
             return Monster.GetRootAs(self._tab.Bytes, self._tab.Vector(o))
         return 0
 
@@ -773,7 +773,7 @@ class Monster(object):
             x = self._tab.Vector(o)
             x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
             x = self._tab.Indirect(x)
-            from .MyGame.Example.Stat import Stat
+            from MyGame.Example.Stat import Stat
             obj = Stat()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -796,7 +796,7 @@ class Monster(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(106))
         if o != 0:
             x = o + self._tab.Pos
-            from .MyGame.Example.Test import Test
+            from MyGame.Example.Test import Test
             obj = Test()
             obj.Init(self._tab.Bytes, x)
             return obj
@@ -881,31 +881,31 @@ def Start(builder):
 def MonsterAddPos(builder, pos):
     builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pos), 0)
 
-def AddPos(builder: flatbuffers.Builder, pos: Any):
+def AddPos(builder, pos):
     MonsterAddPos(builder, pos)
 
 def MonsterAddMana(builder, mana):
     builder.PrependInt16Slot(1, mana, 150)
 
-def AddMana(builder: flatbuffers.Builder, mana: int):
+def AddMana(builder, mana):
     MonsterAddMana(builder, mana)
 
 def MonsterAddHp(builder, hp):
     builder.PrependInt16Slot(2, hp, 100)
 
-def AddHp(builder: flatbuffers.Builder, hp: int):
+def AddHp(builder, hp):
     MonsterAddHp(builder, hp)
 
 def MonsterAddName(builder, name):
     builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
 
-def AddName(builder: flatbuffers.Builder, name: int):
+def AddName(builder, name):
     MonsterAddName(builder, name)
 
 def MonsterAddInventory(builder, inventory):
     builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(inventory), 0)
 
-def AddInventory(builder: flatbuffers.Builder, inventory: int):
+def AddInventory(builder, inventory):
     MonsterAddInventory(builder, inventory)
 
 def MonsterStartInventoryVector(builder, numElems):
@@ -917,25 +917,25 @@ def StartInventoryVector(builder, numElems: int) -> int:
 def MonsterAddColor(builder, color):
     builder.PrependUint8Slot(6, color, 8)
 
-def AddColor(builder: flatbuffers.Builder, color: int):
+def AddColor(builder, color):
     MonsterAddColor(builder, color)
 
 def MonsterAddTestType(builder, testType):
     builder.PrependUint8Slot(7, testType, 0)
 
-def AddTestType(builder: flatbuffers.Builder, testType: int):
+def AddTestType(builder, testType):
     MonsterAddTestType(builder, testType)
 
 def MonsterAddTest(builder, test):
     builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(test), 0)
 
-def AddTest(builder: flatbuffers.Builder, test: int):
+def AddTest(builder, test):
     MonsterAddTest(builder, test)
 
 def MonsterAddTest4(builder, test4):
     builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(test4), 0)
 
-def AddTest4(builder: flatbuffers.Builder, test4: int):
+def AddTest4(builder, test4):
     MonsterAddTest4(builder, test4)
 
 def MonsterStartTest4Vector(builder, numElems):
@@ -947,7 +947,7 @@ def StartTest4Vector(builder, numElems: int) -> int:
 def MonsterAddTestarrayofstring(builder, testarrayofstring):
     builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring), 0)
 
-def AddTestarrayofstring(builder: flatbuffers.Builder, testarrayofstring: int):
+def AddTestarrayofstring(builder, testarrayofstring):
     MonsterAddTestarrayofstring(builder, testarrayofstring)
 
 def MonsterStartTestarrayofstringVector(builder, numElems):
@@ -959,7 +959,7 @@ def StartTestarrayofstringVector(builder, numElems: int) -> int:
 def MonsterAddTestarrayoftables(builder, testarrayoftables):
     builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayoftables), 0)
 
-def AddTestarrayoftables(builder: flatbuffers.Builder, testarrayoftables: int):
+def AddTestarrayoftables(builder, testarrayoftables):
     MonsterAddTestarrayoftables(builder, testarrayoftables)
 
 def MonsterStartTestarrayoftablesVector(builder, numElems):
@@ -971,13 +971,13 @@ def StartTestarrayoftablesVector(builder, numElems: int) -> int:
 def MonsterAddEnemy(builder, enemy):
     builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(enemy), 0)
 
-def AddEnemy(builder: flatbuffers.Builder, enemy: int):
+def AddEnemy(builder, enemy):
     MonsterAddEnemy(builder, enemy)
 
 def MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer):
     builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(testnestedflatbuffer), 0)
 
-def AddTestnestedflatbuffer(builder: flatbuffers.Builder, testnestedflatbuffer: int):
+def AddTestnestedflatbuffer(builder, testnestedflatbuffer):
     MonsterAddTestnestedflatbuffer(builder, testnestedflatbuffer)
 
 def MonsterStartTestnestedflatbufferVector(builder, numElems):
@@ -996,67 +996,67 @@ def MakeTestnestedflatbufferVectorFromBytes(builder, bytes):
 def MonsterAddTestempty(builder, testempty):
     builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(testempty), 0)
 
-def AddTestempty(builder: flatbuffers.Builder, testempty: int):
+def AddTestempty(builder, testempty):
     MonsterAddTestempty(builder, testempty)
 
 def MonsterAddTestbool(builder, testbool):
     builder.PrependBoolSlot(15, testbool, 0)
 
-def AddTestbool(builder: flatbuffers.Builder, testbool: bool):
+def AddTestbool(builder, testbool):
     MonsterAddTestbool(builder, testbool)
 
 def MonsterAddTesthashs32Fnv1(builder, testhashs32Fnv1):
     builder.PrependInt32Slot(16, testhashs32Fnv1, 0)
 
-def AddTesthashs32Fnv1(builder: flatbuffers.Builder, testhashs32Fnv1: int):
+def AddTesthashs32Fnv1(builder, testhashs32Fnv1):
     MonsterAddTesthashs32Fnv1(builder, testhashs32Fnv1)
 
 def MonsterAddTesthashu32Fnv1(builder, testhashu32Fnv1):
     builder.PrependUint32Slot(17, testhashu32Fnv1, 0)
 
-def AddTesthashu32Fnv1(builder: flatbuffers.Builder, testhashu32Fnv1: int):
+def AddTesthashu32Fnv1(builder, testhashu32Fnv1):
     MonsterAddTesthashu32Fnv1(builder, testhashu32Fnv1)
 
 def MonsterAddTesthashs64Fnv1(builder, testhashs64Fnv1):
     builder.PrependInt64Slot(18, testhashs64Fnv1, 0)
 
-def AddTesthashs64Fnv1(builder: flatbuffers.Builder, testhashs64Fnv1: int):
+def AddTesthashs64Fnv1(builder, testhashs64Fnv1):
     MonsterAddTesthashs64Fnv1(builder, testhashs64Fnv1)
 
 def MonsterAddTesthashu64Fnv1(builder, testhashu64Fnv1):
     builder.PrependUint64Slot(19, testhashu64Fnv1, 0)
 
-def AddTesthashu64Fnv1(builder: flatbuffers.Builder, testhashu64Fnv1: int):
+def AddTesthashu64Fnv1(builder, testhashu64Fnv1):
     MonsterAddTesthashu64Fnv1(builder, testhashu64Fnv1)
 
 def MonsterAddTesthashs32Fnv1a(builder, testhashs32Fnv1a):
     builder.PrependInt32Slot(20, testhashs32Fnv1a, 0)
 
-def AddTesthashs32Fnv1a(builder: flatbuffers.Builder, testhashs32Fnv1a: int):
+def AddTesthashs32Fnv1a(builder, testhashs32Fnv1a):
     MonsterAddTesthashs32Fnv1a(builder, testhashs32Fnv1a)
 
 def MonsterAddTesthashu32Fnv1a(builder, testhashu32Fnv1a):
     builder.PrependUint32Slot(21, testhashu32Fnv1a, 0)
 
-def AddTesthashu32Fnv1a(builder: flatbuffers.Builder, testhashu32Fnv1a: int):
+def AddTesthashu32Fnv1a(builder, testhashu32Fnv1a):
     MonsterAddTesthashu32Fnv1a(builder, testhashu32Fnv1a)
 
 def MonsterAddTesthashs64Fnv1a(builder, testhashs64Fnv1a):
     builder.PrependInt64Slot(22, testhashs64Fnv1a, 0)
 
-def AddTesthashs64Fnv1a(builder: flatbuffers.Builder, testhashs64Fnv1a: int):
+def AddTesthashs64Fnv1a(builder, testhashs64Fnv1a):
     MonsterAddTesthashs64Fnv1a(builder, testhashs64Fnv1a)
 
 def MonsterAddTesthashu64Fnv1a(builder, testhashu64Fnv1a):
     builder.PrependUint64Slot(23, testhashu64Fnv1a, 0)
 
-def AddTesthashu64Fnv1a(builder: flatbuffers.Builder, testhashu64Fnv1a: int):
+def AddTesthashu64Fnv1a(builder, testhashu64Fnv1a):
     MonsterAddTesthashu64Fnv1a(builder, testhashu64Fnv1a)
 
 def MonsterAddTestarrayofbools(builder, testarrayofbools):
     builder.PrependUOffsetTRelativeSlot(24, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofbools), 0)
 
-def AddTestarrayofbools(builder: flatbuffers.Builder, testarrayofbools: int):
+def AddTestarrayofbools(builder, testarrayofbools):
     MonsterAddTestarrayofbools(builder, testarrayofbools)
 
 def MonsterStartTestarrayofboolsVector(builder, numElems):
@@ -1068,25 +1068,25 @@ def StartTestarrayofboolsVector(builder, numElems: int) -> int:
 def MonsterAddTestf(builder, testf):
     builder.PrependFloat32Slot(25, testf, 3.14159)
 
-def AddTestf(builder: flatbuffers.Builder, testf: float):
+def AddTestf(builder, testf):
     MonsterAddTestf(builder, testf)
 
 def MonsterAddTestf2(builder, testf2):
     builder.PrependFloat32Slot(26, testf2, 3.0)
 
-def AddTestf2(builder: flatbuffers.Builder, testf2: float):
+def AddTestf2(builder, testf2):
     MonsterAddTestf2(builder, testf2)
 
 def MonsterAddTestf3(builder, testf3):
     builder.PrependFloat32Slot(27, testf3, 0.0)
 
-def AddTestf3(builder: flatbuffers.Builder, testf3: float):
+def AddTestf3(builder, testf3):
     MonsterAddTestf3(builder, testf3)
 
 def MonsterAddTestarrayofstring2(builder, testarrayofstring2):
     builder.PrependUOffsetTRelativeSlot(28, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring2), 0)
 
-def AddTestarrayofstring2(builder: flatbuffers.Builder, testarrayofstring2: int):
+def AddTestarrayofstring2(builder, testarrayofstring2):
     MonsterAddTestarrayofstring2(builder, testarrayofstring2)
 
 def MonsterStartTestarrayofstring2Vector(builder, numElems):
@@ -1098,7 +1098,7 @@ def StartTestarrayofstring2Vector(builder, numElems: int) -> int:
 def MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct):
     builder.PrependUOffsetTRelativeSlot(29, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofsortedstruct), 0)
 
-def AddTestarrayofsortedstruct(builder: flatbuffers.Builder, testarrayofsortedstruct: int):
+def AddTestarrayofsortedstruct(builder, testarrayofsortedstruct):
     MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct)
 
 def MonsterStartTestarrayofsortedstructVector(builder, numElems):
@@ -1110,7 +1110,7 @@ def StartTestarrayofsortedstructVector(builder, numElems: int) -> int:
 def MonsterAddFlex(builder, flex):
     builder.PrependUOffsetTRelativeSlot(30, flatbuffers.number_types.UOffsetTFlags.py_type(flex), 0)
 
-def AddFlex(builder: flatbuffers.Builder, flex: int):
+def AddFlex(builder, flex):
     MonsterAddFlex(builder, flex)
 
 def MonsterStartFlexVector(builder, numElems):
@@ -1122,7 +1122,7 @@ def StartFlexVector(builder, numElems: int) -> int:
 def MonsterAddTest5(builder, test5):
     builder.PrependUOffsetTRelativeSlot(31, flatbuffers.number_types.UOffsetTFlags.py_type(test5), 0)
 
-def AddTest5(builder: flatbuffers.Builder, test5: int):
+def AddTest5(builder, test5):
     MonsterAddTest5(builder, test5)
 
 def MonsterStartTest5Vector(builder, numElems):
@@ -1134,7 +1134,7 @@ def StartTest5Vector(builder, numElems: int) -> int:
 def MonsterAddVectorOfLongs(builder, vectorOfLongs):
     builder.PrependUOffsetTRelativeSlot(32, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfLongs), 0)
 
-def AddVectorOfLongs(builder: flatbuffers.Builder, vectorOfLongs: int):
+def AddVectorOfLongs(builder, vectorOfLongs):
     MonsterAddVectorOfLongs(builder, vectorOfLongs)
 
 def MonsterStartVectorOfLongsVector(builder, numElems):
@@ -1146,7 +1146,7 @@ def StartVectorOfLongsVector(builder, numElems: int) -> int:
 def MonsterAddVectorOfDoubles(builder, vectorOfDoubles):
     builder.PrependUOffsetTRelativeSlot(33, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfDoubles), 0)
 
-def AddVectorOfDoubles(builder: flatbuffers.Builder, vectorOfDoubles: int):
+def AddVectorOfDoubles(builder, vectorOfDoubles):
     MonsterAddVectorOfDoubles(builder, vectorOfDoubles)
 
 def MonsterStartVectorOfDoublesVector(builder, numElems):
@@ -1158,13 +1158,13 @@ def StartVectorOfDoublesVector(builder, numElems: int) -> int:
 def MonsterAddParentNamespaceTest(builder, parentNamespaceTest):
     builder.PrependUOffsetTRelativeSlot(34, flatbuffers.number_types.UOffsetTFlags.py_type(parentNamespaceTest), 0)
 
-def AddParentNamespaceTest(builder: flatbuffers.Builder, parentNamespaceTest: int):
+def AddParentNamespaceTest(builder, parentNamespaceTest):
     MonsterAddParentNamespaceTest(builder, parentNamespaceTest)
 
 def MonsterAddVectorOfReferrables(builder, vectorOfReferrables):
     builder.PrependUOffsetTRelativeSlot(35, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfReferrables), 0)
 
-def AddVectorOfReferrables(builder: flatbuffers.Builder, vectorOfReferrables: int):
+def AddVectorOfReferrables(builder, vectorOfReferrables):
     MonsterAddVectorOfReferrables(builder, vectorOfReferrables)
 
 def MonsterStartVectorOfReferrablesVector(builder, numElems):
@@ -1176,13 +1176,13 @@ def StartVectorOfReferrablesVector(builder, numElems: int) -> int:
 def MonsterAddSingleWeakReference(builder, singleWeakReference):
     builder.PrependUint64Slot(36, singleWeakReference, 0)
 
-def AddSingleWeakReference(builder: flatbuffers.Builder, singleWeakReference: int):
+def AddSingleWeakReference(builder, singleWeakReference):
     MonsterAddSingleWeakReference(builder, singleWeakReference)
 
 def MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences):
     builder.PrependUOffsetTRelativeSlot(37, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfWeakReferences), 0)
 
-def AddVectorOfWeakReferences(builder: flatbuffers.Builder, vectorOfWeakReferences: int):
+def AddVectorOfWeakReferences(builder, vectorOfWeakReferences):
     MonsterAddVectorOfWeakReferences(builder, vectorOfWeakReferences)
 
 def MonsterStartVectorOfWeakReferencesVector(builder, numElems):
@@ -1194,7 +1194,7 @@ def StartVectorOfWeakReferencesVector(builder, numElems: int) -> int:
 def MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables):
     builder.PrependUOffsetTRelativeSlot(38, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfStrongReferrables), 0)
 
-def AddVectorOfStrongReferrables(builder: flatbuffers.Builder, vectorOfStrongReferrables: int):
+def AddVectorOfStrongReferrables(builder, vectorOfStrongReferrables):
     MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables)
 
 def MonsterStartVectorOfStrongReferrablesVector(builder, numElems):
@@ -1206,13 +1206,13 @@ def StartVectorOfStrongReferrablesVector(builder, numElems: int) -> int:
 def MonsterAddCoOwningReference(builder, coOwningReference):
     builder.PrependUint64Slot(39, coOwningReference, 0)
 
-def AddCoOwningReference(builder: flatbuffers.Builder, coOwningReference: int):
+def AddCoOwningReference(builder, coOwningReference):
     MonsterAddCoOwningReference(builder, coOwningReference)
 
 def MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences):
     builder.PrependUOffsetTRelativeSlot(40, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfCoOwningReferences), 0)
 
-def AddVectorOfCoOwningReferences(builder: flatbuffers.Builder, vectorOfCoOwningReferences: int):
+def AddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences):
     MonsterAddVectorOfCoOwningReferences(builder, vectorOfCoOwningReferences)
 
 def MonsterStartVectorOfCoOwningReferencesVector(builder, numElems):
@@ -1224,13 +1224,13 @@ def StartVectorOfCoOwningReferencesVector(builder, numElems: int) -> int:
 def MonsterAddNonOwningReference(builder, nonOwningReference):
     builder.PrependUint64Slot(41, nonOwningReference, 0)
 
-def AddNonOwningReference(builder: flatbuffers.Builder, nonOwningReference: int):
+def AddNonOwningReference(builder, nonOwningReference):
     MonsterAddNonOwningReference(builder, nonOwningReference)
 
 def MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences):
     builder.PrependUOffsetTRelativeSlot(42, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfNonOwningReferences), 0)
 
-def AddVectorOfNonOwningReferences(builder: flatbuffers.Builder, vectorOfNonOwningReferences: int):
+def AddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences):
     MonsterAddVectorOfNonOwningReferences(builder, vectorOfNonOwningReferences)
 
 def MonsterStartVectorOfNonOwningReferencesVector(builder, numElems):
@@ -1242,31 +1242,31 @@ def StartVectorOfNonOwningReferencesVector(builder, numElems: int) -> int:
 def MonsterAddAnyUniqueType(builder, anyUniqueType):
     builder.PrependUint8Slot(43, anyUniqueType, 0)
 
-def AddAnyUniqueType(builder: flatbuffers.Builder, anyUniqueType: int):
+def AddAnyUniqueType(builder, anyUniqueType):
     MonsterAddAnyUniqueType(builder, anyUniqueType)
 
 def MonsterAddAnyUnique(builder, anyUnique):
     builder.PrependUOffsetTRelativeSlot(44, flatbuffers.number_types.UOffsetTFlags.py_type(anyUnique), 0)
 
-def AddAnyUnique(builder: flatbuffers.Builder, anyUnique: int):
+def AddAnyUnique(builder, anyUnique):
     MonsterAddAnyUnique(builder, anyUnique)
 
 def MonsterAddAnyAmbiguousType(builder, anyAmbiguousType):
     builder.PrependUint8Slot(45, anyAmbiguousType, 0)
 
-def AddAnyAmbiguousType(builder: flatbuffers.Builder, anyAmbiguousType: int):
+def AddAnyAmbiguousType(builder, anyAmbiguousType):
     MonsterAddAnyAmbiguousType(builder, anyAmbiguousType)
 
 def MonsterAddAnyAmbiguous(builder, anyAmbiguous):
     builder.PrependUOffsetTRelativeSlot(46, flatbuffers.number_types.UOffsetTFlags.py_type(anyAmbiguous), 0)
 
-def AddAnyAmbiguous(builder: flatbuffers.Builder, anyAmbiguous: int):
+def AddAnyAmbiguous(builder, anyAmbiguous):
     MonsterAddAnyAmbiguous(builder, anyAmbiguous)
 
 def MonsterAddVectorOfEnums(builder, vectorOfEnums):
     builder.PrependUOffsetTRelativeSlot(47, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfEnums), 0)
 
-def AddVectorOfEnums(builder: flatbuffers.Builder, vectorOfEnums: int):
+def AddVectorOfEnums(builder, vectorOfEnums):
     MonsterAddVectorOfEnums(builder, vectorOfEnums)
 
 def MonsterStartVectorOfEnumsVector(builder, numElems):
@@ -1278,13 +1278,13 @@ def StartVectorOfEnumsVector(builder, numElems: int) -> int:
 def MonsterAddSignedEnum(builder, signedEnum):
     builder.PrependInt8Slot(48, signedEnum, -1)
 
-def AddSignedEnum(builder: flatbuffers.Builder, signedEnum: int):
+def AddSignedEnum(builder, signedEnum):
     MonsterAddSignedEnum(builder, signedEnum)
 
 def MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer):
     builder.PrependUOffsetTRelativeSlot(49, flatbuffers.number_types.UOffsetTFlags.py_type(testrequirednestedflatbuffer), 0)
 
-def AddTestrequirednestedflatbuffer(builder: flatbuffers.Builder, testrequirednestedflatbuffer: int):
+def AddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer):
     MonsterAddTestrequirednestedflatbuffer(builder, testrequirednestedflatbuffer)
 
 def MonsterStartTestrequirednestedflatbufferVector(builder, numElems):
@@ -1303,7 +1303,7 @@ def MakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes):
 def MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables):
     builder.PrependUOffsetTRelativeSlot(50, flatbuffers.number_types.UOffsetTFlags.py_type(scalarKeySortedTables), 0)
 
-def AddScalarKeySortedTables(builder: flatbuffers.Builder, scalarKeySortedTables: int):
+def AddScalarKeySortedTables(builder, scalarKeySortedTables):
     MonsterAddScalarKeySortedTables(builder, scalarKeySortedTables)
 
 def MonsterStartScalarKeySortedTablesVector(builder, numElems):
@@ -1315,67 +1315,67 @@ def StartScalarKeySortedTablesVector(builder, numElems: int) -> int:
 def MonsterAddNativeInline(builder, nativeInline):
     builder.PrependStructSlot(51, flatbuffers.number_types.UOffsetTFlags.py_type(nativeInline), 0)
 
-def AddNativeInline(builder: flatbuffers.Builder, nativeInline: Any):
+def AddNativeInline(builder, nativeInline):
     MonsterAddNativeInline(builder, nativeInline)
 
 def MonsterAddLongEnumNonEnumDefault(builder, longEnumNonEnumDefault):
     builder.PrependUint64Slot(52, longEnumNonEnumDefault, 0)
 
-def AddLongEnumNonEnumDefault(builder: flatbuffers.Builder, longEnumNonEnumDefault: int):
+def AddLongEnumNonEnumDefault(builder, longEnumNonEnumDefault):
     MonsterAddLongEnumNonEnumDefault(builder, longEnumNonEnumDefault)
 
 def MonsterAddLongEnumNormalDefault(builder, longEnumNormalDefault):
     builder.PrependUint64Slot(53, longEnumNormalDefault, 2)
 
-def AddLongEnumNormalDefault(builder: flatbuffers.Builder, longEnumNormalDefault: int):
+def AddLongEnumNormalDefault(builder, longEnumNormalDefault):
     MonsterAddLongEnumNormalDefault(builder, longEnumNormalDefault)
 
 def MonsterAddNanDefault(builder, nanDefault):
     builder.PrependFloat32Slot(54, nanDefault, float('nan'))
 
-def AddNanDefault(builder: flatbuffers.Builder, nanDefault: float):
+def AddNanDefault(builder, nanDefault):
     MonsterAddNanDefault(builder, nanDefault)
 
 def MonsterAddInfDefault(builder, infDefault):
     builder.PrependFloat32Slot(55, infDefault, float('inf'))
 
-def AddInfDefault(builder: flatbuffers.Builder, infDefault: float):
+def AddInfDefault(builder, infDefault):
     MonsterAddInfDefault(builder, infDefault)
 
 def MonsterAddPositiveInfDefault(builder, positiveInfDefault):
     builder.PrependFloat32Slot(56, positiveInfDefault, float('inf'))
 
-def AddPositiveInfDefault(builder: flatbuffers.Builder, positiveInfDefault: float):
+def AddPositiveInfDefault(builder, positiveInfDefault):
     MonsterAddPositiveInfDefault(builder, positiveInfDefault)
 
 def MonsterAddInfinityDefault(builder, infinityDefault):
     builder.PrependFloat32Slot(57, infinityDefault, float('inf'))
 
-def AddInfinityDefault(builder: flatbuffers.Builder, infinityDefault: float):
+def AddInfinityDefault(builder, infinityDefault):
     MonsterAddInfinityDefault(builder, infinityDefault)
 
 def MonsterAddPositiveInfinityDefault(builder, positiveInfinityDefault):
     builder.PrependFloat32Slot(58, positiveInfinityDefault, float('inf'))
 
-def AddPositiveInfinityDefault(builder: flatbuffers.Builder, positiveInfinityDefault: float):
+def AddPositiveInfinityDefault(builder, positiveInfinityDefault):
     MonsterAddPositiveInfinityDefault(builder, positiveInfinityDefault)
 
 def MonsterAddNegativeInfDefault(builder, negativeInfDefault):
     builder.PrependFloat32Slot(59, negativeInfDefault, float('-inf'))
 
-def AddNegativeInfDefault(builder: flatbuffers.Builder, negativeInfDefault: float):
+def AddNegativeInfDefault(builder, negativeInfDefault):
     MonsterAddNegativeInfDefault(builder, negativeInfDefault)
 
 def MonsterAddNegativeInfinityDefault(builder, negativeInfinityDefault):
     builder.PrependFloat32Slot(60, negativeInfinityDefault, float('-inf'))
 
-def AddNegativeInfinityDefault(builder: flatbuffers.Builder, negativeInfinityDefault: float):
+def AddNegativeInfinityDefault(builder, negativeInfinityDefault):
     MonsterAddNegativeInfinityDefault(builder, negativeInfinityDefault)
 
 def MonsterAddDoubleInfDefault(builder, doubleInfDefault):
     builder.PrependFloat64Slot(61, doubleInfDefault, float('inf'))
 
-def AddDoubleInfDefault(builder: flatbuffers.Builder, doubleInfDefault: float):
+def AddDoubleInfDefault(builder, doubleInfDefault):
     MonsterAddDoubleInfDefault(builder, doubleInfDefault)
 
 def MonsterEnd(builder):

tests/MyGame/Example/NestedUnion/Vec3.py

@@ -5,7 +5,7 @@
 import flatbuffers
 from flatbuffers.compat import import_numpy
 from typing import Any
-from .MyGame.Example.NestedUnion.Test import Test
+from MyGame.Example.NestedUnion.Test import Test
 from typing import Optional
 np = import_numpy()
 

tests/MyGame/Example/Race.lua

@@ -3,7 +3,7 @@
   Automatically generated by the FlatBuffers compiler, do not modify.
   Or modify. I'm a message, not a cop.
 
-  flatc version: 23.3.3
+  flatc version: 23.5.26
 
   Declared by  : //monster_test.fbs
   Rooting type : MyGame.Example.Monster (//monster_test.fbs)

tests/MyGame/Example/Race.nim

@@ -2,7 +2,7 @@
   Automatically generated by the FlatBuffers compiler, do not modify.
   Or modify. I'm a message, not a cop.
 
-  flatc version: 23.3.3
+  flatc version: 23.5.26
 
   Declared by  : 
   Rooting type : MyGame.Example.Monster ()

tests/MyGame/Example/Referrable.cs

@@ -13,7 +13,7 @@ public struct Referrable : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
-  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_3_3(); }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_26(); }
   public static Referrable GetRootAsReferrable(ByteBuffer _bb) { return GetRootAsReferrable(_bb, new Referrable()); }
   public static Referrable GetRootAsReferrable(ByteBuffer _bb, Referrable obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
   public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }

tests/MyGame/Example/Referrable.java

@@ -21,7 +21,7 @@ import java.nio.ByteOrder;
 
 @SuppressWarnings("unused")
 public final class Referrable extends Table {
-  public static void ValidateVersion() { Constants.FLATBUFFERS_23_3_3(); }
+  public static void ValidateVersion() { Constants.FLATBUFFERS_23_5_26(); }
   public static Referrable getRootAsReferrable(ByteBuffer _bb) { return getRootAsReferrable(_bb, new Referrable()); }
   public static Referrable getRootAsReferrable(ByteBuffer _bb, Referrable obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
   public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }

tests/MyGame/Example/Referrable.kt

@@ -48,7 +48,7 @@ class Referrable : Table() {
         return (val_1 - val_2).sign
     }
     companion object {
-        fun validateVersion() = Constants.FLATBUFFERS_23_3_3()
+        fun validateVersion() = Constants.FLATBUFFERS_23_5_26()
         fun getRootAsReferrable(_bb: ByteBuffer): Referrable = getRootAsReferrable(_bb, Referrable())
         fun getRootAsReferrable(_bb: ByteBuffer, obj: Referrable): Referrable {
             _bb.order(ByteOrder.LITTLE_ENDIAN)

tests/MyGame/Example/Referrable.lua

@@ -3,7 +3,7 @@
   Automatically generated by the FlatBuffers compiler, do not modify.
   Or modify. I'm a message, not a cop.
 
-  flatc version: 23.3.3
+  flatc version: 23.5.26
 
   Declared by  : //monster_test.fbs
   Rooting type : MyGame.Example.Monster (//monster_test.fbs)

tests/MyGame/Example/Referrable.nim

@@ -2,7 +2,7 @@
   Automatically generated by the FlatBuffers compiler, do not modify.
   Or modify. I'm a message, not a cop.
 
-  flatc version: 23.3.3
+  flatc version: 23.5.26
 
   Declared by  : 
   Rooting type : MyGame.Example.Monster ()

tests/MyGame/Example/Referrable.py

@@ -44,7 +44,7 @@ def Start(builder):
 def ReferrableAddId(builder, id):
     builder.PrependUint64Slot(0, id, 0)
 
-def AddId(builder: flatbuffers.Builder, id: int):
+def AddId(builder, id):
     ReferrableAddId(builder, id)
 
 def ReferrableEnd(builder):

tests/MyGame/Example/Stat.cs

@@ -13,7 +13,7 @@ public struct Stat : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
-  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_3_3(); }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_26(); }
   public static Stat GetRootAsStat(ByteBuffer _bb) { return GetRootAsStat(_bb, new Stat()); }
   public static Stat GetRootAsStat(ByteBuffer _bb, Stat obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
   public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }

tests/MyGame/Example/Stat.java

@@ -21,7 +21,7 @@ import java.nio.ByteOrder;
 
 @SuppressWarnings("unused")
 public final class Stat extends Table {
-  public static void ValidateVersion() { Constants.FLATBUFFERS_23_3_3(); }
+  public static void ValidateVersion() { Constants.FLATBUFFERS_23_5_26(); }
   public static Stat getRootAsStat(ByteBuffer _bb) { return getRootAsStat(_bb, new Stat()); }
   public static Stat getRootAsStat(ByteBuffer _bb, Stat obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
   public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }

tests/MyGame/Example/Stat.kt

@@ -73,7 +73,7 @@ class Stat : Table() {
         return (val_1 - val_2).sign
     }
     companion object {
-        fun validateVersion() = Constants.FLATBUFFERS_23_3_3()
+        fun validateVersion() = Constants.FLATBUFFERS_23_5_26()
         fun getRootAsStat(_bb: ByteBuffer): Stat = getRootAsStat(_bb, Stat())
         fun getRootAsStat(_bb: ByteBuffer, obj: Stat): Stat {
             _bb.order(ByteOrder.LITTLE_ENDIAN)

tests/MyGame/Example/Stat.lua

@@ -3,7 +3,7 @@
   Automatically generated by the FlatBuffers compiler, do not modify.
   Or modify. I'm a message, not a cop.
 
-  flatc version: 23.3.3
+  flatc version: 23.5.26
 
   Declared by  : //monster_test.fbs
   Rooting type : MyGame.Example.Monster (//monster_test.fbs)

tests/MyGame/Example/Stat.nim

@@ -2,7 +2,7 @@
   Automatically generated by the FlatBuffers compiler, do not modify.
   Or modify. I'm a message, not a cop.
 
-  flatc version: 23.3.3
+  flatc version: 23.5.26
 
   Declared by  : 
   Rooting type : MyGame.Example.Monster ()

tests/MyGame/Example/Stat.py

@@ -58,19 +58,19 @@ def Start(builder):
 def StatAddId(builder, id):
     builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(id), 0)
 
-def AddId(builder: flatbuffers.Builder, id: int):
+def AddId(builder, id):
     StatAddId(builder, id)
 
 def StatAddVal(builder, val):
     builder.PrependInt64Slot(1, val, 0)
 
-def AddVal(builder: flatbuffers.Builder, val: int):
+def AddVal(builder, val):
     StatAddVal(builder, val)
 
 def StatAddCount(builder, count):
     builder.PrependUint16Slot(2, count, 0)
 
-def AddCount(builder: flatbuffers.Builder, count: int):
+def AddCount(builder, count):
     StatAddCount(builder, count)
 
 def StatEnd(builder):

tests/MyGame/Example/StructOfStructs.lua

@@ -3,7 +3,7 @@
   Automatically generated by the FlatBuffers compiler, do not modify.
   Or modify. I'm a message, not a cop.
 
-  flatc version: 23.3.3
+  flatc version: 23.5.26
 
   Declared by  : //monster_test.fbs
   Rooting type : MyGame.Example.Monster (//monster_test.fbs)

tests/MyGame/Example/StructOfStructs.nim

@@ -2,7 +2,7 @@
   Automatically generated by the FlatBuffers compiler, do not modify.
   Or modify. I'm a message, not a cop.
 
-  flatc version: 23.3.3
+  flatc version: 23.5.26
 
   Declared by  : 
   Rooting type : MyGame.Example.Monster ()

tests/MyGame/Example/StructOfStructsOfStructs.lua

@@ -3,7 +3,7 @@
   Automatically generated by the FlatBuffers compiler, do not modify.
   Or modify. I'm a message, not a cop.
 
-  flatc version: 23.3.3
+  flatc version: 23.5.26
 
   Declared by  : //monster_test.fbs
   Rooting type : MyGame.Example.Monster (//monster_test.fbs)

tests/MyGame/Example/StructOfStructsOfStructs.nim

@@ -2,7 +2,7 @@
   Automatically generated by the FlatBuffers compiler, do not modify.
   Or modify. I'm a message, not a cop.
 
-  flatc version: 23.3.3
+  flatc version: 23.5.26
 
   Declared by  : 
   Rooting type : MyGame.Example.Monster ()

tests/MyGame/Example/Test.lua

@@ -3,7 +3,7 @@
   Automatically generated by the FlatBuffers compiler, do not modify.
   Or modify. I'm a message, not a cop.
 
-  flatc version: 23.3.3
+  flatc version: 23.5.26
 
   Declared by  : //monster_test.fbs
   Rooting type : MyGame.Example.Monster (//monster_test.fbs)

tests/MyGame/Example/Test.nim

@@ -2,7 +2,7 @@
   Automatically generated by the FlatBuffers compiler, do not modify.
   Or modify. I'm a message, not a cop.
 
-  flatc version: 23.3.3
+  flatc version: 23.5.26
 
   Declared by  : 
   Rooting type : MyGame.Example.Monster ()

tests/MyGame/Example/TestSimpleTableWithEnum.cs

@@ -13,7 +13,7 @@ internal partial struct TestSimpleTableWithEnum : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
-  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_3_3(); }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_26(); }
   public static TestSimpleTableWithEnum GetRootAsTestSimpleTableWithEnum(ByteBuffer _bb) { return GetRootAsTestSimpleTableWithEnum(_bb, new TestSimpleTableWithEnum()); }
   public static TestSimpleTableWithEnum GetRootAsTestSimpleTableWithEnum(ByteBuffer _bb, TestSimpleTableWithEnum obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
   public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }

tests/MyGame/Example/TestSimpleTableWithEnum.java

@@ -21,7 +21,7 @@ import java.nio.ByteOrder;
 
 @SuppressWarnings("unused")
 final class TestSimpleTableWithEnum extends Table {
-  public static void ValidateVersion() { Constants.FLATBUFFERS_23_3_3(); }
+  public static void ValidateVersion() { Constants.FLATBUFFERS_23_5_26(); }
   public static TestSimpleTableWithEnum getRootAsTestSimpleTableWithEnum(ByteBuffer _bb) { return getRootAsTestSimpleTableWithEnum(_bb, new TestSimpleTableWithEnum()); }
   public static TestSimpleTableWithEnum getRootAsTestSimpleTableWithEnum(ByteBuffer _bb, TestSimpleTableWithEnum obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
   public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }

tests/MyGame/Example/TestSimpleTableWithEnum.kt

@@ -43,7 +43,7 @@ class TestSimpleTableWithEnum : Table() {
         }
     }
     companion object {
-        fun validateVersion() = Constants.FLATBUFFERS_23_3_3()
+        fun validateVersion() = Constants.FLATBUFFERS_23_5_26()
         fun getRootAsTestSimpleTableWithEnum(_bb: ByteBuffer): TestSimpleTableWithEnum = getRootAsTestSimpleTableWithEnum(_bb, TestSimpleTableWithEnum())
         fun getRootAsTestSimpleTableWithEnum(_bb: ByteBuffer, obj: TestSimpleTableWithEnum): TestSimpleTableWithEnum {
             _bb.order(ByteOrder.LITTLE_ENDIAN)

tests/MyGame/Example/TestSimpleTableWithEnum.lua

@@ -3,7 +3,7 @@
   Automatically generated by the FlatBuffers compiler, do not modify.
   Or modify. I'm a message, not a cop.
 
-  flatc version: 23.3.3
+  flatc version: 23.5.26
 
   Declared by  : //monster_test.fbs
   Rooting type : MyGame.Example.Monster (//monster_test.fbs)

tests/MyGame/Example/TestSimpleTableWithEnum.nim

@@ -2,7 +2,7 @@
   Automatically generated by the FlatBuffers compiler, do not modify.
   Or modify. I'm a message, not a cop.
 
-  flatc version: 23.3.3
+  flatc version: 23.5.26
 
   Declared by  : 
   Rooting type : MyGame.Example.Monster ()

tests/MyGame/Example/TestSimpleTableWithEnum.py

@@ -44,7 +44,7 @@ def Start(builder):
 def TestSimpleTableWithEnumAddColor(builder, color):
     builder.PrependUint8Slot(0, color, 2)
 
-def AddColor(builder: flatbuffers.Builder, color: int):
+def AddColor(builder, color):
     TestSimpleTableWithEnumAddColor(builder, color)
 
 def TestSimpleTableWithEnumEnd(builder):

tests/MyGame/Example/TypeAliases.cs

@@ -13,7 +13,7 @@ public struct TypeAliases : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
-  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_3_3(); }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_26(); }
   public static TypeAliases GetRootAsTypeAliases(ByteBuffer _bb) { return GetRootAsTypeAliases(_bb, new TypeAliases()); }
   public static TypeAliases GetRootAsTypeAliases(ByteBuffer _bb, TypeAliases obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
   public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }

tests/MyGame/Example/TypeAliases.java

@@ -21,7 +21,7 @@ import java.nio.ByteOrder;
 
 @SuppressWarnings("unused")
 public final class TypeAliases extends Table {
-  public static void ValidateVersion() { Constants.FLATBUFFERS_23_3_3(); }
+  public static void ValidateVersion() { Constants.FLATBUFFERS_23_5_26(); }
   public static TypeAliases getRootAsTypeAliases(ByteBuffer _bb) { return getRootAsTypeAliases(_bb, new TypeAliases()); }
   public static TypeAliases getRootAsTypeAliases(ByteBuffer _bb, TypeAliases obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
   public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }

tests/MyGame/Example/TypeAliases.kt

@@ -215,7 +215,7 @@ class TypeAliases : Table() {
         }
     }
     companion object {
-        fun validateVersion() = Constants.FLATBUFFERS_23_3_3()
+        fun validateVersion() = Constants.FLATBUFFERS_23_5_26()
         fun getRootAsTypeAliases(_bb: ByteBuffer): TypeAliases = getRootAsTypeAliases(_bb, TypeAliases())
         fun getRootAsTypeAliases(_bb: ByteBuffer, obj: TypeAliases): TypeAliases {
             _bb.order(ByteOrder.LITTLE_ENDIAN)

tests/MyGame/Example/TypeAliases.lua

@@ -3,7 +3,7 @@
   Automatically generated by the FlatBuffers compiler, do not modify.
   Or modify. I'm a message, not a cop.
 
-  flatc version: 23.3.3
+  flatc version: 23.5.26
 
   Declared by  : //monster_test.fbs
   Rooting type : MyGame.Example.Monster (//monster_test.fbs)

tests/MyGame/Example/TypeAliases.nim

@@ -2,7 +2,7 @@
   Automatically generated by the FlatBuffers compiler, do not modify.
   Or modify. I'm a message, not a cop.
 
-  flatc version: 23.3.3
+  flatc version: 23.5.26
 
   Declared by  : 
   Rooting type : MyGame.Example.Monster ()

tests/MyGame/Example/TypeAliases.py

@@ -161,67 +161,67 @@ def Start(builder):
 def TypeAliasesAddI8(builder, i8):
     builder.PrependInt8Slot(0, i8, 0)
 
-def AddI8(builder: flatbuffers.Builder, i8: int):
+def AddI8(builder, i8):
     TypeAliasesAddI8(builder, i8)
 
 def TypeAliasesAddU8(builder, u8):
     builder.PrependUint8Slot(1, u8, 0)
 
-def AddU8(builder: flatbuffers.Builder, u8: int):
+def AddU8(builder, u8):
     TypeAliasesAddU8(builder, u8)
 
 def TypeAliasesAddI16(builder, i16):
     builder.PrependInt16Slot(2, i16, 0)
 
-def AddI16(builder: flatbuffers.Builder, i16: int):
+def AddI16(builder, i16):
     TypeAliasesAddI16(builder, i16)
 
 def TypeAliasesAddU16(builder, u16):
     builder.PrependUint16Slot(3, u16, 0)
 
-def AddU16(builder: flatbuffers.Builder, u16: int):
+def AddU16(builder, u16):
     TypeAliasesAddU16(builder, u16)
 
 def TypeAliasesAddI32(builder, i32):
     builder.PrependInt32Slot(4, i32, 0)
 
-def AddI32(builder: flatbuffers.Builder, i32: int):
+def AddI32(builder, i32):
     TypeAliasesAddI32(builder, i32)
 
 def TypeAliasesAddU32(builder, u32):
     builder.PrependUint32Slot(5, u32, 0)
 
-def AddU32(builder: flatbuffers.Builder, u32: int):
+def AddU32(builder, u32):
     TypeAliasesAddU32(builder, u32)
 
 def TypeAliasesAddI64(builder, i64):
     builder.PrependInt64Slot(6, i64, 0)
 
-def AddI64(builder: flatbuffers.Builder, i64: int):
+def AddI64(builder, i64):
     TypeAliasesAddI64(builder, i64)
 
 def TypeAliasesAddU64(builder, u64):
     builder.PrependUint64Slot(7, u64, 0)
 
-def AddU64(builder: flatbuffers.Builder, u64: int):
+def AddU64(builder, u64):
     TypeAliasesAddU64(builder, u64)
 
 def TypeAliasesAddF32(builder, f32):
     builder.PrependFloat32Slot(8, f32, 0.0)
 
-def AddF32(builder: flatbuffers.Builder, f32: float):
+def AddF32(builder, f32):
     TypeAliasesAddF32(builder, f32)
 
 def TypeAliasesAddF64(builder, f64):
     builder.PrependFloat64Slot(9, f64, 0.0)
 
-def AddF64(builder: flatbuffers.Builder, f64: float):
+def AddF64(builder, f64):
     TypeAliasesAddF64(builder, f64)
 
 def TypeAliasesAddV8(builder, v8):
     builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(v8), 0)
 
-def AddV8(builder: flatbuffers.Builder, v8: int):
+def AddV8(builder, v8):
     TypeAliasesAddV8(builder, v8)
 
 def TypeAliasesStartV8Vector(builder, numElems):
@@ -233,7 +233,7 @@ def StartV8Vector(builder, numElems: int) -> int:
 def TypeAliasesAddVf64(builder, vf64):
     builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(vf64), 0)
 
-def AddVf64(builder: flatbuffers.Builder, vf64: int):
+def AddVf64(builder, vf64):
     TypeAliasesAddVf64(builder, vf64)
 
 def TypeAliasesStartVf64Vector(builder, numElems):

tests/MyGame/Example/Vec3.lua

@@ -3,7 +3,7 @@
   Automatically generated by the FlatBuffers compiler, do not modify.
   Or modify. I'm a message, not a cop.
 
-  flatc version: 23.3.3
+  flatc version: 23.5.26
 
   Declared by  : //monster_test.fbs
   Rooting type : MyGame.Example.Monster (//monster_test.fbs)

tests/MyGame/Example/Vec3.nim

@@ -2,7 +2,7 @@
   Automatically generated by the FlatBuffers compiler, do not modify.
   Or modify. I'm a message, not a cop.
 
-  flatc version: 23.3.3
+  flatc version: 23.5.26
 
   Declared by  : 
   Rooting type : MyGame.Example.Monster ()

tests/MyGame/Example2/Monster.cs

@@ -13,7 +13,7 @@ public struct Monster : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
-  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_3_3(); }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_26(); }
   public static Monster GetRootAsMonster(ByteBuffer _bb) { return GetRootAsMonster(_bb, new Monster()); }
   public static Monster GetRootAsMonster(ByteBuffer _bb, Monster obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
   public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }

tests/MyGame/Example2/Monster.java

@@ -21,7 +21,7 @@ import java.nio.ByteOrder;
 
 @SuppressWarnings("unused")
 public final class Monster extends Table {
-  public static void ValidateVersion() { Constants.FLATBUFFERS_23_3_3(); }
+  public static void ValidateVersion() { Constants.FLATBUFFERS_23_5_26(); }
   public static Monster getRootAsMonster(ByteBuffer _bb) { return getRootAsMonster(_bb, new Monster()); }
   public static Monster getRootAsMonster(ByteBuffer _bb, Monster obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
   public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }

tests/MyGame/Example2/Monster.kt

@@ -29,7 +29,7 @@ class Monster : Table() {
         return this
     }
     companion object {
-        fun validateVersion() = Constants.FLATBUFFERS_23_3_3()
+        fun validateVersion() = Constants.FLATBUFFERS_23_5_26()
         fun getRootAsMonster(_bb: ByteBuffer): Monster = getRootAsMonster(_bb, Monster())
         fun getRootAsMonster(_bb: ByteBuffer, obj: Monster): Monster {
             _bb.order(ByteOrder.LITTLE_ENDIAN)

tests/MyGame/Example2/Monster.lua

@@ -3,7 +3,7 @@
   Automatically generated by the FlatBuffers compiler, do not modify.
   Or modify. I'm a message, not a cop.
 
-  flatc version: 23.3.3
+  flatc version: 23.5.26
 
   Declared by  : //monster_test.fbs
   Rooting type : MyGame.Example.Monster (//monster_test.fbs)

tests/MyGame/Example2/Monster.nim

@@ -2,7 +2,7 @@
   Automatically generated by the FlatBuffers compiler, do not modify.
   Or modify. I'm a message, not a cop.
 
-  flatc version: 23.3.3
+  flatc version: 23.5.26
 
   Declared by  : 
   Rooting type : MyGame.Example.Monster ()

tests/MyGame/InParentNamespace.cs

@@ -13,7 +13,7 @@ public struct InParentNamespace : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
-  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_3_3(); }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_26(); }
   public static InParentNamespace GetRootAsInParentNamespace(ByteBuffer _bb) { return GetRootAsInParentNamespace(_bb, new InParentNamespace()); }
   public static InParentNamespace GetRootAsInParentNamespace(ByteBuffer _bb, InParentNamespace obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
   public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }

tests/MyGame/InParentNamespace.java

@@ -21,7 +21,7 @@ import java.nio.ByteOrder;
 
 @SuppressWarnings("unused")
 public final class InParentNamespace extends Table {
-  public static void ValidateVersion() { Constants.FLATBUFFERS_23_3_3(); }
+  public static void ValidateVersion() { Constants.FLATBUFFERS_23_5_26(); }
   public static InParentNamespace getRootAsInParentNamespace(ByteBuffer _bb) { return getRootAsInParentNamespace(_bb, new InParentNamespace()); }
   public static InParentNamespace getRootAsInParentNamespace(ByteBuffer _bb, InParentNamespace obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
   public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }

tests/MyGame/InParentNamespace.kt

@@ -29,7 +29,7 @@ class InParentNamespace : Table() {
         return this
     }
     companion object {
-        fun validateVersion() = Constants.FLATBUFFERS_23_3_3()
+        fun validateVersion() = Constants.FLATBUFFERS_23_5_26()
         fun getRootAsInParentNamespace(_bb: ByteBuffer): InParentNamespace = getRootAsInParentNamespace(_bb, InParentNamespace())
         fun getRootAsInParentNamespace(_bb: ByteBuffer, obj: InParentNamespace): InParentNamespace {
             _bb.order(ByteOrder.LITTLE_ENDIAN)

tests/MyGame/InParentNamespace.lua

@@ -3,7 +3,7 @@
   Automatically generated by the FlatBuffers compiler, do not modify.
   Or modify. I'm a message, not a cop.
 
-  flatc version: 23.3.3
+  flatc version: 23.5.26
 
   Declared by  : //monster_test.fbs
   Rooting type : MyGame.Example.Monster (//monster_test.fbs)

tests/MyGame/InParentNamespace.nim

@@ -2,7 +2,7 @@
   Automatically generated by the FlatBuffers compiler, do not modify.
   Or modify. I'm a message, not a cop.
 
-  flatc version: 23.3.3
+  flatc version: 23.5.26
 
   Declared by  : 
   Rooting type : MyGame.Example.Monster ()

tests/MyGame/MonsterExtra.cs

@@ -13,7 +13,7 @@ public struct MonsterExtra : IFlatbufferObject
 {
   private Table __p;
   public ByteBuffer ByteBuffer { get { return __p.bb; } }
-  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_3_3(); }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_23_5_26(); }
   public static MonsterExtra GetRootAsMonsterExtra(ByteBuffer _bb) { return GetRootAsMonsterExtra(_bb, new MonsterExtra()); }
   public static MonsterExtra GetRootAsMonsterExtra(ByteBuffer _bb, MonsterExtra obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
   public static bool MonsterExtraBufferHasIdentifier(ByteBuffer _bb) { return Table.__has_identifier(_bb, "MONE"); }

tests/MyGame/MonsterExtra.java

@@ -21,7 +21,7 @@ import java.nio.ByteOrder;
 
 @SuppressWarnings("unused")
 public final class MonsterExtra extends Table {
-  public static void ValidateVersion() { Constants.FLATBUFFERS_23_3_3(); }
+  public static void ValidateVersion() { Constants.FLATBUFFERS_23_5_26(); }
   public static MonsterExtra getRootAsMonsterExtra(ByteBuffer _bb) { return getRootAsMonsterExtra(_bb, new MonsterExtra()); }
   public static MonsterExtra getRootAsMonsterExtra(ByteBuffer _bb, MonsterExtra obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
   public static boolean MonsterExtraBufferHasIdentifier(ByteBuffer _bb) { return __has_identifier(_bb, "MONE"); }

tests/MyGame/MonsterExtra.kt

@@ -187,7 +187,7 @@ class MonsterExtra : Table() {
         }
     }
     companion object {
-        fun validateVersion() = Constants.FLATBUFFERS_23_3_3()
+        fun validateVersion() = Constants.FLATBUFFERS_23_5_26()
         fun getRootAsMonsterExtra(_bb: ByteBuffer): MonsterExtra = getRootAsMonsterExtra(_bb, MonsterExtra())
         fun getRootAsMonsterExtra(_bb: ByteBuffer, obj: MonsterExtra): MonsterExtra {
             _bb.order(ByteOrder.LITTLE_ENDIAN)

tests/MyGame/OtherNameSpace/FromInclude.lua

@@ -3,7 +3,7 @@
   Automatically generated by the FlatBuffers compiler, do not modify.
   Or modify. I'm a message, not a cop.
 
-  flatc version: 23.3.3
+  flatc version: 23.5.26
 
   Declared by  : //include_test/sub/include_test2.fbs
   Rooting type : MyGame.Example.Monster (//monster_test.fbs)

tests/MyGame/OtherNameSpace/FromInclude.nim

@@ -2,7 +2,7 @@
   Automatically generated by the FlatBuffers compiler, do not modify.
   Or modify. I'm a message, not a cop.
 
-  flatc version: 23.3.3
+  flatc version: 23.5.26
 
   Declared by  : 
   Rooting type : MyGame.Example.Monster ()

tests/MyGame/OtherNameSpace/TableB.lua

@@ -3,7 +3,7 @@
   Automatically generated by the FlatBuffers compiler, do not modify.
   Or modify. I'm a message, not a cop.
 
-  flatc version: 23.3.3
+  flatc version: 23.5.26
 
   Declared by  : //include_test/sub/include_test2.fbs
   Rooting type : MyGame.Example.Monster (//monster_test.fbs)

tests/MyGame/OtherNameSpace/TableB.nim

@@ -2,7 +2,7 @@
   Automatically generated by the FlatBuffers compiler, do not modify.
   Or modify. I'm a message, not a cop.
 
-  flatc version: 23.3.3
+  flatc version: 23.5.26
 
   Declared by  : 
   Rooting type : MyGame.Example.Monster ()

tests/MyGame/OtherNameSpace/Unused.lua

@@ -3,7 +3,7 @@
   Automatically generated by the FlatBuffers compiler, do not modify.
   Or modify. I'm a message, not a cop.
 
-  flatc version: 23.3.3
+  flatc version: 23.5.26
 
   Declared by  : //include_test/sub/include_test2.fbs
   Rooting type : MyGame.Example.Monster (//monster_test.fbs)