From 5121883cc6bd83cbf6a3500b3c77b47242029be1 Mon Sep 17 00:00:00 2001
From: Fergus Henderson <fergus@google.com>
Date: Thu, 16 Oct 2025 16:50:52 +0100
Subject: [PATCH 1/4] Fixes to make SizeVerifier work.

In particular change all the places in the Flatbuffers library
and generated code that were using `Verifier` to instead use
`VerifierTemplate<TrackBufferSize>` and wrap them all inside
`template <bool TrackBufferSize = false>`.

Also add unit tests for SizeVerifier.
---
 goldens/cpp/basic_generated.h                 | 16 +++--
 include/flatbuffers/flex_flat_util.h          |  3 +-
 include/flatbuffers/reflection_generated.h    | 40 +++++++----
 include/flatbuffers/table.h                   | 43 ++++++-----
 samples/monster_generated.h                   | 28 +++++---
 src/idl_gen_cpp.cpp                           | 47 +++++++++---
 src/idl_parser.cpp                            |  5 +-
 tests/64bit/evolution/v1_generated.h          | 13 ++--
 tests/64bit/evolution/v2_generated.h          | 13 ++--
 tests/64bit/test_64bit_generated.h            | 18 +++--
 .../generated_cpp17/monster_test_generated.h  | 71 ++++++++++++-------
 .../optional_scalars_generated.h              | 13 ++--
 .../generated_cpp17/union_vector_generated.h  | 51 ++++++++-----
 tests/evolution_test/evolution_v1_generated.h | 31 +++++---
 tests/evolution_test/evolution_v2_generated.h | 34 +++++----
 tests/fuzzer/flatbuffers_verifier_fuzzer.cc   |  2 +
 tests/key_field/key_field_sample_generated.h  | 13 ++--
 tests/monster_extra_generated.h               | 13 ++--
 tests/monster_test_generated.h                | 71 ++++++++++++-------
 .../ext_only/monster_test_generated.hpp       | 71 ++++++++++++-------
 .../filesuffix_only/monster_test_suffix.h     | 71 ++++++++++++-------
 .../monster_test_suffix.hpp                   | 71 ++++++++++++-------
 .../namespace_test1_generated.h               | 15 ++--
 .../namespace_test2_generated.h               |  9 ++-
 tests/native_inline_table_test_generated.h    |  6 +-
 tests/native_type_test_generated.h            | 13 ++--
 tests/optional_scalars_generated.h            | 13 ++--
 tests/test.cpp                                | 30 ++++++++
 tests/union_underlying_type_test_generated.h  | 24 ++++---
 tests/union_vector/union_vector_generated.h   | 51 ++++++++-----
 30 files changed, 593 insertions(+), 306 deletions(-)

diff --git a/goldens/cpp/basic_generated.h b/goldens/cpp/basic_generated.h
index 2c5391fd848..7304b382acf 100644
--- a/goldens/cpp/basic_generated.h
+++ b/goldens/cpp/basic_generated.h
@@ -30,7 +30,8 @@ struct Galaxy FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   int64_t num_stars() const {
     return GetField<int64_t>(VT_NUM_STARS, 0);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int64_t>(verifier, VT_NUM_STARS, 8) &&
            verifier.EndTable();
@@ -75,7 +76,8 @@ struct Universe FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const ::flatbuffers::Vector<::flatbuffers::Offset<flatbuffers::goldens::Galaxy>> *galaxies() const {
     return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<flatbuffers::goldens::Galaxy>> *>(VT_GALAXIES);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<double>(verifier, VT_AGE, 8) &&
            VerifyOffset(verifier, VT_GALAXIES) &&
@@ -135,14 +137,16 @@ inline const flatbuffers::goldens::Universe *GetSizePrefixedUniverse(const void
   return ::flatbuffers::GetSizePrefixedRoot<flatbuffers::goldens::Universe>(buf);
 }
 
+template <bool TrackBufferSize = false>
 inline bool VerifyUniverseBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifyBuffer<flatbuffers::goldens::Universe>(nullptr);
+    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+  return verifier.template VerifyBuffer<flatbuffers::goldens::Universe>(nullptr);
 }
 
+template <bool TrackBufferSize = false>
 inline bool VerifySizePrefixedUniverseBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifySizePrefixedBuffer<flatbuffers::goldens::Universe>(nullptr);
+    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+  return verifier.template VerifySizePrefixedBuffer<flatbuffers::goldens::Universe>(nullptr);
 }
 
 inline void FinishUniverseBuffer(
diff --git a/include/flatbuffers/flex_flat_util.h b/include/flatbuffers/flex_flat_util.h
index c02e90fea1c..4b4b8f8fb91 100644
--- a/include/flatbuffers/flex_flat_util.h
+++ b/include/flatbuffers/flex_flat_util.h
@@ -23,9 +23,10 @@
 namespace flexbuffers {
 
 // Verifies the `nested` flexbuffer within a flatbuffer vector is valid.
+template <bool TrackBufferSize>
 inline bool VerifyNestedFlexBuffer(
     const flatbuffers::Vector<uint8_t>* const nested,
-    flatbuffers::Verifier& verifier) {
+    flatbuffers::VerifierTemplate<TrackBufferSize>& verifier) {
   if (!nested) return true;
   return verifier.Check(flexbuffers::VerifyBuffer(
       nested->data(), nested->size(), verifier.GetFlexReuseTracker()));
diff --git a/include/flatbuffers/reflection_generated.h b/include/flatbuffers/reflection_generated.h
index 5c2ab09b256..0c24320d7c0 100644
--- a/include/flatbuffers/reflection_generated.h
+++ b/include/flatbuffers/reflection_generated.h
@@ -196,7 +196,8 @@ struct Type FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   uint32_t element_size() const {
     return GetField<uint32_t>(VT_ELEMENT_SIZE, 0);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int8_t>(verifier, VT_BASE_TYPE, 1) &&
            VerifyField<int8_t>(verifier, VT_ELEMENT, 1) &&
@@ -283,7 +284,8 @@ struct KeyValue FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const ::flatbuffers::String *value() const {
     return GetPointer<const ::flatbuffers::String *>(VT_VALUE);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffsetRequired(verifier, VT_KEY) &&
            verifier.VerifyString(key()) &&
@@ -367,7 +369,8 @@ struct EnumVal FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes() const {
     return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *>(VT_ATTRIBUTES);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffsetRequired(verifier, VT_NAME) &&
            verifier.VerifyString(name()) &&
@@ -495,7 +498,8 @@ struct Enum FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const ::flatbuffers::String *declaration_file() const {
     return GetPointer<const ::flatbuffers::String *>(VT_DECLARATION_FILE);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffsetRequired(verifier, VT_NAME) &&
            verifier.VerifyString(name()) &&
@@ -675,7 +679,8 @@ struct Field FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   bool offset64() const {
     return GetField<uint8_t>(VT_OFFSET64, 0) != 0;
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffsetRequired(verifier, VT_NAME) &&
            verifier.VerifyString(name()) &&
@@ -880,7 +885,8 @@ struct Object FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const ::flatbuffers::String *declaration_file() const {
     return GetPointer<const ::flatbuffers::String *>(VT_DECLARATION_FILE);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffsetRequired(verifier, VT_NAME) &&
            verifier.VerifyString(name()) &&
@@ -1028,7 +1034,8 @@ struct RPCCall FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation() const {
     return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_DOCUMENTATION);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffsetRequired(verifier, VT_NAME) &&
            verifier.VerifyString(name()) &&
@@ -1151,7 +1158,8 @@ struct Service FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const ::flatbuffers::String *declaration_file() const {
     return GetPointer<const ::flatbuffers::String *>(VT_DECLARATION_FILE);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffsetRequired(verifier, VT_NAME) &&
            verifier.VerifyString(name()) &&
@@ -1267,7 +1275,8 @@ struct SchemaFile FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *included_filenames() const {
     return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_INCLUDED_FILENAMES);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffsetRequired(verifier, VT_FILENAME) &&
            verifier.VerifyString(filename()) &&
@@ -1360,7 +1369,8 @@ struct Schema FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::SchemaFile>> *fbs_files() const {
     return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::SchemaFile>> *>(VT_FBS_FILES);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffsetRequired(verifier, VT_OBJECTS) &&
            verifier.VerifyVector(objects()) &&
@@ -1498,14 +1508,16 @@ inline bool SizePrefixedSchemaBufferHasIdentifier(const void *buf) {
       buf, SchemaIdentifier(), true);
 }
 
+template <bool TrackBufferSize = false>
 inline bool VerifySchemaBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifyBuffer<reflection::Schema>(SchemaIdentifier());
+    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+  return verifier.template VerifyBuffer<reflection::Schema>(SchemaIdentifier());
 }
 
+template <bool TrackBufferSize = false>
 inline bool VerifySizePrefixedSchemaBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifySizePrefixedBuffer<reflection::Schema>(SchemaIdentifier());
+    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+  return verifier.template VerifySizePrefixedBuffer<reflection::Schema>(SchemaIdentifier());
 }
 
 inline const char *SchemaExtension() {
diff --git a/include/flatbuffers/table.h b/include/flatbuffers/table.h
index defe084370b..535d9c1fc48 100644
--- a/include/flatbuffers/table.h
+++ b/include/flatbuffers/table.h
@@ -122,49 +122,58 @@ class Table {
 
   // Verify the vtable of this table.
   // Call this once per table, followed by VerifyField once per field.
-  bool VerifyTableStart(Verifier& verifier) const {
+  template <bool TrackBufferSize>
+  bool VerifyTableStart(VerifierTemplate<TrackBufferSize>& verifier) const {
     return verifier.VerifyTableStart(data_);
   }
 
   // Verify a particular field.
-  template <typename T>
-  bool VerifyField(const Verifier& verifier, voffset_t field,
-                   size_t align) const {
+  template <typename T, bool TrackBufferSize>
+  bool VerifyField(const VerifierTemplate<TrackBufferSize>& verifier,
+                   voffset_t field, size_t align) const {
     // Calling GetOptionalFieldOffset should be safe now thanks to
     // VerifyTable().
     auto field_offset = GetOptionalFieldOffset(field);
     // Check the actual field.
-    return !field_offset || verifier.VerifyField<T>(data_, field_offset, align);
+    return !field_offset ||
+           verifier.template VerifyField<T>(data_, field_offset, align);
   }
 
   // VerifyField for required fields.
-  template <typename T>
-  bool VerifyFieldRequired(const Verifier& verifier, voffset_t field,
-                           size_t align) const {
+  template <typename T, bool TrackBufferSize>
+  bool VerifyFieldRequired(const VerifierTemplate<TrackBufferSize>& verifier,
+                           voffset_t field, size_t align) const {
     auto field_offset = GetOptionalFieldOffset(field);
     return verifier.Check(field_offset != 0) &&
-           verifier.VerifyField<T>(data_, field_offset, align);
+           verifier.template VerifyField<T>(data_, field_offset, align);
   }
 
   // Versions for offsets.
-  template <typename OffsetT = uoffset_t>
-  bool VerifyOffset(const Verifier& verifier, voffset_t field) const {
+  template <typename OffsetT = uoffset_t, bool TrackBufferSize = false>
+  bool VerifyOffset(const VerifierTemplate<TrackBufferSize>& verifier,
+                    voffset_t field) const {
     auto field_offset = GetOptionalFieldOffset(field);
-    return !field_offset || verifier.VerifyOffset<OffsetT>(data_, field_offset);
+    return !field_offset ||
+           verifier.template VerifyOffset<OffsetT>(data_, field_offset);
   }
 
-  template <typename OffsetT = uoffset_t>
-  bool VerifyOffsetRequired(const Verifier& verifier, voffset_t field) const {
+  template <typename OffsetT = uoffset_t, bool TrackBufferSize = false>
+  bool VerifyOffsetRequired(const VerifierTemplate<TrackBufferSize>& verifier,
+                            voffset_t field) const {
     auto field_offset = GetOptionalFieldOffset(field);
     return verifier.Check(field_offset != 0) &&
-           verifier.VerifyOffset<OffsetT>(data_, field_offset);
+           verifier.template VerifyOffset<OffsetT>(data_, field_offset);
   }
 
-  bool VerifyOffset64(const Verifier& verifier, voffset_t field) const {
+  template <bool TrackBufferSize>
+  bool VerifyOffset64(const VerifierTemplate<TrackBufferSize>& verifier,
+                      voffset_t field) const {
     return VerifyOffset<uoffset64_t>(verifier, field);
   }
 
-  bool VerifyOffset64Required(const Verifier& verifier, voffset_t field) const {
+  template <bool TrackBufferSize>
+  bool VerifyOffset64Required(const VerifierTemplate<TrackBufferSize>& verifier,
+                              voffset_t field) const {
     return VerifyOffsetRequired<uoffset64_t>(verifier, field);
   }
 
diff --git a/samples/monster_generated.h b/samples/monster_generated.h
index 4cd4c5b9821..d9c5f6dcca8 100644
--- a/samples/monster_generated.h
+++ b/samples/monster_generated.h
@@ -179,8 +179,10 @@ inline bool operator!=(const EquipmentUnion &lhs, const EquipmentUnion &rhs) {
     return !(lhs == rhs);
 }
 
-bool VerifyEquipment(::flatbuffers::Verifier &verifier, const void *obj, Equipment type);
-bool VerifyEquipmentVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
+template <bool TrackBufferSize = false>
+bool VerifyEquipment(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Equipment type);
+template <bool TrackBufferSize = false>
+bool VerifyEquipmentVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
 
 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Vec3 FLATBUFFERS_FINAL_CLASS {
  private:
@@ -331,7 +333,8 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   ::flatbuffers::Vector<const MyGame::Sample::Vec3 *> *mutable_path() {
     return GetPointer<::flatbuffers::Vector<const MyGame::Sample::Vec3 *> *>(VT_PATH);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<MyGame::Sample::Vec3>(verifier, VT_POS, 4) &&
            VerifyField<int16_t>(verifier, VT_MANA, 2) &&
@@ -491,7 +494,8 @@ struct Weapon FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   bool mutate_damage(int16_t _damage = 0) {
     return SetField<int16_t>(VT_DAMAGE, _damage, 0);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_NAME) &&
            verifier.VerifyString(name()) &&
@@ -686,7 +690,8 @@ inline ::flatbuffers::Offset<Weapon> CreateWeapon(::flatbuffers::FlatBufferBuild
       _damage);
 }
 
-inline bool VerifyEquipment(::flatbuffers::Verifier &verifier, const void *obj, Equipment type) {
+template <bool TrackBufferSize>
+inline bool VerifyEquipment(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Equipment type) {
   switch (type) {
     case Equipment_NONE: {
       return true;
@@ -699,7 +704,8 @@ inline bool VerifyEquipment(::flatbuffers::Verifier &verifier, const void *obj,
   }
 }
 
-inline bool VerifyEquipmentVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
+template <bool TrackBufferSize>
+inline bool VerifyEquipmentVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@@ -883,14 +889,16 @@ inline MyGame::Sample::Monster *GetMutableSizePrefixedMonster(void *buf) {
   return ::flatbuffers::GetMutableSizePrefixedRoot<MyGame::Sample::Monster>(buf);
 }
 
+template <bool TrackBufferSize = false>
 inline bool VerifyMonsterBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifyBuffer<MyGame::Sample::Monster>(nullptr);
+    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+  return verifier.template VerifyBuffer<MyGame::Sample::Monster>(nullptr);
 }
 
+template <bool TrackBufferSize = false>
 inline bool VerifySizePrefixedMonsterBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifySizePrefixedBuffer<MyGame::Sample::Monster>(nullptr);
+    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+  return verifier.template VerifySizePrefixedBuffer<MyGame::Sample::Monster>(nullptr);
 }
 
 inline void FinishMonsterBuffer(
diff --git a/src/idl_gen_cpp.cpp b/src/idl_gen_cpp.cpp
index 38f68b7262d..7f245947565 100644
--- a/src/idl_gen_cpp.cpp
+++ b/src/idl_gen_cpp.cpp
@@ -677,17 +677,22 @@ class CppGenerator : public BaseGenerator {
         code_.SetValue("ID", "nullptr");
       }
 
+      code_ += "template <bool TrackBufferSize = false>";
       code_ += "inline bool Verify{{STRUCT_NAME}}Buffer(";
-      code_ += "    ::flatbuffers::Verifier &verifier) {";
-      code_ += "  return verifier.VerifyBuffer<{{CPP_NAME}}>({{ID}});";
+      code_ +=
+          "    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {";
+      code_ += "  return verifier.template VerifyBuffer<{{CPP_NAME}}>({{ID}});";
       code_ += "}";
       code_ += "";
 
+      code_ += "template <bool TrackBufferSize = false>";
       code_ += "inline bool VerifySizePrefixed{{STRUCT_NAME}}Buffer(";
-      code_ += "    ::flatbuffers::Verifier &verifier) {";
+      code_ +=
+          "    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {";
       code_ +=
           "  return "
-          "verifier.VerifySizePrefixedBuffer<{{CPP_NAME}}{{SIZE_T}}>({{ID}});";
+          "verifier.template "
+          "VerifySizePrefixedBuffer<{{CPP_NAME}}{{SIZE_T}}>({{ID}});";
       code_ += "}";
       code_ += "";
 
@@ -1087,19 +1092,34 @@ class CppGenerator : public BaseGenerator {
     }
   }
 
+  // For the initial declaration, we specify the template parameters,
+  // including template default arguments.
+  std::string UnionVerifyTemplateDecl() {
+    return "template <bool TrackBufferSize = false>";
+  }
+
+  // For the subsequent definition, we must not redeclare the template default arguments.
+  std::string UnionVerifyTemplateDef() {
+    return "template <bool TrackBufferSize>";
+  }
+
+  // Should be used in conjunction with
+  // UnionVerifyTemplateDecl()/UnionVerifyTemplateDef().
   std::string UnionVerifySignature(const EnumDef& enum_def) {
     return "bool Verify" + Name(enum_def) +
-           "(::flatbuffers::Verifier &verifier, const void *obj, " +
-           Name(enum_def) + " type)";
+           "(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, " +
+           "const void *obj, " + Name(enum_def) + " type)";
   }
 
+  // Should be used in conjunction with
+  // UnionVerifyTemplateDecl()/UnionVerifyTemplateDef().
   std::string UnionVectorVerifySignature(const EnumDef& enum_def) {
     const std::string name = Name(enum_def);
     const std::string& type =
         opts_.scoped_enums ? name
                            : GenTypeBasic(enum_def.underlying_type, false);
     return "bool Verify" + name + "Vector" +
-           "(::flatbuffers::Verifier &verifier, " +
+           "(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, " +
            "const ::flatbuffers::Vector<::flatbuffers::Offset<void>> "
            "*values, " +
            "const ::flatbuffers::Vector<" + type + "> *types)";
@@ -1394,7 +1414,9 @@ class CppGenerator : public BaseGenerator {
     GenEnumObjectBasedAPI(enum_def);
 
     if (enum_def.is_union) {
+      code_ += UnionVerifyTemplateDecl();
       code_ += UnionVerifySignature(enum_def) + ";";
+      code_ += UnionVerifyTemplateDecl();
       code_ += UnionVectorVerifySignature(enum_def) + ";";
       code_ += "";
     }
@@ -1623,6 +1645,7 @@ class CppGenerator : public BaseGenerator {
     // on the wrong type.
     code_.SetValue("ENUM_NAME", Name(enum_def));
 
+    code_ += UnionVerifyTemplateDef();
     code_ += "inline " + UnionVerifySignature(enum_def) + " {";
     code_ += "  switch (type) {";
     for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end(); ++it) {
@@ -1639,7 +1662,7 @@ class CppGenerator : public BaseGenerator {
             code_.SetValue("ALIGN",
                            NumToString(ev.union_type.struct_def->minalign));
             code_ +=
-                "      return verifier.VerifyField<{{TYPE}}>("
+                "      return verifier.template VerifyField<{{TYPE}}>("
                 "static_cast<const uint8_t *>(obj), 0, {{ALIGN}});";
           } else {
             code_ += getptr;
@@ -1663,6 +1686,7 @@ class CppGenerator : public BaseGenerator {
     code_ += "}";
     code_ += "";
 
+    code_ += UnionVerifyTemplateDef();
     code_ += "inline " + UnionVectorVerifySignature(enum_def) + " {";
     code_ += "  if (!values || !types) return !values && !types;";
     code_ += "  if (values->size() != types->size()) return false;";
@@ -2391,7 +2415,7 @@ class CppGenerator : public BaseGenerator {
           code_.SetValue("CPP_NAME", nfn);
           // FIXME: file_identifier.
           code_ +=
-              "{{PRE}}verifier.VerifyNestedFlatBuffer<{{CPP_NAME}}>"
+              "{{PRE}}verifier.template VerifyNestedFlatBuffer<{{CPP_NAME}}>"
               "({{NAME}}(), nullptr)\\";
         } else if (field.flexbuffer) {
           code_ +=
@@ -2976,7 +3000,10 @@ class CppGenerator : public BaseGenerator {
 
     // Generate a verifier function that can check a buffer from an untrusted
     // source will never cause reads outside the buffer.
-    code_ += "  bool Verify(::flatbuffers::Verifier &verifier) const {";
+    code_ += "  template <bool TrackBufferSize = false>";
+    code_ +=
+        "  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> "
+        "&verifier) const {";
     code_ += "    return VerifyTableStart(verifier)\\";
     for (const auto& field : struct_def.fields.vec) {
       if (field->deprecated) {
diff --git a/src/idl_parser.cpp b/src/idl_parser.cpp
index 42df4cde71e..24555aec48e 100644
--- a/src/idl_parser.cpp
+++ b/src/idl_parser.cpp
@@ -4351,8 +4351,9 @@ bool Parser::Deserialize(const uint8_t* buf, const size_t size) {
     else
       size_prefixed = true;
   }
-  auto verify_fn = size_prefixed ? &reflection::VerifySizePrefixedSchemaBuffer
-                                 : &reflection::VerifySchemaBuffer;
+  auto verify_fn = size_prefixed
+      ? &reflection::VerifySizePrefixedSchemaBuffer<false>
+      : &reflection::VerifySchemaBuffer<false>;
   if (!verify_fn(verifier)) {
     return false;
   }
diff --git a/tests/64bit/evolution/v1_generated.h b/tests/64bit/evolution/v1_generated.h
index 10e715e18f0..c9d7f857ca9 100644
--- a/tests/64bit/evolution/v1_generated.h
+++ b/tests/64bit/evolution/v1_generated.h
@@ -52,7 +52,8 @@ struct RootTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   ::flatbuffers::Vector<uint8_t> *mutable_b() {
     return GetPointer<::flatbuffers::Vector<uint8_t> *>(VT_B);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<float>(verifier, VT_A, 4) &&
            VerifyOffset(verifier, VT_B) &&
@@ -180,14 +181,16 @@ inline v1::RootTable *GetMutableSizePrefixedRootTable(void *buf) {
   return ::flatbuffers::GetMutableSizePrefixedRoot<v1::RootTable>(buf);
 }
 
+template <bool TrackBufferSize = false>
 inline bool VerifyRootTableBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifyBuffer<v1::RootTable>(nullptr);
+    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+  return verifier.template VerifyBuffer<v1::RootTable>(nullptr);
 }
 
+template <bool TrackBufferSize = false>
 inline bool VerifySizePrefixedRootTableBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifySizePrefixedBuffer<v1::RootTable>(nullptr);
+    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+  return verifier.template VerifySizePrefixedBuffer<v1::RootTable>(nullptr);
 }
 
 inline void FinishRootTableBuffer(
diff --git a/tests/64bit/evolution/v2_generated.h b/tests/64bit/evolution/v2_generated.h
index 0b6b702e853..f5836e7ad68 100644
--- a/tests/64bit/evolution/v2_generated.h
+++ b/tests/64bit/evolution/v2_generated.h
@@ -60,7 +60,8 @@ struct RootTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   ::flatbuffers::Vector64<uint8_t> *mutable_big_vector() {
     return GetPointer64<::flatbuffers::Vector64<uint8_t> *>(VT_BIG_VECTOR);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<float>(verifier, VT_A, 4) &&
            VerifyOffset(verifier, VT_B) &&
@@ -204,14 +205,16 @@ inline v2::RootTable *GetMutableSizePrefixedRootTable(void *buf) {
   return ::flatbuffers::GetMutableSizePrefixedRoot<v2::RootTable,::flatbuffers::uoffset64_t>(buf);
 }
 
+template <bool TrackBufferSize = false>
 inline bool VerifyRootTableBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifyBuffer<v2::RootTable>(nullptr);
+    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+  return verifier.template VerifyBuffer<v2::RootTable>(nullptr);
 }
 
+template <bool TrackBufferSize = false>
 inline bool VerifySizePrefixedRootTableBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifySizePrefixedBuffer<v2::RootTable,::flatbuffers::uoffset64_t>(nullptr);
+    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+  return verifier.template VerifySizePrefixedBuffer<v2::RootTable,::flatbuffers::uoffset64_t>(nullptr);
 }
 
 inline void FinishRootTableBuffer(
diff --git a/tests/64bit/test_64bit_generated.h b/tests/64bit/test_64bit_generated.h
index c3cb2001130..3c947235472 100644
--- a/tests/64bit/test_64bit_generated.h
+++ b/tests/64bit/test_64bit_generated.h
@@ -108,7 +108,8 @@ struct WrapperTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   ::flatbuffers::Vector<int8_t> *mutable_vector() {
     return GetPointer64<::flatbuffers::Vector<int8_t> *>(VT_VECTOR);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset64(verifier, VT_VECTOR) &&
            verifier.VerifyVector(vector()) &&
@@ -258,7 +259,8 @@ struct RootTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   ::flatbuffers::Vector64<uint8_t> *mutable_forced_aligned_vector() {
     return GetPointer64<::flatbuffers::Vector64<uint8_t> *>(VT_FORCED_ALIGNED_VECTOR);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset64(verifier, VT_FAR_VECTOR) &&
            verifier.VerifyVector(far_vector()) &&
@@ -271,7 +273,7 @@ struct RootTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
            verifier.VerifyString(near_string()) &&
            VerifyOffset64(verifier, VT_NESTED_ROOT) &&
            verifier.VerifyVector(nested_root()) &&
-           verifier.VerifyNestedFlatBuffer<RootTable>(nested_root(), nullptr) &&
+           verifier.template VerifyNestedFlatBuffer<RootTable>(nested_root(), nullptr) &&
            VerifyOffset64(verifier, VT_FAR_STRUCT_VECTOR) &&
            verifier.VerifyVector(far_struct_vector()) &&
            VerifyOffset64(verifier, VT_BIG_STRUCT_VECTOR) &&
@@ -616,14 +618,16 @@ inline RootTable *GetMutableSizePrefixedRootTable(void *buf) {
   return ::flatbuffers::GetMutableSizePrefixedRoot<RootTable,::flatbuffers::uoffset64_t>(buf);
 }
 
+template <bool TrackBufferSize = false>
 inline bool VerifyRootTableBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifyBuffer<RootTable>(nullptr);
+    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+  return verifier.template VerifyBuffer<RootTable>(nullptr);
 }
 
+template <bool TrackBufferSize = false>
 inline bool VerifySizePrefixedRootTableBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifySizePrefixedBuffer<RootTable,::flatbuffers::uoffset64_t>(nullptr);
+    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+  return verifier.template VerifySizePrefixedBuffer<RootTable,::flatbuffers::uoffset64_t>(nullptr);
 }
 
 inline void FinishRootTableBuffer(
diff --git a/tests/cpp17/generated_cpp17/monster_test_generated.h b/tests/cpp17/generated_cpp17/monster_test_generated.h
index e14cd4c2a3f..95afbdc2a30 100644
--- a/tests/cpp17/generated_cpp17/monster_test_generated.h
+++ b/tests/cpp17/generated_cpp17/monster_test_generated.h
@@ -323,8 +323,10 @@ struct AnyUnion {
   }
 };
 
-bool VerifyAny(::flatbuffers::Verifier &verifier, const void *obj, Any type);
-bool VerifyAnyVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Any> *types);
+template <bool TrackBufferSize = false>
+bool VerifyAny(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Any type);
+template <bool TrackBufferSize = false>
+bool VerifyAnyVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Any> *types);
 
 enum class AnyUniqueAliases : uint8_t {
   NONE = 0,
@@ -450,8 +452,10 @@ struct AnyUniqueAliasesUnion {
   }
 };
 
-bool VerifyAnyUniqueAliases(::flatbuffers::Verifier &verifier, const void *obj, AnyUniqueAliases type);
-bool VerifyAnyUniqueAliasesVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<AnyUniqueAliases> *types);
+template <bool TrackBufferSize = false>
+bool VerifyAnyUniqueAliases(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, AnyUniqueAliases type);
+template <bool TrackBufferSize = false>
+bool VerifyAnyUniqueAliasesVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<AnyUniqueAliases> *types);
 
 enum class AnyAmbiguousAliases : uint8_t {
   NONE = 0,
@@ -535,8 +539,10 @@ struct AnyAmbiguousAliasesUnion {
   }
 };
 
-bool VerifyAnyAmbiguousAliases(::flatbuffers::Verifier &verifier, const void *obj, AnyAmbiguousAliases type);
-bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<AnyAmbiguousAliases> *types);
+template <bool TrackBufferSize = false>
+bool VerifyAnyAmbiguousAliases(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, AnyAmbiguousAliases type);
+template <bool TrackBufferSize = false>
+bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<AnyAmbiguousAliases> *types);
 
 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(2) Test FLATBUFFERS_FINAL_CLASS {
  private:
@@ -881,7 +887,8 @@ struct InParentNamespace FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
   static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
     return InParentNamespaceTypeTable();
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            verifier.EndTable();
   }
@@ -935,7 +942,8 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
     return MonsterTypeTable();
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            verifier.EndTable();
   }
@@ -1006,7 +1014,8 @@ struct TestSimpleTableWithEnum FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::
          if constexpr (Index == 0) return color();
     else static_assert(Index != -1, "Invalid Field Index");
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint8_t>(verifier, VT_COLOR, 1) &&
            verifier.EndTable();
@@ -1107,7 +1116,8 @@ struct Stat FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
     else if constexpr (Index == 2) return count();
     else static_assert(Index != -1, "Invalid Field Index");
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_ID) &&
            verifier.VerifyString(id()) &&
@@ -1218,7 +1228,8 @@ struct Referrable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
          if constexpr (Index == 0) return id();
     else static_assert(Index != -1, "Invalid Field Index");
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint64_t>(verifier, VT_ID, 8) &&
            verifier.EndTable();
@@ -1886,7 +1897,8 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
     else if constexpr (Index == 60) return double_inf_default();
     else static_assert(Index != -1, "Invalid Field Index");
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<MyGame::Example::Vec3>(verifier, VT_POS, 8) &&
            VerifyField<int16_t>(verifier, VT_MANA, 2) &&
@@ -1911,7 +1923,7 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
            verifier.VerifyTable(enemy()) &&
            VerifyOffset(verifier, VT_TESTNESTEDFLATBUFFER) &&
            verifier.VerifyVector(testnestedflatbuffer()) &&
-           verifier.VerifyNestedFlatBuffer<MyGame::Example::Monster>(testnestedflatbuffer(), nullptr) &&
+           verifier.template VerifyNestedFlatBuffer<MyGame::Example::Monster>(testnestedflatbuffer(), nullptr) &&
            VerifyOffset(verifier, VT_TESTEMPTY) &&
            verifier.VerifyTable(testempty()) &&
            VerifyField<uint8_t>(verifier, VT_TESTBOOL, 1) &&
@@ -1970,7 +1982,7 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
            VerifyField<int8_t>(verifier, VT_SIGNED_ENUM, 1) &&
            VerifyOffset(verifier, VT_TESTREQUIREDNESTEDFLATBUFFER) &&
            verifier.VerifyVector(testrequirednestedflatbuffer()) &&
-           verifier.VerifyNestedFlatBuffer<MyGame::Example::Monster>(testrequirednestedflatbuffer(), nullptr) &&
+           verifier.template VerifyNestedFlatBuffer<MyGame::Example::Monster>(testrequirednestedflatbuffer(), nullptr) &&
            VerifyOffset(verifier, VT_SCALAR_KEY_SORTED_TABLES) &&
            verifier.VerifyVector(scalar_key_sorted_tables()) &&
            verifier.VerifyVectorOfTables(scalar_key_sorted_tables()) &&
@@ -2692,7 +2704,8 @@ struct TypeAliases FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
     else if constexpr (Index == 11) return vf64();
     else static_assert(Index != -1, "Invalid Field Index");
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int8_t>(verifier, VT_I8, 1) &&
            VerifyField<uint8_t>(verifier, VT_U8, 1) &&
@@ -3385,7 +3398,8 @@ inline ::flatbuffers::Offset<TypeAliases> CreateTypeAliases(::flatbuffers::FlatB
       _vf64);
 }
 
-inline bool VerifyAny(::flatbuffers::Verifier &verifier, const void *obj, Any type) {
+template <bool TrackBufferSize>
+inline bool VerifyAny(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Any type) {
   switch (type) {
     case Any::NONE: {
       return true;
@@ -3406,7 +3420,8 @@ inline bool VerifyAny(::flatbuffers::Verifier &verifier, const void *obj, Any ty
   }
 }
 
-inline bool VerifyAnyVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Any> *types) {
+template <bool TrackBufferSize>
+inline bool VerifyAnyVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Any> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@@ -3498,7 +3513,8 @@ inline void AnyUnion::Reset() {
   type = Any::NONE;
 }
 
-inline bool VerifyAnyUniqueAliases(::flatbuffers::Verifier &verifier, const void *obj, AnyUniqueAliases type) {
+template <bool TrackBufferSize>
+inline bool VerifyAnyUniqueAliases(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, AnyUniqueAliases type) {
   switch (type) {
     case AnyUniqueAliases::NONE: {
       return true;
@@ -3519,7 +3535,8 @@ inline bool VerifyAnyUniqueAliases(::flatbuffers::Verifier &verifier, const void
   }
 }
 
-inline bool VerifyAnyUniqueAliasesVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<AnyUniqueAliases> *types) {
+template <bool TrackBufferSize>
+inline bool VerifyAnyUniqueAliasesVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<AnyUniqueAliases> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@@ -3611,7 +3628,8 @@ inline void AnyUniqueAliasesUnion::Reset() {
   type = AnyUniqueAliases::NONE;
 }
 
-inline bool VerifyAnyAmbiguousAliases(::flatbuffers::Verifier &verifier, const void *obj, AnyAmbiguousAliases type) {
+template <bool TrackBufferSize>
+inline bool VerifyAnyAmbiguousAliases(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, AnyAmbiguousAliases type) {
   switch (type) {
     case AnyAmbiguousAliases::NONE: {
       return true;
@@ -3632,7 +3650,8 @@ inline bool VerifyAnyAmbiguousAliases(::flatbuffers::Verifier &verifier, const v
   }
 }
 
-inline bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<AnyAmbiguousAliases> *types) {
+template <bool TrackBufferSize>
+inline bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<AnyAmbiguousAliases> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@@ -4241,14 +4260,16 @@ inline bool SizePrefixedMonsterBufferHasIdentifier(const void *buf) {
       buf, MonsterIdentifier(), true);
 }
 
+template <bool TrackBufferSize = false>
 inline bool VerifyMonsterBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifyBuffer<MyGame::Example::Monster>(MonsterIdentifier());
+    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+  return verifier.template VerifyBuffer<MyGame::Example::Monster>(MonsterIdentifier());
 }
 
+template <bool TrackBufferSize = false>
 inline bool VerifySizePrefixedMonsterBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifySizePrefixedBuffer<MyGame::Example::Monster>(MonsterIdentifier());
+    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+  return verifier.template VerifySizePrefixedBuffer<MyGame::Example::Monster>(MonsterIdentifier());
 }
 
 inline const char *MonsterExtension() {
diff --git a/tests/cpp17/generated_cpp17/optional_scalars_generated.h b/tests/cpp17/generated_cpp17/optional_scalars_generated.h
index f2ace0e619d..3023e9ad7ae 100644
--- a/tests/cpp17/generated_cpp17/optional_scalars_generated.h
+++ b/tests/cpp17/generated_cpp17/optional_scalars_generated.h
@@ -395,7 +395,8 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
     else if constexpr (Index == 35) return default_enum();
     else static_assert(Index != -1, "Invalid Field Index");
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int8_t>(verifier, VT_JUST_I8, 1) &&
            VerifyField<int8_t>(verifier, VT_MAYBE_I8, 1) &&
@@ -958,14 +959,16 @@ inline bool SizePrefixedScalarStuffBufferHasIdentifier(const void *buf) {
       buf, ScalarStuffIdentifier(), true);
 }
 
+template <bool TrackBufferSize = false>
 inline bool VerifyScalarStuffBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifyBuffer<optional_scalars::ScalarStuff>(ScalarStuffIdentifier());
+    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+  return verifier.template VerifyBuffer<optional_scalars::ScalarStuff>(ScalarStuffIdentifier());
 }
 
+template <bool TrackBufferSize = false>
 inline bool VerifySizePrefixedScalarStuffBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifySizePrefixedBuffer<optional_scalars::ScalarStuff>(ScalarStuffIdentifier());
+    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+  return verifier.template VerifySizePrefixedBuffer<optional_scalars::ScalarStuff>(ScalarStuffIdentifier());
 }
 
 inline const char *ScalarStuffExtension() {
diff --git a/tests/cpp17/generated_cpp17/union_vector_generated.h b/tests/cpp17/generated_cpp17/union_vector_generated.h
index 0b428e1ea2e..beb9774c16f 100644
--- a/tests/cpp17/generated_cpp17/union_vector_generated.h
+++ b/tests/cpp17/generated_cpp17/union_vector_generated.h
@@ -158,8 +158,10 @@ struct CharacterUnion {
   }
 };
 
-bool VerifyCharacter(::flatbuffers::Verifier &verifier, const void *obj, Character type);
-bool VerifyCharacterVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Character> *types);
+template <bool TrackBufferSize = false>
+bool VerifyCharacter(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Character type);
+template <bool TrackBufferSize = false>
+bool VerifyCharacterVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Character> *types);
 
 enum class Gadget : uint8_t {
   NONE = 0,
@@ -266,8 +268,10 @@ struct GadgetUnion {
   }
 };
 
-bool VerifyGadget(::flatbuffers::Verifier &verifier, const void *obj, Gadget type);
-bool VerifyGadgetVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Gadget> *types);
+template <bool TrackBufferSize = false>
+bool VerifyGadget(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Gadget type);
+template <bool TrackBufferSize = false>
+bool VerifyGadgetVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Gadget> *types);
 
 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Rapunzel FLATBUFFERS_FINAL_CLASS {
  private:
@@ -418,7 +422,8 @@ struct Attacker FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
          if constexpr (Index == 0) return sword_attack_damage();
     else static_assert(Index != -1, "Invalid Field Index");
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int32_t>(verifier, VT_SWORD_ATTACK_DAMAGE, 4) &&
            verifier.EndTable();
@@ -495,7 +500,8 @@ struct HandFan FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
          if constexpr (Index == 0) return length();
     else static_assert(Index != -1, "Invalid Field Index");
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int32_t>(verifier, VT_LENGTH, 4) &&
            verifier.EndTable();
@@ -612,7 +618,8 @@ struct Movie FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
     else if constexpr (Index == 3) return characters();
     else static_assert(Index != -1, "Invalid Field Index");
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint8_t>(verifier, VT_MAIN_CHARACTER_TYPE, 1) &&
            VerifyOffset(verifier, VT_MAIN_CHARACTER) &&
@@ -791,7 +798,8 @@ inline ::flatbuffers::Offset<Movie> CreateMovie(::flatbuffers::FlatBufferBuilder
       _characters);
 }
 
-inline bool VerifyCharacter(::flatbuffers::Verifier &verifier, const void *obj, Character type) {
+template <bool TrackBufferSize>
+inline bool VerifyCharacter(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Character type) {
   switch (type) {
     case Character::NONE: {
       return true;
@@ -801,13 +809,13 @@ inline bool VerifyCharacter(::flatbuffers::Verifier &verifier, const void *obj,
       return verifier.VerifyTable(ptr);
     }
     case Character::Rapunzel: {
-      return verifier.VerifyField<Rapunzel>(static_cast<const uint8_t *>(obj), 0, 4);
+      return verifier.template VerifyField<Rapunzel>(static_cast<const uint8_t *>(obj), 0, 4);
     }
     case Character::Belle: {
-      return verifier.VerifyField<BookReader>(static_cast<const uint8_t *>(obj), 0, 4);
+      return verifier.template VerifyField<BookReader>(static_cast<const uint8_t *>(obj), 0, 4);
     }
     case Character::BookFan: {
-      return verifier.VerifyField<BookReader>(static_cast<const uint8_t *>(obj), 0, 4);
+      return verifier.template VerifyField<BookReader>(static_cast<const uint8_t *>(obj), 0, 4);
     }
     case Character::Other: {
       auto ptr = reinterpret_cast<const ::flatbuffers::String *>(obj);
@@ -821,7 +829,8 @@ inline bool VerifyCharacter(::flatbuffers::Verifier &verifier, const void *obj,
   }
 }
 
-inline bool VerifyCharacterVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Character> *types) {
+template <bool TrackBufferSize>
+inline bool VerifyCharacterVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Character> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@@ -964,13 +973,14 @@ inline void CharacterUnion::Reset() {
   type = Character::NONE;
 }
 
-inline bool VerifyGadget(::flatbuffers::Verifier &verifier, const void *obj, Gadget type) {
+template <bool TrackBufferSize>
+inline bool VerifyGadget(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Gadget type) {
   switch (type) {
     case Gadget::NONE: {
       return true;
     }
     case Gadget::FallingTub: {
-      return verifier.VerifyField<FallingTub>(static_cast<const uint8_t *>(obj), 0, 4);
+      return verifier.template VerifyField<FallingTub>(static_cast<const uint8_t *>(obj), 0, 4);
     }
     case Gadget::HandFan: {
       auto ptr = reinterpret_cast<const HandFan *>(obj);
@@ -980,7 +990,8 @@ inline bool VerifyGadget(::flatbuffers::Verifier &verifier, const void *obj, Gad
   }
 }
 
-inline bool VerifyGadgetVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Gadget> *types) {
+template <bool TrackBufferSize>
+inline bool VerifyGadgetVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Gadget> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@@ -1226,14 +1237,16 @@ inline bool SizePrefixedMovieBufferHasIdentifier(const void *buf) {
       buf, MovieIdentifier(), true);
 }
 
+template <bool TrackBufferSize = false>
 inline bool VerifyMovieBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifyBuffer<Movie>(MovieIdentifier());
+    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+  return verifier.template VerifyBuffer<Movie>(MovieIdentifier());
 }
 
+template <bool TrackBufferSize = false>
 inline bool VerifySizePrefixedMovieBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifySizePrefixedBuffer<Movie>(MovieIdentifier());
+    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+  return verifier.template VerifySizePrefixedBuffer<Movie>(MovieIdentifier());
 }
 
 inline void FinishMovieBuffer(
diff --git a/tests/evolution_test/evolution_v1_generated.h b/tests/evolution_test/evolution_v1_generated.h
index 91ae45d90b3..023edcd35f5 100644
--- a/tests/evolution_test/evolution_v1_generated.h
+++ b/tests/evolution_test/evolution_v1_generated.h
@@ -102,8 +102,10 @@ template<> struct UnionTraits<Evolution::V1::TableB> {
   static const Union enum_value = Union::TableB;
 };
 
-bool VerifyUnion(::flatbuffers::Verifier &verifier, const void *obj, Union type);
-bool VerifyUnionVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Union> *types);
+template <bool TrackBufferSize = false>
+bool VerifyUnion(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Union type);
+template <bool TrackBufferSize = false>
+bool VerifyUnionVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Union> *types);
 
 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Struct FLATBUFFERS_FINAL_CLASS {
  private:
@@ -156,7 +158,8 @@ struct TableA FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   int32_t b() const {
     return GetField<int32_t>(VT_B, 0);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<float>(verifier, VT_A, 4) &&
            VerifyField<int32_t>(verifier, VT_B, 4) &&
@@ -203,7 +206,8 @@ struct TableB FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   int32_t a() const {
     return GetField<int32_t>(VT_A, 0);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int32_t>(verifier, VT_A, 4) &&
            verifier.EndTable();
@@ -302,7 +306,8 @@ struct Root FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const Evolution::V1::TableB *j_as_TableB() const {
     return j_type() == Evolution::V1::Union::TableB ? static_cast<const Evolution::V1::TableB *>(j()) : nullptr;
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int32_t>(verifier, VT_A, 4) &&
            VerifyField<uint8_t>(verifier, VT_B, 1) &&
@@ -455,7 +460,8 @@ inline ::flatbuffers::Offset<Root> CreateRootDirect(
       j);
 }
 
-inline bool VerifyUnion(::flatbuffers::Verifier &verifier, const void *obj, Union type) {
+template <bool TrackBufferSize>
+inline bool VerifyUnion(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Union type) {
   switch (type) {
     case Union::NONE: {
       return true;
@@ -472,7 +478,8 @@ inline bool VerifyUnion(::flatbuffers::Verifier &verifier, const void *obj, Unio
   }
 }
 
-inline bool VerifyUnionVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Union> *types) {
+template <bool TrackBufferSize>
+inline bool VerifyUnionVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Union> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@@ -492,14 +499,16 @@ inline const Evolution::V1::Root *GetSizePrefixedRoot(const void *buf) {
   return ::flatbuffers::GetSizePrefixedRoot<Evolution::V1::Root>(buf);
 }
 
+template <bool TrackBufferSize = false>
 inline bool VerifyRootBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifyBuffer<Evolution::V1::Root>(nullptr);
+    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+  return verifier.template VerifyBuffer<Evolution::V1::Root>(nullptr);
 }
 
+template <bool TrackBufferSize = false>
 inline bool VerifySizePrefixedRootBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifySizePrefixedBuffer<Evolution::V1::Root>(nullptr);
+    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+  return verifier.template VerifySizePrefixedBuffer<Evolution::V1::Root>(nullptr);
 }
 
 inline void FinishRootBuffer(
diff --git a/tests/evolution_test/evolution_v2_generated.h b/tests/evolution_test/evolution_v2_generated.h
index 8a6dcf050ab..768142896ef 100644
--- a/tests/evolution_test/evolution_v2_generated.h
+++ b/tests/evolution_test/evolution_v2_generated.h
@@ -118,8 +118,10 @@ template<> struct UnionTraits<Evolution::V2::TableC> {
   static const Union enum_value = Union::TableC;
 };
 
-bool VerifyUnion(::flatbuffers::Verifier &verifier, const void *obj, Union type);
-bool VerifyUnionVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Union> *types);
+template <bool TrackBufferSize = false>
+bool VerifyUnion(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Union type);
+template <bool TrackBufferSize = false>
+bool VerifyUnionVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Union> *types);
 
 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Struct FLATBUFFERS_FINAL_CLASS {
  private:
@@ -176,7 +178,8 @@ struct TableA FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const ::flatbuffers::String *c() const {
     return GetPointer<const ::flatbuffers::String *>(VT_C);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<float>(verifier, VT_A, 4) &&
            VerifyField<int32_t>(verifier, VT_B, 4) &&
@@ -243,7 +246,8 @@ struct TableB FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   int32_t a() const {
     return GetField<int32_t>(VT_A, 0);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int32_t>(verifier, VT_A, 4) &&
            verifier.EndTable();
@@ -288,7 +292,8 @@ struct TableC FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const ::flatbuffers::String *b() const {
     return GetPointer<const ::flatbuffers::String *>(VT_B);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<double>(verifier, VT_A, 8) &&
            VerifyOffset(verifier, VT_B) &&
@@ -397,7 +402,8 @@ struct Root FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   uint8_t l() const {
     return GetField<uint8_t>(VT_L, 56);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint8_t>(verifier, VT_B, 1) &&
            VerifyField<uint8_t>(verifier, VT_C_TYPE, 1) &&
@@ -538,7 +544,8 @@ inline ::flatbuffers::Offset<Root> CreateRootDirect(
       l);
 }
 
-inline bool VerifyUnion(::flatbuffers::Verifier &verifier, const void *obj, Union type) {
+template <bool TrackBufferSize>
+inline bool VerifyUnion(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Union type) {
   switch (type) {
     case Union::NONE: {
       return true;
@@ -559,7 +566,8 @@ inline bool VerifyUnion(::flatbuffers::Verifier &verifier, const void *obj, Unio
   }
 }
 
-inline bool VerifyUnionVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Union> *types) {
+template <bool TrackBufferSize>
+inline bool VerifyUnionVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Union> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@@ -579,14 +587,16 @@ inline const Evolution::V2::Root *GetSizePrefixedRoot(const void *buf) {
   return ::flatbuffers::GetSizePrefixedRoot<Evolution::V2::Root>(buf);
 }
 
+template <bool TrackBufferSize = false>
 inline bool VerifyRootBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifyBuffer<Evolution::V2::Root>(nullptr);
+    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+  return verifier.template VerifyBuffer<Evolution::V2::Root>(nullptr);
 }
 
+template <bool TrackBufferSize = false>
 inline bool VerifySizePrefixedRootBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifySizePrefixedBuffer<Evolution::V2::Root>(nullptr);
+    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+  return verifier.template VerifySizePrefixedBuffer<Evolution::V2::Root>(nullptr);
 }
 
 inline void FinishRootBuffer(
diff --git a/tests/fuzzer/flatbuffers_verifier_fuzzer.cc b/tests/fuzzer/flatbuffers_verifier_fuzzer.cc
index f8a7b4c82ba..94168b54a9c 100644
--- a/tests/fuzzer/flatbuffers_verifier_fuzzer.cc
+++ b/tests/fuzzer/flatbuffers_verifier_fuzzer.cc
@@ -11,5 +11,7 @@
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
   flatbuffers::Verifier verifier(data, size);
   MyGame::Example::VerifyMonsterBuffer(verifier);
+  flatbuffers::SizeVerifier size_verifier(data, size);
+  MyGame::Example::VerifyMonsterBuffer(size_verifier);
   return 0;
 }
diff --git a/tests/key_field/key_field_sample_generated.h b/tests/key_field/key_field_sample_generated.h
index 46b43852dd4..8d93e139703 100644
--- a/tests/key_field/key_field_sample_generated.h
+++ b/tests/key_field/key_field_sample_generated.h
@@ -634,7 +634,8 @@ struct FooTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   ::flatbuffers::Vector<const keyfield::sample::Grain *> *mutable_h() {
     return GetPointer<::flatbuffers::Vector<const keyfield::sample::Grain *> *>(VT_H);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int32_t>(verifier, VT_A, 4) &&
            VerifyField<int32_t>(verifier, VT_B, 4) &&
@@ -990,14 +991,16 @@ inline keyfield::sample::FooTable *GetMutableSizePrefixedFooTable(void *buf) {
   return ::flatbuffers::GetMutableSizePrefixedRoot<keyfield::sample::FooTable>(buf);
 }
 
+template <bool TrackBufferSize = false>
 inline bool VerifyFooTableBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifyBuffer<keyfield::sample::FooTable>(nullptr);
+    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+  return verifier.template VerifyBuffer<keyfield::sample::FooTable>(nullptr);
 }
 
+template <bool TrackBufferSize = false>
 inline bool VerifySizePrefixedFooTableBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifySizePrefixedBuffer<keyfield::sample::FooTable>(nullptr);
+    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+  return verifier.template VerifySizePrefixedBuffer<keyfield::sample::FooTable>(nullptr);
 }
 
 inline void FinishFooTableBuffer(
diff --git a/tests/monster_extra_generated.h b/tests/monster_extra_generated.h
index 201569abc15..e5a86fbd133 100644
--- a/tests/monster_extra_generated.h
+++ b/tests/monster_extra_generated.h
@@ -116,7 +116,8 @@ struct MonsterExtra FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   ::flatbuffers::Vector<float> *mutable_fvec() {
     return GetPointer<::flatbuffers::Vector<float> *>(VT_FVEC);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<double>(verifier, VT_D0, 8) &&
            VerifyField<double>(verifier, VT_D1, 8) &&
@@ -374,14 +375,16 @@ inline bool SizePrefixedMonsterExtraBufferHasIdentifier(const void *buf) {
       buf, MonsterExtraIdentifier(), true);
 }
 
+template <bool TrackBufferSize = false>
 inline bool VerifyMonsterExtraBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifyBuffer<MyGame::MonsterExtra>(MonsterExtraIdentifier());
+    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+  return verifier.template VerifyBuffer<MyGame::MonsterExtra>(MonsterExtraIdentifier());
 }
 
+template <bool TrackBufferSize = false>
 inline bool VerifySizePrefixedMonsterExtraBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifySizePrefixedBuffer<MyGame::MonsterExtra>(MonsterExtraIdentifier());
+    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+  return verifier.template VerifySizePrefixedBuffer<MyGame::MonsterExtra>(MonsterExtraIdentifier());
 }
 
 inline const char *MonsterExtraExtension() {
diff --git a/tests/monster_test_generated.h b/tests/monster_test_generated.h
index caa25138247..0aec4e8eb66 100644
--- a/tests/monster_test_generated.h
+++ b/tests/monster_test_generated.h
@@ -386,8 +386,10 @@ inline bool operator!=(const AnyUnion &lhs, const AnyUnion &rhs) {
     return !(lhs == rhs);
 }
 
-bool VerifyAny(::flatbuffers::Verifier &verifier, const void *obj, Any type);
-bool VerifyAnyVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
+template <bool TrackBufferSize = false>
+bool VerifyAny(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Any type);
+template <bool TrackBufferSize = false>
+bool VerifyAnyVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
 
 enum AnyUniqueAliases : uint8_t {
   AnyUniqueAliases_NONE = 0,
@@ -542,8 +544,10 @@ inline bool operator!=(const AnyUniqueAliasesUnion &lhs, const AnyUniqueAliasesU
     return !(lhs == rhs);
 }
 
-bool VerifyAnyUniqueAliases(::flatbuffers::Verifier &verifier, const void *obj, AnyUniqueAliases type);
-bool VerifyAnyUniqueAliasesVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
+template <bool TrackBufferSize = false>
+bool VerifyAnyUniqueAliases(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, AnyUniqueAliases type);
+template <bool TrackBufferSize = false>
+bool VerifyAnyUniqueAliasesVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
 
 enum AnyAmbiguousAliases : uint8_t {
   AnyAmbiguousAliases_NONE = 0,
@@ -656,8 +660,10 @@ inline bool operator!=(const AnyAmbiguousAliasesUnion &lhs, const AnyAmbiguousAl
     return !(lhs == rhs);
 }
 
-bool VerifyAnyAmbiguousAliases(::flatbuffers::Verifier &verifier, const void *obj, AnyAmbiguousAliases type);
-bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
+template <bool TrackBufferSize = false>
+bool VerifyAnyAmbiguousAliases(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, AnyAmbiguousAliases type);
+template <bool TrackBufferSize = false>
+bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
 
 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(2) Test FLATBUFFERS_FINAL_CLASS {
  private:
@@ -953,7 +959,8 @@ struct InParentNamespace FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
   static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
     return InParentNamespaceTypeTable();
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            verifier.EndTable();
   }
@@ -998,7 +1005,8 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
     return MonsterTypeTable();
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            verifier.EndTable();
   }
@@ -1055,7 +1063,8 @@ struct TestSimpleTableWithEnum FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::
   bool mutate_color(MyGame::Example::Color _color = static_cast<MyGame::Example::Color>(2)) {
     return SetField<uint8_t>(VT_COLOR, static_cast<uint8_t>(_color), 2);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint8_t>(verifier, VT_COLOR, 1) &&
            verifier.EndTable();
@@ -1136,7 +1145,8 @@ struct Stat FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   int KeyCompareWithValue(uint16_t _count) const {
     return static_cast<int>(count() > _count) - static_cast<int>(count() < _count);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_ID) &&
            verifier.VerifyString(id()) &&
@@ -1227,7 +1237,8 @@ struct Referrable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   int KeyCompareWithValue(uint64_t _id) const {
     return static_cast<int>(id() > _id) - static_cast<int>(id() < _id);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint64_t>(verifier, VT_ID, 8) &&
            verifier.EndTable();
@@ -1817,7 +1828,8 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   bool mutate_double_inf_default(double _double_inf_default = std::numeric_limits<double>::infinity()) {
     return SetField<double>(VT_DOUBLE_INF_DEFAULT, _double_inf_default, std::numeric_limits<double>::infinity());
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<MyGame::Example::Vec3>(verifier, VT_POS, 8) &&
            VerifyField<int16_t>(verifier, VT_MANA, 2) &&
@@ -1842,7 +1854,7 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
            verifier.VerifyTable(enemy()) &&
            VerifyOffset(verifier, VT_TESTNESTEDFLATBUFFER) &&
            verifier.VerifyVector(testnestedflatbuffer()) &&
-           verifier.VerifyNestedFlatBuffer<MyGame::Example::Monster>(testnestedflatbuffer(), nullptr) &&
+           verifier.template VerifyNestedFlatBuffer<MyGame::Example::Monster>(testnestedflatbuffer(), nullptr) &&
            VerifyOffset(verifier, VT_TESTEMPTY) &&
            verifier.VerifyTable(testempty()) &&
            VerifyField<uint8_t>(verifier, VT_TESTBOOL, 1) &&
@@ -1901,7 +1913,7 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
            VerifyField<int8_t>(verifier, VT_SIGNED_ENUM, 1) &&
            VerifyOffset(verifier, VT_TESTREQUIREDNESTEDFLATBUFFER) &&
            verifier.VerifyVector(testrequirednestedflatbuffer()) &&
-           verifier.VerifyNestedFlatBuffer<MyGame::Example::Monster>(testrequirednestedflatbuffer(), nullptr) &&
+           verifier.template VerifyNestedFlatBuffer<MyGame::Example::Monster>(testrequirednestedflatbuffer(), nullptr) &&
            VerifyOffset(verifier, VT_SCALAR_KEY_SORTED_TABLES) &&
            verifier.VerifyVector(scalar_key_sorted_tables()) &&
            verifier.VerifyVectorOfTables(scalar_key_sorted_tables()) &&
@@ -2534,7 +2546,8 @@ struct TypeAliases FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   ::flatbuffers::Vector<double> *mutable_vf64() {
     return GetPointer<::flatbuffers::Vector<double> *>(VT_VF64);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int8_t>(verifier, VT_I8, 1) &&
            VerifyField<uint8_t>(verifier, VT_U8, 1) &&
@@ -3348,7 +3361,8 @@ inline ::flatbuffers::Offset<TypeAliases> CreateTypeAliases(::flatbuffers::FlatB
       _vf64);
 }
 
-inline bool VerifyAny(::flatbuffers::Verifier &verifier, const void *obj, Any type) {
+template <bool TrackBufferSize>
+inline bool VerifyAny(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Any type) {
   switch (type) {
     case Any_NONE: {
       return true;
@@ -3369,7 +3383,8 @@ inline bool VerifyAny(::flatbuffers::Verifier &verifier, const void *obj, Any ty
   }
 }
 
-inline bool VerifyAnyVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
+template <bool TrackBufferSize>
+inline bool VerifyAnyVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@@ -3461,7 +3476,8 @@ inline void AnyUnion::Reset() {
   type = Any_NONE;
 }
 
-inline bool VerifyAnyUniqueAliases(::flatbuffers::Verifier &verifier, const void *obj, AnyUniqueAliases type) {
+template <bool TrackBufferSize>
+inline bool VerifyAnyUniqueAliases(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, AnyUniqueAliases type) {
   switch (type) {
     case AnyUniqueAliases_NONE: {
       return true;
@@ -3482,7 +3498,8 @@ inline bool VerifyAnyUniqueAliases(::flatbuffers::Verifier &verifier, const void
   }
 }
 
-inline bool VerifyAnyUniqueAliasesVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
+template <bool TrackBufferSize>
+inline bool VerifyAnyUniqueAliasesVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@@ -3574,7 +3591,8 @@ inline void AnyUniqueAliasesUnion::Reset() {
   type = AnyUniqueAliases_NONE;
 }
 
-inline bool VerifyAnyAmbiguousAliases(::flatbuffers::Verifier &verifier, const void *obj, AnyAmbiguousAliases type) {
+template <bool TrackBufferSize>
+inline bool VerifyAnyAmbiguousAliases(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, AnyAmbiguousAliases type) {
   switch (type) {
     case AnyAmbiguousAliases_NONE: {
       return true;
@@ -3595,7 +3613,8 @@ inline bool VerifyAnyAmbiguousAliases(::flatbuffers::Verifier &verifier, const v
   }
 }
 
-inline bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
+template <bool TrackBufferSize>
+inline bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@@ -4204,14 +4223,16 @@ inline bool SizePrefixedMonsterBufferHasIdentifier(const void *buf) {
       buf, MonsterIdentifier(), true);
 }
 
+template <bool TrackBufferSize = false>
 inline bool VerifyMonsterBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifyBuffer<MyGame::Example::Monster>(MonsterIdentifier());
+    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+  return verifier.template VerifyBuffer<MyGame::Example::Monster>(MonsterIdentifier());
 }
 
+template <bool TrackBufferSize = false>
 inline bool VerifySizePrefixedMonsterBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifySizePrefixedBuffer<MyGame::Example::Monster>(MonsterIdentifier());
+    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+  return verifier.template VerifySizePrefixedBuffer<MyGame::Example::Monster>(MonsterIdentifier());
 }
 
 inline const char *MonsterExtension() {
diff --git a/tests/monster_test_suffix/ext_only/monster_test_generated.hpp b/tests/monster_test_suffix/ext_only/monster_test_generated.hpp
index ee0a34a1ac7..35f4c00ee13 100644
--- a/tests/monster_test_suffix/ext_only/monster_test_generated.hpp
+++ b/tests/monster_test_suffix/ext_only/monster_test_generated.hpp
@@ -383,8 +383,10 @@ inline bool operator!=(const AnyUnion &lhs, const AnyUnion &rhs) {
     return !(lhs == rhs);
 }
 
-bool VerifyAny(::flatbuffers::Verifier &verifier, const void *obj, Any type);
-bool VerifyAnyVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
+template <bool TrackBufferSize = false>
+bool VerifyAny(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Any type);
+template <bool TrackBufferSize = false>
+bool VerifyAnyVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
 
 enum AnyUniqueAliases : uint8_t {
   AnyUniqueAliases_NONE = 0,
@@ -539,8 +541,10 @@ inline bool operator!=(const AnyUniqueAliasesUnion &lhs, const AnyUniqueAliasesU
     return !(lhs == rhs);
 }
 
-bool VerifyAnyUniqueAliases(::flatbuffers::Verifier &verifier, const void *obj, AnyUniqueAliases type);
-bool VerifyAnyUniqueAliasesVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
+template <bool TrackBufferSize = false>
+bool VerifyAnyUniqueAliases(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, AnyUniqueAliases type);
+template <bool TrackBufferSize = false>
+bool VerifyAnyUniqueAliasesVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
 
 enum AnyAmbiguousAliases : uint8_t {
   AnyAmbiguousAliases_NONE = 0,
@@ -653,8 +657,10 @@ inline bool operator!=(const AnyAmbiguousAliasesUnion &lhs, const AnyAmbiguousAl
     return !(lhs == rhs);
 }
 
-bool VerifyAnyAmbiguousAliases(::flatbuffers::Verifier &verifier, const void *obj, AnyAmbiguousAliases type);
-bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
+template <bool TrackBufferSize = false>
+bool VerifyAnyAmbiguousAliases(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, AnyAmbiguousAliases type);
+template <bool TrackBufferSize = false>
+bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
 
 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(2) Test FLATBUFFERS_FINAL_CLASS {
  private:
@@ -949,7 +955,8 @@ struct InParentNamespace FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
   static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
     return InParentNamespaceTypeTable();
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            verifier.EndTable();
   }
@@ -993,7 +1000,8 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
     return MonsterTypeTable();
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            verifier.EndTable();
   }
@@ -1049,7 +1057,8 @@ struct TestSimpleTableWithEnum FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::
   bool mutate_color(MyGame::Example::Color _color = static_cast<MyGame::Example::Color>(2)) {
     return SetField<uint8_t>(VT_COLOR, static_cast<uint8_t>(_color), 2);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint8_t>(verifier, VT_COLOR, 1) &&
            verifier.EndTable();
@@ -1129,7 +1138,8 @@ struct Stat FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   int KeyCompareWithValue(uint16_t _count) const {
     return static_cast<int>(count() > _count) - static_cast<int>(count() < _count);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_ID) &&
            verifier.VerifyString(id()) &&
@@ -1219,7 +1229,8 @@ struct Referrable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   int KeyCompareWithValue(uint64_t _id) const {
     return static_cast<int>(id() > _id) - static_cast<int>(id() < _id);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint64_t>(verifier, VT_ID, 8) &&
            verifier.EndTable();
@@ -1808,7 +1819,8 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   bool mutate_double_inf_default(double _double_inf_default = std::numeric_limits<double>::infinity()) {
     return SetField<double>(VT_DOUBLE_INF_DEFAULT, _double_inf_default, std::numeric_limits<double>::infinity());
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<MyGame::Example::Vec3>(verifier, VT_POS, 8) &&
            VerifyField<int16_t>(verifier, VT_MANA, 2) &&
@@ -1833,7 +1845,7 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
            verifier.VerifyTable(enemy()) &&
            VerifyOffset(verifier, VT_TESTNESTEDFLATBUFFER) &&
            verifier.VerifyVector(testnestedflatbuffer()) &&
-           verifier.VerifyNestedFlatBuffer<MyGame::Example::Monster>(testnestedflatbuffer(), nullptr) &&
+           verifier.template VerifyNestedFlatBuffer<MyGame::Example::Monster>(testnestedflatbuffer(), nullptr) &&
            VerifyOffset(verifier, VT_TESTEMPTY) &&
            verifier.VerifyTable(testempty()) &&
            VerifyField<uint8_t>(verifier, VT_TESTBOOL, 1) &&
@@ -1892,7 +1904,7 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
            VerifyField<int8_t>(verifier, VT_SIGNED_ENUM, 1) &&
            VerifyOffset(verifier, VT_TESTREQUIREDNESTEDFLATBUFFER) &&
            verifier.VerifyVector(testrequirednestedflatbuffer()) &&
-           verifier.VerifyNestedFlatBuffer<MyGame::Example::Monster>(testrequirednestedflatbuffer(), nullptr) &&
+           verifier.template VerifyNestedFlatBuffer<MyGame::Example::Monster>(testrequirednestedflatbuffer(), nullptr) &&
            VerifyOffset(verifier, VT_SCALAR_KEY_SORTED_TABLES) &&
            verifier.VerifyVector(scalar_key_sorted_tables()) &&
            verifier.VerifyVectorOfTables(scalar_key_sorted_tables()) &&
@@ -2524,7 +2536,8 @@ struct TypeAliases FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   ::flatbuffers::Vector<double> *mutable_vf64() {
     return GetPointer<::flatbuffers::Vector<double> *>(VT_VF64);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int8_t>(verifier, VT_I8, 1) &&
            VerifyField<uint8_t>(verifier, VT_U8, 1) &&
@@ -3338,7 +3351,8 @@ inline ::flatbuffers::Offset<TypeAliases> CreateTypeAliases(::flatbuffers::FlatB
       _vf64);
 }
 
-inline bool VerifyAny(::flatbuffers::Verifier &verifier, const void *obj, Any type) {
+template <bool TrackBufferSize>
+inline bool VerifyAny(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Any type) {
   switch (type) {
     case Any_NONE: {
       return true;
@@ -3359,7 +3373,8 @@ inline bool VerifyAny(::flatbuffers::Verifier &verifier, const void *obj, Any ty
   }
 }
 
-inline bool VerifyAnyVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
+template <bool TrackBufferSize>
+inline bool VerifyAnyVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@@ -3451,7 +3466,8 @@ inline void AnyUnion::Reset() {
   type = Any_NONE;
 }
 
-inline bool VerifyAnyUniqueAliases(::flatbuffers::Verifier &verifier, const void *obj, AnyUniqueAliases type) {
+template <bool TrackBufferSize>
+inline bool VerifyAnyUniqueAliases(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, AnyUniqueAliases type) {
   switch (type) {
     case AnyUniqueAliases_NONE: {
       return true;
@@ -3472,7 +3488,8 @@ inline bool VerifyAnyUniqueAliases(::flatbuffers::Verifier &verifier, const void
   }
 }
 
-inline bool VerifyAnyUniqueAliasesVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
+template <bool TrackBufferSize>
+inline bool VerifyAnyUniqueAliasesVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@@ -3564,7 +3581,8 @@ inline void AnyUniqueAliasesUnion::Reset() {
   type = AnyUniqueAliases_NONE;
 }
 
-inline bool VerifyAnyAmbiguousAliases(::flatbuffers::Verifier &verifier, const void *obj, AnyAmbiguousAliases type) {
+template <bool TrackBufferSize>
+inline bool VerifyAnyAmbiguousAliases(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, AnyAmbiguousAliases type) {
   switch (type) {
     case AnyAmbiguousAliases_NONE: {
       return true;
@@ -3585,7 +3603,8 @@ inline bool VerifyAnyAmbiguousAliases(::flatbuffers::Verifier &verifier, const v
   }
 }
 
-inline bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
+template <bool TrackBufferSize>
+inline bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@@ -4194,14 +4213,16 @@ inline bool SizePrefixedMonsterBufferHasIdentifier(const void *buf) {
       buf, MonsterIdentifier(), true);
 }
 
+template <bool TrackBufferSize = false>
 inline bool VerifyMonsterBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifyBuffer<MyGame::Example::Monster>(MonsterIdentifier());
+    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+  return verifier.template VerifyBuffer<MyGame::Example::Monster>(MonsterIdentifier());
 }
 
+template <bool TrackBufferSize = false>
 inline bool VerifySizePrefixedMonsterBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifySizePrefixedBuffer<MyGame::Example::Monster>(MonsterIdentifier());
+    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+  return verifier.template VerifySizePrefixedBuffer<MyGame::Example::Monster>(MonsterIdentifier());
 }
 
 inline const char *MonsterExtension() {
diff --git a/tests/monster_test_suffix/filesuffix_only/monster_test_suffix.h b/tests/monster_test_suffix/filesuffix_only/monster_test_suffix.h
index ee0a34a1ac7..35f4c00ee13 100644
--- a/tests/monster_test_suffix/filesuffix_only/monster_test_suffix.h
+++ b/tests/monster_test_suffix/filesuffix_only/monster_test_suffix.h
@@ -383,8 +383,10 @@ inline bool operator!=(const AnyUnion &lhs, const AnyUnion &rhs) {
     return !(lhs == rhs);
 }
 
-bool VerifyAny(::flatbuffers::Verifier &verifier, const void *obj, Any type);
-bool VerifyAnyVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
+template <bool TrackBufferSize = false>
+bool VerifyAny(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Any type);
+template <bool TrackBufferSize = false>
+bool VerifyAnyVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
 
 enum AnyUniqueAliases : uint8_t {
   AnyUniqueAliases_NONE = 0,
@@ -539,8 +541,10 @@ inline bool operator!=(const AnyUniqueAliasesUnion &lhs, const AnyUniqueAliasesU
     return !(lhs == rhs);
 }
 
-bool VerifyAnyUniqueAliases(::flatbuffers::Verifier &verifier, const void *obj, AnyUniqueAliases type);
-bool VerifyAnyUniqueAliasesVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
+template <bool TrackBufferSize = false>
+bool VerifyAnyUniqueAliases(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, AnyUniqueAliases type);
+template <bool TrackBufferSize = false>
+bool VerifyAnyUniqueAliasesVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
 
 enum AnyAmbiguousAliases : uint8_t {
   AnyAmbiguousAliases_NONE = 0,
@@ -653,8 +657,10 @@ inline bool operator!=(const AnyAmbiguousAliasesUnion &lhs, const AnyAmbiguousAl
     return !(lhs == rhs);
 }
 
-bool VerifyAnyAmbiguousAliases(::flatbuffers::Verifier &verifier, const void *obj, AnyAmbiguousAliases type);
-bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
+template <bool TrackBufferSize = false>
+bool VerifyAnyAmbiguousAliases(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, AnyAmbiguousAliases type);
+template <bool TrackBufferSize = false>
+bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
 
 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(2) Test FLATBUFFERS_FINAL_CLASS {
  private:
@@ -949,7 +955,8 @@ struct InParentNamespace FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
   static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
     return InParentNamespaceTypeTable();
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            verifier.EndTable();
   }
@@ -993,7 +1000,8 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
     return MonsterTypeTable();
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            verifier.EndTable();
   }
@@ -1049,7 +1057,8 @@ struct TestSimpleTableWithEnum FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::
   bool mutate_color(MyGame::Example::Color _color = static_cast<MyGame::Example::Color>(2)) {
     return SetField<uint8_t>(VT_COLOR, static_cast<uint8_t>(_color), 2);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint8_t>(verifier, VT_COLOR, 1) &&
            verifier.EndTable();
@@ -1129,7 +1138,8 @@ struct Stat FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   int KeyCompareWithValue(uint16_t _count) const {
     return static_cast<int>(count() > _count) - static_cast<int>(count() < _count);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_ID) &&
            verifier.VerifyString(id()) &&
@@ -1219,7 +1229,8 @@ struct Referrable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   int KeyCompareWithValue(uint64_t _id) const {
     return static_cast<int>(id() > _id) - static_cast<int>(id() < _id);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint64_t>(verifier, VT_ID, 8) &&
            verifier.EndTable();
@@ -1808,7 +1819,8 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   bool mutate_double_inf_default(double _double_inf_default = std::numeric_limits<double>::infinity()) {
     return SetField<double>(VT_DOUBLE_INF_DEFAULT, _double_inf_default, std::numeric_limits<double>::infinity());
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<MyGame::Example::Vec3>(verifier, VT_POS, 8) &&
            VerifyField<int16_t>(verifier, VT_MANA, 2) &&
@@ -1833,7 +1845,7 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
            verifier.VerifyTable(enemy()) &&
            VerifyOffset(verifier, VT_TESTNESTEDFLATBUFFER) &&
            verifier.VerifyVector(testnestedflatbuffer()) &&
-           verifier.VerifyNestedFlatBuffer<MyGame::Example::Monster>(testnestedflatbuffer(), nullptr) &&
+           verifier.template VerifyNestedFlatBuffer<MyGame::Example::Monster>(testnestedflatbuffer(), nullptr) &&
            VerifyOffset(verifier, VT_TESTEMPTY) &&
            verifier.VerifyTable(testempty()) &&
            VerifyField<uint8_t>(verifier, VT_TESTBOOL, 1) &&
@@ -1892,7 +1904,7 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
            VerifyField<int8_t>(verifier, VT_SIGNED_ENUM, 1) &&
            VerifyOffset(verifier, VT_TESTREQUIREDNESTEDFLATBUFFER) &&
            verifier.VerifyVector(testrequirednestedflatbuffer()) &&
-           verifier.VerifyNestedFlatBuffer<MyGame::Example::Monster>(testrequirednestedflatbuffer(), nullptr) &&
+           verifier.template VerifyNestedFlatBuffer<MyGame::Example::Monster>(testrequirednestedflatbuffer(), nullptr) &&
            VerifyOffset(verifier, VT_SCALAR_KEY_SORTED_TABLES) &&
            verifier.VerifyVector(scalar_key_sorted_tables()) &&
            verifier.VerifyVectorOfTables(scalar_key_sorted_tables()) &&
@@ -2524,7 +2536,8 @@ struct TypeAliases FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   ::flatbuffers::Vector<double> *mutable_vf64() {
     return GetPointer<::flatbuffers::Vector<double> *>(VT_VF64);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int8_t>(verifier, VT_I8, 1) &&
            VerifyField<uint8_t>(verifier, VT_U8, 1) &&
@@ -3338,7 +3351,8 @@ inline ::flatbuffers::Offset<TypeAliases> CreateTypeAliases(::flatbuffers::FlatB
       _vf64);
 }
 
-inline bool VerifyAny(::flatbuffers::Verifier &verifier, const void *obj, Any type) {
+template <bool TrackBufferSize>
+inline bool VerifyAny(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Any type) {
   switch (type) {
     case Any_NONE: {
       return true;
@@ -3359,7 +3373,8 @@ inline bool VerifyAny(::flatbuffers::Verifier &verifier, const void *obj, Any ty
   }
 }
 
-inline bool VerifyAnyVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
+template <bool TrackBufferSize>
+inline bool VerifyAnyVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@@ -3451,7 +3466,8 @@ inline void AnyUnion::Reset() {
   type = Any_NONE;
 }
 
-inline bool VerifyAnyUniqueAliases(::flatbuffers::Verifier &verifier, const void *obj, AnyUniqueAliases type) {
+template <bool TrackBufferSize>
+inline bool VerifyAnyUniqueAliases(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, AnyUniqueAliases type) {
   switch (type) {
     case AnyUniqueAliases_NONE: {
       return true;
@@ -3472,7 +3488,8 @@ inline bool VerifyAnyUniqueAliases(::flatbuffers::Verifier &verifier, const void
   }
 }
 
-inline bool VerifyAnyUniqueAliasesVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
+template <bool TrackBufferSize>
+inline bool VerifyAnyUniqueAliasesVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@@ -3564,7 +3581,8 @@ inline void AnyUniqueAliasesUnion::Reset() {
   type = AnyUniqueAliases_NONE;
 }
 
-inline bool VerifyAnyAmbiguousAliases(::flatbuffers::Verifier &verifier, const void *obj, AnyAmbiguousAliases type) {
+template <bool TrackBufferSize>
+inline bool VerifyAnyAmbiguousAliases(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, AnyAmbiguousAliases type) {
   switch (type) {
     case AnyAmbiguousAliases_NONE: {
       return true;
@@ -3585,7 +3603,8 @@ inline bool VerifyAnyAmbiguousAliases(::flatbuffers::Verifier &verifier, const v
   }
 }
 
-inline bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
+template <bool TrackBufferSize>
+inline bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@@ -4194,14 +4213,16 @@ inline bool SizePrefixedMonsterBufferHasIdentifier(const void *buf) {
       buf, MonsterIdentifier(), true);
 }
 
+template <bool TrackBufferSize = false>
 inline bool VerifyMonsterBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifyBuffer<MyGame::Example::Monster>(MonsterIdentifier());
+    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+  return verifier.template VerifyBuffer<MyGame::Example::Monster>(MonsterIdentifier());
 }
 
+template <bool TrackBufferSize = false>
 inline bool VerifySizePrefixedMonsterBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifySizePrefixedBuffer<MyGame::Example::Monster>(MonsterIdentifier());
+    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+  return verifier.template VerifySizePrefixedBuffer<MyGame::Example::Monster>(MonsterIdentifier());
 }
 
 inline const char *MonsterExtension() {
diff --git a/tests/monster_test_suffix/monster_test_suffix.hpp b/tests/monster_test_suffix/monster_test_suffix.hpp
index ee0a34a1ac7..35f4c00ee13 100644
--- a/tests/monster_test_suffix/monster_test_suffix.hpp
+++ b/tests/monster_test_suffix/monster_test_suffix.hpp
@@ -383,8 +383,10 @@ inline bool operator!=(const AnyUnion &lhs, const AnyUnion &rhs) {
     return !(lhs == rhs);
 }
 
-bool VerifyAny(::flatbuffers::Verifier &verifier, const void *obj, Any type);
-bool VerifyAnyVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
+template <bool TrackBufferSize = false>
+bool VerifyAny(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Any type);
+template <bool TrackBufferSize = false>
+bool VerifyAnyVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
 
 enum AnyUniqueAliases : uint8_t {
   AnyUniqueAliases_NONE = 0,
@@ -539,8 +541,10 @@ inline bool operator!=(const AnyUniqueAliasesUnion &lhs, const AnyUniqueAliasesU
     return !(lhs == rhs);
 }
 
-bool VerifyAnyUniqueAliases(::flatbuffers::Verifier &verifier, const void *obj, AnyUniqueAliases type);
-bool VerifyAnyUniqueAliasesVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
+template <bool TrackBufferSize = false>
+bool VerifyAnyUniqueAliases(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, AnyUniqueAliases type);
+template <bool TrackBufferSize = false>
+bool VerifyAnyUniqueAliasesVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
 
 enum AnyAmbiguousAliases : uint8_t {
   AnyAmbiguousAliases_NONE = 0,
@@ -653,8 +657,10 @@ inline bool operator!=(const AnyAmbiguousAliasesUnion &lhs, const AnyAmbiguousAl
     return !(lhs == rhs);
 }
 
-bool VerifyAnyAmbiguousAliases(::flatbuffers::Verifier &verifier, const void *obj, AnyAmbiguousAliases type);
-bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
+template <bool TrackBufferSize = false>
+bool VerifyAnyAmbiguousAliases(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, AnyAmbiguousAliases type);
+template <bool TrackBufferSize = false>
+bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
 
 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(2) Test FLATBUFFERS_FINAL_CLASS {
  private:
@@ -949,7 +955,8 @@ struct InParentNamespace FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
   static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
     return InParentNamespaceTypeTable();
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            verifier.EndTable();
   }
@@ -993,7 +1000,8 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
     return MonsterTypeTable();
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            verifier.EndTable();
   }
@@ -1049,7 +1057,8 @@ struct TestSimpleTableWithEnum FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::
   bool mutate_color(MyGame::Example::Color _color = static_cast<MyGame::Example::Color>(2)) {
     return SetField<uint8_t>(VT_COLOR, static_cast<uint8_t>(_color), 2);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint8_t>(verifier, VT_COLOR, 1) &&
            verifier.EndTable();
@@ -1129,7 +1138,8 @@ struct Stat FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   int KeyCompareWithValue(uint16_t _count) const {
     return static_cast<int>(count() > _count) - static_cast<int>(count() < _count);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_ID) &&
            verifier.VerifyString(id()) &&
@@ -1219,7 +1229,8 @@ struct Referrable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   int KeyCompareWithValue(uint64_t _id) const {
     return static_cast<int>(id() > _id) - static_cast<int>(id() < _id);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint64_t>(verifier, VT_ID, 8) &&
            verifier.EndTable();
@@ -1808,7 +1819,8 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   bool mutate_double_inf_default(double _double_inf_default = std::numeric_limits<double>::infinity()) {
     return SetField<double>(VT_DOUBLE_INF_DEFAULT, _double_inf_default, std::numeric_limits<double>::infinity());
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<MyGame::Example::Vec3>(verifier, VT_POS, 8) &&
            VerifyField<int16_t>(verifier, VT_MANA, 2) &&
@@ -1833,7 +1845,7 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
            verifier.VerifyTable(enemy()) &&
            VerifyOffset(verifier, VT_TESTNESTEDFLATBUFFER) &&
            verifier.VerifyVector(testnestedflatbuffer()) &&
-           verifier.VerifyNestedFlatBuffer<MyGame::Example::Monster>(testnestedflatbuffer(), nullptr) &&
+           verifier.template VerifyNestedFlatBuffer<MyGame::Example::Monster>(testnestedflatbuffer(), nullptr) &&
            VerifyOffset(verifier, VT_TESTEMPTY) &&
            verifier.VerifyTable(testempty()) &&
            VerifyField<uint8_t>(verifier, VT_TESTBOOL, 1) &&
@@ -1892,7 +1904,7 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
            VerifyField<int8_t>(verifier, VT_SIGNED_ENUM, 1) &&
            VerifyOffset(verifier, VT_TESTREQUIREDNESTEDFLATBUFFER) &&
            verifier.VerifyVector(testrequirednestedflatbuffer()) &&
-           verifier.VerifyNestedFlatBuffer<MyGame::Example::Monster>(testrequirednestedflatbuffer(), nullptr) &&
+           verifier.template VerifyNestedFlatBuffer<MyGame::Example::Monster>(testrequirednestedflatbuffer(), nullptr) &&
            VerifyOffset(verifier, VT_SCALAR_KEY_SORTED_TABLES) &&
            verifier.VerifyVector(scalar_key_sorted_tables()) &&
            verifier.VerifyVectorOfTables(scalar_key_sorted_tables()) &&
@@ -2524,7 +2536,8 @@ struct TypeAliases FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   ::flatbuffers::Vector<double> *mutable_vf64() {
     return GetPointer<::flatbuffers::Vector<double> *>(VT_VF64);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int8_t>(verifier, VT_I8, 1) &&
            VerifyField<uint8_t>(verifier, VT_U8, 1) &&
@@ -3338,7 +3351,8 @@ inline ::flatbuffers::Offset<TypeAliases> CreateTypeAliases(::flatbuffers::FlatB
       _vf64);
 }
 
-inline bool VerifyAny(::flatbuffers::Verifier &verifier, const void *obj, Any type) {
+template <bool TrackBufferSize>
+inline bool VerifyAny(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Any type) {
   switch (type) {
     case Any_NONE: {
       return true;
@@ -3359,7 +3373,8 @@ inline bool VerifyAny(::flatbuffers::Verifier &verifier, const void *obj, Any ty
   }
 }
 
-inline bool VerifyAnyVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
+template <bool TrackBufferSize>
+inline bool VerifyAnyVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@@ -3451,7 +3466,8 @@ inline void AnyUnion::Reset() {
   type = Any_NONE;
 }
 
-inline bool VerifyAnyUniqueAliases(::flatbuffers::Verifier &verifier, const void *obj, AnyUniqueAliases type) {
+template <bool TrackBufferSize>
+inline bool VerifyAnyUniqueAliases(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, AnyUniqueAliases type) {
   switch (type) {
     case AnyUniqueAliases_NONE: {
       return true;
@@ -3472,7 +3488,8 @@ inline bool VerifyAnyUniqueAliases(::flatbuffers::Verifier &verifier, const void
   }
 }
 
-inline bool VerifyAnyUniqueAliasesVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
+template <bool TrackBufferSize>
+inline bool VerifyAnyUniqueAliasesVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@@ -3564,7 +3581,8 @@ inline void AnyUniqueAliasesUnion::Reset() {
   type = AnyUniqueAliases_NONE;
 }
 
-inline bool VerifyAnyAmbiguousAliases(::flatbuffers::Verifier &verifier, const void *obj, AnyAmbiguousAliases type) {
+template <bool TrackBufferSize>
+inline bool VerifyAnyAmbiguousAliases(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, AnyAmbiguousAliases type) {
   switch (type) {
     case AnyAmbiguousAliases_NONE: {
       return true;
@@ -3585,7 +3603,8 @@ inline bool VerifyAnyAmbiguousAliases(::flatbuffers::Verifier &verifier, const v
   }
 }
 
-inline bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
+template <bool TrackBufferSize>
+inline bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@@ -4194,14 +4213,16 @@ inline bool SizePrefixedMonsterBufferHasIdentifier(const void *buf) {
       buf, MonsterIdentifier(), true);
 }
 
+template <bool TrackBufferSize = false>
 inline bool VerifyMonsterBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifyBuffer<MyGame::Example::Monster>(MonsterIdentifier());
+    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+  return verifier.template VerifyBuffer<MyGame::Example::Monster>(MonsterIdentifier());
 }
 
+template <bool TrackBufferSize = false>
 inline bool VerifySizePrefixedMonsterBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifySizePrefixedBuffer<MyGame::Example::Monster>(MonsterIdentifier());
+    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+  return verifier.template VerifySizePrefixedBuffer<MyGame::Example::Monster>(MonsterIdentifier());
 }
 
 inline const char *MonsterExtension() {
diff --git a/tests/namespace_test/namespace_test1_generated.h b/tests/namespace_test/namespace_test1_generated.h
index 8cf5ab114af..f5cb316b7c3 100644
--- a/tests/namespace_test/namespace_test1_generated.h
+++ b/tests/namespace_test/namespace_test1_generated.h
@@ -138,8 +138,10 @@ inline bool operator!=(const UnionInNestedNSUnion &lhs, const UnionInNestedNSUni
     return !(lhs == rhs);
 }
 
-bool VerifyUnionInNestedNS(::flatbuffers::Verifier &verifier, const void *obj, UnionInNestedNS type);
-bool VerifyUnionInNestedNSVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
+template <bool TrackBufferSize = false>
+bool VerifyUnionInNestedNS(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, UnionInNestedNS type);
+template <bool TrackBufferSize = false>
+bool VerifyUnionInNestedNSVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
 
 enum EnumInNestedNS : int8_t {
   EnumInNestedNS_A = 0,
@@ -246,7 +248,8 @@ struct TableInNestedNS FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   bool mutate_foo(int32_t _foo = 0) {
     return SetField<int32_t>(VT_FOO, _foo, 0);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int32_t>(verifier, VT_FOO, 4) &&
            verifier.EndTable();
@@ -321,7 +324,8 @@ inline ::flatbuffers::Offset<TableInNestedNS> CreateTableInNestedNS(::flatbuffer
       _foo);
 }
 
-inline bool VerifyUnionInNestedNS(::flatbuffers::Verifier &verifier, const void *obj, UnionInNestedNS type) {
+template <bool TrackBufferSize>
+inline bool VerifyUnionInNestedNS(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, UnionInNestedNS type) {
   switch (type) {
     case UnionInNestedNS_NONE: {
       return true;
@@ -334,7 +338,8 @@ inline bool VerifyUnionInNestedNS(::flatbuffers::Verifier &verifier, const void
   }
 }
 
-inline bool VerifyUnionInNestedNSVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
+template <bool TrackBufferSize>
+inline bool VerifyUnionInNestedNSVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
diff --git a/tests/namespace_test/namespace_test2_generated.h b/tests/namespace_test/namespace_test2_generated.h
index 5a5c8dde233..9a290ad4c0e 100644
--- a/tests/namespace_test/namespace_test2_generated.h
+++ b/tests/namespace_test/namespace_test2_generated.h
@@ -126,7 +126,8 @@ struct TableInFirstNS FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   NamespaceA::NamespaceB::StructInNestedNS *mutable_foo_struct() {
     return GetStruct<NamespaceA::NamespaceB::StructInNestedNS *>(VT_FOO_STRUCT);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_FOO_TABLE) &&
            verifier.VerifyTable(foo_table()) &&
@@ -236,7 +237,8 @@ struct TableInC FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   NamespaceA::SecondTableInA *mutable_refer_to_a2() {
     return GetPointer<NamespaceA::SecondTableInA *>(VT_REFER_TO_A2);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_REFER_TO_A1) &&
            verifier.VerifyTable(refer_to_a1()) &&
@@ -316,7 +318,8 @@ struct SecondTableInA FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   NamespaceC::TableInC *mutable_refer_to_c() {
     return GetPointer<NamespaceC::TableInC *>(VT_REFER_TO_C);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_REFER_TO_C) &&
            verifier.VerifyTable(refer_to_c()) &&
diff --git a/tests/native_inline_table_test_generated.h b/tests/native_inline_table_test_generated.h
index 29d33760320..fb1b96682ef 100644
--- a/tests/native_inline_table_test_generated.h
+++ b/tests/native_inline_table_test_generated.h
@@ -50,7 +50,8 @@ struct NativeInlineTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
   bool mutate_a(int32_t _a = 0) {
     return SetField<int32_t>(VT_A, _a, 0);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int32_t>(verifier, VT_A, 4) &&
            verifier.EndTable();
@@ -108,7 +109,8 @@ struct TestNativeInlineTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Ta
   ::flatbuffers::Vector<::flatbuffers::Offset<NativeInlineTable>> *mutable_t() {
     return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<NativeInlineTable>> *>(VT_T);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_T) &&
            verifier.VerifyVector(t()) &&
diff --git a/tests/native_type_test_generated.h b/tests/native_type_test_generated.h
index 608c8d45b52..188d6e6cded 100644
--- a/tests/native_type_test_generated.h
+++ b/tests/native_type_test_generated.h
@@ -161,7 +161,8 @@ struct ApplicationData FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   Geometry::Vector3D *mutable_position_inline() {
     return GetStruct<Geometry::Vector3D *>(VT_POSITION_INLINE);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_VECTORS) &&
            verifier.VerifyVector(vectors()) &&
@@ -360,14 +361,16 @@ inline Geometry::ApplicationData *GetMutableSizePrefixedApplicationData(void *bu
   return ::flatbuffers::GetMutableSizePrefixedRoot<Geometry::ApplicationData>(buf);
 }
 
+template <bool TrackBufferSize = false>
 inline bool VerifyApplicationDataBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifyBuffer<Geometry::ApplicationData>(nullptr);
+    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+  return verifier.template VerifyBuffer<Geometry::ApplicationData>(nullptr);
 }
 
+template <bool TrackBufferSize = false>
 inline bool VerifySizePrefixedApplicationDataBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifySizePrefixedBuffer<Geometry::ApplicationData>(nullptr);
+    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+  return verifier.template VerifySizePrefixedBuffer<Geometry::ApplicationData>(nullptr);
 }
 
 inline void FinishApplicationDataBuffer(
diff --git a/tests/optional_scalars_generated.h b/tests/optional_scalars_generated.h
index 2577248b0f2..21d63aaa159 100644
--- a/tests/optional_scalars_generated.h
+++ b/tests/optional_scalars_generated.h
@@ -357,7 +357,8 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   bool mutate_default_enum(optional_scalars::OptionalByte _default_enum = static_cast<optional_scalars::OptionalByte>(1)) {
     return SetField<int8_t>(VT_DEFAULT_ENUM, static_cast<int8_t>(_default_enum), 1);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int8_t>(verifier, VT_JUST_I8, 1) &&
            VerifyField<int8_t>(verifier, VT_MAYBE_I8, 1) &&
@@ -918,14 +919,16 @@ inline bool SizePrefixedScalarStuffBufferHasIdentifier(const void *buf) {
       buf, ScalarStuffIdentifier(), true);
 }
 
+template <bool TrackBufferSize = false>
 inline bool VerifyScalarStuffBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifyBuffer<optional_scalars::ScalarStuff>(ScalarStuffIdentifier());
+    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+  return verifier.template VerifyBuffer<optional_scalars::ScalarStuff>(ScalarStuffIdentifier());
 }
 
+template <bool TrackBufferSize = false>
 inline bool VerifySizePrefixedScalarStuffBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifySizePrefixedBuffer<optional_scalars::ScalarStuff>(ScalarStuffIdentifier());
+    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+  return verifier.template VerifySizePrefixedBuffer<optional_scalars::ScalarStuff>(ScalarStuffIdentifier());
 }
 
 inline const char *ScalarStuffExtension() {
diff --git a/tests/test.cpp b/tests/test.cpp
index c499ece1d20..eacc8478f4a 100644
--- a/tests/test.cpp
+++ b/tests/test.cpp
@@ -1254,6 +1254,35 @@ void NestedVerifierTest() {
   }
 }
 
+void SizeVerifierTest() {
+  // Create a monster.
+  flatbuffers::FlatBufferBuilder builder;
+  FinishMonsterBuffer(builder,
+                      CreateMonster(builder, nullptr, 0, 0,
+                                    builder.CreateString("NestedMonster")));
+  size_t length = builder.GetSize();
+  const uint8_t* data = builder.GetBufferPointer();
+
+  // Verify the monster, using SizeVerifier.
+  // We verify in several ways, using several different API functions/methods,
+  // to ensure that all of these APIs are tested.
+  flatbuffers::SizeVerifier size_verifier(data,
+                                          FLATBUFFERS_MAX_BUFFER_SIZE - 1);
+  {
+    TEST_EQ(true, VerifyMonsterBuffer(size_verifier));
+  }
+  {
+    TEST_EQ(true, size_verifier.VerifyBuffer<Monster>());
+  }
+  {
+    const MyGame::Example::Monster* my_buffer = GetMonster(data);
+    TEST_EQ(true, my_buffer->Verify(size_verifier));
+  }
+
+  // Verify that the size verifier computed the correct size.
+  TEST_EQ(length, size_verifier.GetComputedSize());
+}
+
 template <class T, class Container>
 void TestIterators(const std::vector<T>& expected, const Container& tested) {
   TEST_ASSERT(tested.rbegin().base() == tested.end());
@@ -1725,6 +1754,7 @@ int FlatBufferTests(const std::string& tests_data_path) {
   FlatbuffersIteratorsTest();
   WarningsAsErrorsTest();
   NestedVerifierTest();
+  SizeVerifierTest();
   PrivateAnnotationsLeaks();
   JsonUnsortedArrayTest();
   VectorSpanTest();
diff --git a/tests/union_underlying_type_test_generated.h b/tests/union_underlying_type_test_generated.h
index 541cdf716f1..8f131ab6dff 100644
--- a/tests/union_underlying_type_test_generated.h
+++ b/tests/union_underlying_type_test_generated.h
@@ -194,8 +194,10 @@ inline bool operator!=(const ABCUnion &lhs, const ABCUnion &rhs) {
     return !(lhs == rhs);
 }
 
-bool VerifyABC(::flatbuffers::Verifier &verifier, const void *obj, ABC type);
-bool VerifyABCVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<ABC> *types);
+template <bool TrackBufferSize = false>
+bool VerifyABC(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, ABC type);
+template <bool TrackBufferSize = false>
+bool VerifyABCVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<ABC> *types);
 
 struct AT : public ::flatbuffers::NativeTable {
   typedef A TableType;
@@ -217,7 +219,8 @@ struct A FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   bool mutate_a(int32_t _a = 0) {
     return SetField<int32_t>(VT_A, _a, 0);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int32_t>(verifier, VT_A, 4) &&
            verifier.EndTable();
@@ -275,7 +278,8 @@ struct B FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   ::flatbuffers::String *mutable_b() {
     return GetPointer<::flatbuffers::String *>(VT_B);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_B) &&
            verifier.VerifyString(b()) &&
@@ -343,7 +347,8 @@ struct C FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   bool mutate_c(bool _c = 0) {
     return SetField<uint8_t>(VT_C, static_cast<uint8_t>(_c), 0);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint8_t>(verifier, VT_C, 1) &&
            verifier.EndTable();
@@ -430,7 +435,8 @@ struct D FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   ::flatbuffers::Vector<::flatbuffers::Offset<void>> *mutable_test_vector_of_union() {
     return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<void>> *>(VT_TEST_VECTOR_OF_UNION);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int32_t>(verifier, VT_TEST_UNION_TYPE, 1) &&
            VerifyOffset(verifier, VT_TEST_UNION) &&
@@ -676,7 +682,8 @@ inline ::flatbuffers::Offset<D> CreateD(::flatbuffers::FlatBufferBuilder &_fbb,
       _test_vector_of_union);
 }
 
-inline bool VerifyABC(::flatbuffers::Verifier &verifier, const void *obj, ABC type) {
+template <bool TrackBufferSize>
+inline bool VerifyABC(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, ABC type) {
   switch (type) {
     case ABC::NONE: {
       return true;
@@ -697,7 +704,8 @@ inline bool VerifyABC(::flatbuffers::Verifier &verifier, const void *obj, ABC ty
   }
 }
 
-inline bool VerifyABCVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<ABC> *types) {
+template <bool TrackBufferSize>
+inline bool VerifyABCVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<ABC> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
diff --git a/tests/union_vector/union_vector_generated.h b/tests/union_vector/union_vector_generated.h
index c337abfd177..84e724f3cdd 100644
--- a/tests/union_vector/union_vector_generated.h
+++ b/tests/union_vector/union_vector_generated.h
@@ -212,8 +212,10 @@ inline bool operator!=(const CharacterUnion &lhs, const CharacterUnion &rhs) {
     return !(lhs == rhs);
 }
 
-bool VerifyCharacter(::flatbuffers::Verifier &verifier, const void *obj, Character type);
-bool VerifyCharacterVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
+template <bool TrackBufferSize = false>
+bool VerifyCharacter(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Character type);
+template <bool TrackBufferSize = false>
+bool VerifyCharacterVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
 
 enum Gadget : uint8_t {
   Gadget_NONE = 0,
@@ -345,8 +347,10 @@ inline bool operator!=(const GadgetUnion &lhs, const GadgetUnion &rhs) {
     return !(lhs == rhs);
 }
 
-bool VerifyGadget(::flatbuffers::Verifier &verifier, const void *obj, Gadget type);
-bool VerifyGadgetVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
+template <bool TrackBufferSize = false>
+bool VerifyGadget(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Gadget type);
+template <bool TrackBufferSize = false>
+bool VerifyGadgetVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
 
 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Rapunzel FLATBUFFERS_FINAL_CLASS {
  private:
@@ -467,7 +471,8 @@ struct Attacker FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   bool mutate_sword_attack_damage(int32_t _sword_attack_damage = 0) {
     return SetField<int32_t>(VT_SWORD_ATTACK_DAMAGE, _sword_attack_damage, 0);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int32_t>(verifier, VT_SWORD_ATTACK_DAMAGE, 4) &&
            verifier.EndTable();
@@ -525,7 +530,8 @@ struct HandFan FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   bool mutate_length(int32_t _length = 0) {
     return SetField<int32_t>(VT_LENGTH, _length, 0);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int32_t>(verifier, VT_LENGTH, 4) &&
            verifier.EndTable();
@@ -620,7 +626,8 @@ struct Movie FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   ::flatbuffers::Vector<::flatbuffers::Offset<void>> *mutable_characters() {
     return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<void>> *>(VT_CHARACTERS);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool TrackBufferSize = false>
+  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint8_t>(verifier, VT_MAIN_CHARACTER_TYPE, 1) &&
            VerifyOffset(verifier, VT_MAIN_CHARACTER) &&
@@ -817,7 +824,8 @@ inline ::flatbuffers::Offset<Movie> CreateMovie(::flatbuffers::FlatBufferBuilder
       _characters);
 }
 
-inline bool VerifyCharacter(::flatbuffers::Verifier &verifier, const void *obj, Character type) {
+template <bool TrackBufferSize>
+inline bool VerifyCharacter(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Character type) {
   switch (type) {
     case Character_NONE: {
       return true;
@@ -827,13 +835,13 @@ inline bool VerifyCharacter(::flatbuffers::Verifier &verifier, const void *obj,
       return verifier.VerifyTable(ptr);
     }
     case Character_Rapunzel: {
-      return verifier.VerifyField<Rapunzel>(static_cast<const uint8_t *>(obj), 0, 4);
+      return verifier.template VerifyField<Rapunzel>(static_cast<const uint8_t *>(obj), 0, 4);
     }
     case Character_Belle: {
-      return verifier.VerifyField<BookReader>(static_cast<const uint8_t *>(obj), 0, 4);
+      return verifier.template VerifyField<BookReader>(static_cast<const uint8_t *>(obj), 0, 4);
     }
     case Character_BookFan: {
-      return verifier.VerifyField<BookReader>(static_cast<const uint8_t *>(obj), 0, 4);
+      return verifier.template VerifyField<BookReader>(static_cast<const uint8_t *>(obj), 0, 4);
     }
     case Character_Other: {
       auto ptr = reinterpret_cast<const ::flatbuffers::String *>(obj);
@@ -847,7 +855,8 @@ inline bool VerifyCharacter(::flatbuffers::Verifier &verifier, const void *obj,
   }
 }
 
-inline bool VerifyCharacterVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
+template <bool TrackBufferSize>
+inline bool VerifyCharacterVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@@ -990,13 +999,14 @@ inline void CharacterUnion::Reset() {
   type = Character_NONE;
 }
 
-inline bool VerifyGadget(::flatbuffers::Verifier &verifier, const void *obj, Gadget type) {
+template <bool TrackBufferSize>
+inline bool VerifyGadget(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Gadget type) {
   switch (type) {
     case Gadget_NONE: {
       return true;
     }
     case Gadget_FallingTub: {
-      return verifier.VerifyField<FallingTub>(static_cast<const uint8_t *>(obj), 0, 4);
+      return verifier.template VerifyField<FallingTub>(static_cast<const uint8_t *>(obj), 0, 4);
     }
     case Gadget_HandFan: {
       auto ptr = reinterpret_cast<const HandFan *>(obj);
@@ -1006,7 +1016,8 @@ inline bool VerifyGadget(::flatbuffers::Verifier &verifier, const void *obj, Gad
   }
 }
 
-inline bool VerifyGadgetVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
+template <bool TrackBufferSize>
+inline bool VerifyGadgetVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@@ -1252,14 +1263,16 @@ inline bool SizePrefixedMovieBufferHasIdentifier(const void *buf) {
       buf, MovieIdentifier(), true);
 }
 
+template <bool TrackBufferSize = false>
 inline bool VerifyMovieBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifyBuffer<Movie>(MovieIdentifier());
+    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+  return verifier.template VerifyBuffer<Movie>(MovieIdentifier());
 }
 
+template <bool TrackBufferSize = false>
 inline bool VerifySizePrefixedMovieBuffer(
-    ::flatbuffers::Verifier &verifier) {
-  return verifier.VerifySizePrefixedBuffer<Movie>(MovieIdentifier());
+    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+  return verifier.template VerifySizePrefixedBuffer<Movie>(MovieIdentifier());
 }
 
 inline void FinishMovieBuffer(

From 796c7dbd1f54250561f6d67d9efa1e81dccd2a7e Mon Sep 17 00:00:00 2001
From: Fergus Henderson <fergus@google.com>
Date: Mon, 27 Oct 2025 18:56:19 +0000
Subject: [PATCH 2/4] Format using `sh scripts/clang-format-git.sh`

---
 src/idl_gen_cpp.cpp | 3 ++-
 src/idl_parser.cpp  | 4 ++--
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/idl_gen_cpp.cpp b/src/idl_gen_cpp.cpp
index 7f245947565..7eb2bb3956c 100644
--- a/src/idl_gen_cpp.cpp
+++ b/src/idl_gen_cpp.cpp
@@ -1098,7 +1098,8 @@ class CppGenerator : public BaseGenerator {
     return "template <bool TrackBufferSize = false>";
   }
 
-  // For the subsequent definition, we must not redeclare the template default arguments.
+  // For the subsequent definition, we must not redeclare the template default
+  // arguments.
   std::string UnionVerifyTemplateDef() {
     return "template <bool TrackBufferSize>";
   }
diff --git a/src/idl_parser.cpp b/src/idl_parser.cpp
index 24555aec48e..57a25189b9a 100644
--- a/src/idl_parser.cpp
+++ b/src/idl_parser.cpp
@@ -4352,8 +4352,8 @@ bool Parser::Deserialize(const uint8_t* buf, const size_t size) {
       size_prefixed = true;
   }
   auto verify_fn = size_prefixed
-      ? &reflection::VerifySizePrefixedSchemaBuffer<false>
-      : &reflection::VerifySchemaBuffer<false>;
+                       ? &reflection::VerifySizePrefixedSchemaBuffer<false>
+                       : &reflection::VerifySchemaBuffer<false>;
   if (!verify_fn(verifier)) {
     return false;
   }

From 38736a546ffa038523319b4ab6c520f9d3e67428 Mon Sep 17 00:00:00 2001
From: Fergus Henderson <fergus@google.com>
Date: Mon, 10 Nov 2025 13:59:29 +0000
Subject: [PATCH 3/4] Use `B` rather than `TrackBufferSize` for the name of the
 template parameter.

---
 goldens/cpp/basic_generated.h                 | 16 ++--
 include/flatbuffers/flex_flat_util.h          |  4 +-
 include/flatbuffers/reflection_generated.h    | 48 +++++------
 include/flatbuffers/table.h                   | 32 +++----
 samples/monster_generated.h                   | 32 +++----
 src/idl_gen_cpp.cpp                           | 26 +++---
 tests/64bit/evolution/v1_generated.h          | 12 +--
 tests/64bit/evolution/v2_generated.h          | 12 +--
 tests/64bit/test_64bit_generated.h            | 16 ++--
 .../generated_cpp17/monster_test_generated.h  | 84 +++++++++----------
 .../optional_scalars_generated.h              | 12 +--
 .../generated_cpp17/union_vector_generated.h  | 52 ++++++------
 tests/evolution_test/evolution_v1_generated.h | 36 ++++----
 tests/evolution_test/evolution_v2_generated.h | 40 ++++-----
 tests/key_field/key_field_sample_generated.h  | 12 +--
 tests/monster_extra_generated.h               | 12 +--
 tests/monster_test_generated.h                | 84 +++++++++----------
 .../ext_only/monster_test_generated.hpp       | 84 +++++++++----------
 .../filesuffix_only/monster_test_suffix.h     | 84 +++++++++----------
 .../monster_test_suffix.hpp                   | 84 +++++++++----------
 .../namespace_test1_generated.h               | 20 ++---
 .../namespace_test2_generated.h               | 12 +--
 tests/native_inline_table_test_generated.h    |  8 +-
 tests/native_type_test_generated.h            | 12 +--
 tests/optional_scalars_generated.h            | 12 +--
 tests/union_underlying_type_test_generated.h  | 32 +++----
 tests/union_vector/union_vector_generated.h   | 52 ++++++------
 27 files changed, 462 insertions(+), 468 deletions(-)

diff --git a/goldens/cpp/basic_generated.h b/goldens/cpp/basic_generated.h
index 7304b382acf..f0fd80258f3 100644
--- a/goldens/cpp/basic_generated.h
+++ b/goldens/cpp/basic_generated.h
@@ -30,8 +30,8 @@ struct Galaxy FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   int64_t num_stars() const {
     return GetField<int64_t>(VT_NUM_STARS, 0);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int64_t>(verifier, VT_NUM_STARS, 8) &&
            verifier.EndTable();
@@ -76,8 +76,8 @@ struct Universe FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const ::flatbuffers::Vector<::flatbuffers::Offset<flatbuffers::goldens::Galaxy>> *galaxies() const {
     return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<flatbuffers::goldens::Galaxy>> *>(VT_GALAXIES);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<double>(verifier, VT_AGE, 8) &&
            VerifyOffset(verifier, VT_GALAXIES) &&
@@ -137,15 +137,15 @@ inline const flatbuffers::goldens::Universe *GetSizePrefixedUniverse(const void
   return ::flatbuffers::GetSizePrefixedRoot<flatbuffers::goldens::Universe>(buf);
 }
 
-template <bool TrackBufferSize = false>
+template <bool B = false>
 inline bool VerifyUniverseBuffer(
-    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
   return verifier.template VerifyBuffer<flatbuffers::goldens::Universe>(nullptr);
 }
 
-template <bool TrackBufferSize = false>
+template <bool B = false>
 inline bool VerifySizePrefixedUniverseBuffer(
-    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
   return verifier.template VerifySizePrefixedBuffer<flatbuffers::goldens::Universe>(nullptr);
 }
 
diff --git a/include/flatbuffers/flex_flat_util.h b/include/flatbuffers/flex_flat_util.h
index 4b4b8f8fb91..70c0a45860b 100644
--- a/include/flatbuffers/flex_flat_util.h
+++ b/include/flatbuffers/flex_flat_util.h
@@ -23,10 +23,10 @@
 namespace flexbuffers {
 
 // Verifies the `nested` flexbuffer within a flatbuffer vector is valid.
-template <bool TrackBufferSize>
+template <bool B>
 inline bool VerifyNestedFlexBuffer(
     const flatbuffers::Vector<uint8_t>* const nested,
-    flatbuffers::VerifierTemplate<TrackBufferSize>& verifier) {
+    flatbuffers::VerifierTemplate<B>& verifier) {
   if (!nested) return true;
   return verifier.Check(flexbuffers::VerifyBuffer(
       nested->data(), nested->size(), verifier.GetFlexReuseTracker()));
diff --git a/include/flatbuffers/reflection_generated.h b/include/flatbuffers/reflection_generated.h
index 0c24320d7c0..9a9ed6b9b2b 100644
--- a/include/flatbuffers/reflection_generated.h
+++ b/include/flatbuffers/reflection_generated.h
@@ -196,8 +196,8 @@ struct Type FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   uint32_t element_size() const {
     return GetField<uint32_t>(VT_ELEMENT_SIZE, 0);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int8_t>(verifier, VT_BASE_TYPE, 1) &&
            VerifyField<int8_t>(verifier, VT_ELEMENT, 1) &&
@@ -284,8 +284,8 @@ struct KeyValue FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const ::flatbuffers::String *value() const {
     return GetPointer<const ::flatbuffers::String *>(VT_VALUE);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffsetRequired(verifier, VT_KEY) &&
            verifier.VerifyString(key()) &&
@@ -369,8 +369,8 @@ struct EnumVal FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *attributes() const {
     return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::KeyValue>> *>(VT_ATTRIBUTES);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffsetRequired(verifier, VT_NAME) &&
            verifier.VerifyString(name()) &&
@@ -498,8 +498,8 @@ struct Enum FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const ::flatbuffers::String *declaration_file() const {
     return GetPointer<const ::flatbuffers::String *>(VT_DECLARATION_FILE);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffsetRequired(verifier, VT_NAME) &&
            verifier.VerifyString(name()) &&
@@ -679,8 +679,8 @@ struct Field FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   bool offset64() const {
     return GetField<uint8_t>(VT_OFFSET64, 0) != 0;
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffsetRequired(verifier, VT_NAME) &&
            verifier.VerifyString(name()) &&
@@ -885,8 +885,8 @@ struct Object FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const ::flatbuffers::String *declaration_file() const {
     return GetPointer<const ::flatbuffers::String *>(VT_DECLARATION_FILE);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffsetRequired(verifier, VT_NAME) &&
            verifier.VerifyString(name()) &&
@@ -1034,8 +1034,8 @@ struct RPCCall FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *documentation() const {
     return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_DOCUMENTATION);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffsetRequired(verifier, VT_NAME) &&
            verifier.VerifyString(name()) &&
@@ -1158,8 +1158,8 @@ struct Service FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const ::flatbuffers::String *declaration_file() const {
     return GetPointer<const ::flatbuffers::String *>(VT_DECLARATION_FILE);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffsetRequired(verifier, VT_NAME) &&
            verifier.VerifyString(name()) &&
@@ -1275,8 +1275,8 @@ struct SchemaFile FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *included_filenames() const {
     return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_INCLUDED_FILENAMES);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffsetRequired(verifier, VT_FILENAME) &&
            verifier.VerifyString(filename()) &&
@@ -1369,8 +1369,8 @@ struct Schema FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::SchemaFile>> *fbs_files() const {
     return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<reflection::SchemaFile>> *>(VT_FBS_FILES);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffsetRequired(verifier, VT_OBJECTS) &&
            verifier.VerifyVector(objects()) &&
@@ -1508,15 +1508,15 @@ inline bool SizePrefixedSchemaBufferHasIdentifier(const void *buf) {
       buf, SchemaIdentifier(), true);
 }
 
-template <bool TrackBufferSize = false>
+template <bool B = false>
 inline bool VerifySchemaBuffer(
-    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
   return verifier.template VerifyBuffer<reflection::Schema>(SchemaIdentifier());
 }
 
-template <bool TrackBufferSize = false>
+template <bool B = false>
 inline bool VerifySizePrefixedSchemaBuffer(
-    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
   return verifier.template VerifySizePrefixedBuffer<reflection::Schema>(SchemaIdentifier());
 }
 
diff --git a/include/flatbuffers/table.h b/include/flatbuffers/table.h
index 535d9c1fc48..0149216ff43 100644
--- a/include/flatbuffers/table.h
+++ b/include/flatbuffers/table.h
@@ -122,15 +122,15 @@ class Table {
 
   // Verify the vtable of this table.
   // Call this once per table, followed by VerifyField once per field.
-  template <bool TrackBufferSize>
-  bool VerifyTableStart(VerifierTemplate<TrackBufferSize>& verifier) const {
+  template <bool B>
+  bool VerifyTableStart(VerifierTemplate<B>& verifier) const {
     return verifier.VerifyTableStart(data_);
   }
 
   // Verify a particular field.
-  template <typename T, bool TrackBufferSize>
-  bool VerifyField(const VerifierTemplate<TrackBufferSize>& verifier,
-                   voffset_t field, size_t align) const {
+  template <typename T, bool B>
+  bool VerifyField(const VerifierTemplate<B>& verifier, voffset_t field,
+                   size_t align) const {
     // Calling GetOptionalFieldOffset should be safe now thanks to
     // VerifyTable().
     auto field_offset = GetOptionalFieldOffset(field);
@@ -140,39 +140,39 @@ class Table {
   }
 
   // VerifyField for required fields.
-  template <typename T, bool TrackBufferSize>
-  bool VerifyFieldRequired(const VerifierTemplate<TrackBufferSize>& verifier,
-                           voffset_t field, size_t align) const {
+  template <typename T, bool B>
+  bool VerifyFieldRequired(const VerifierTemplate<B>& verifier, voffset_t field,
+                           size_t align) const {
     auto field_offset = GetOptionalFieldOffset(field);
     return verifier.Check(field_offset != 0) &&
            verifier.template VerifyField<T>(data_, field_offset, align);
   }
 
   // Versions for offsets.
-  template <typename OffsetT = uoffset_t, bool TrackBufferSize = false>
-  bool VerifyOffset(const VerifierTemplate<TrackBufferSize>& verifier,
+  template <typename OffsetT = uoffset_t, bool B = false>
+  bool VerifyOffset(const VerifierTemplate<B>& verifier,
                     voffset_t field) const {
     auto field_offset = GetOptionalFieldOffset(field);
     return !field_offset ||
            verifier.template VerifyOffset<OffsetT>(data_, field_offset);
   }
 
-  template <typename OffsetT = uoffset_t, bool TrackBufferSize = false>
-  bool VerifyOffsetRequired(const VerifierTemplate<TrackBufferSize>& verifier,
+  template <typename OffsetT = uoffset_t, bool B = false>
+  bool VerifyOffsetRequired(const VerifierTemplate<B>& verifier,
                             voffset_t field) const {
     auto field_offset = GetOptionalFieldOffset(field);
     return verifier.Check(field_offset != 0) &&
            verifier.template VerifyOffset<OffsetT>(data_, field_offset);
   }
 
-  template <bool TrackBufferSize>
-  bool VerifyOffset64(const VerifierTemplate<TrackBufferSize>& verifier,
+  template <bool B>
+  bool VerifyOffset64(const VerifierTemplate<B>& verifier,
                       voffset_t field) const {
     return VerifyOffset<uoffset64_t>(verifier, field);
   }
 
-  template <bool TrackBufferSize>
-  bool VerifyOffset64Required(const VerifierTemplate<TrackBufferSize>& verifier,
+  template <bool B>
+  bool VerifyOffset64Required(const VerifierTemplate<B>& verifier,
                               voffset_t field) const {
     return VerifyOffsetRequired<uoffset64_t>(verifier, field);
   }
diff --git a/samples/monster_generated.h b/samples/monster_generated.h
index 461abf2ef42..a0facac9603 100644
--- a/samples/monster_generated.h
+++ b/samples/monster_generated.h
@@ -179,10 +179,10 @@ inline bool operator!=(const EquipmentUnion &lhs, const EquipmentUnion &rhs) {
     return !(lhs == rhs);
 }
 
-template <bool TrackBufferSize = false>
-bool VerifyEquipment(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Equipment type);
-template <bool TrackBufferSize = false>
-bool VerifyEquipmentVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
+template <bool B = false>
+bool VerifyEquipment(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, Equipment type);
+template <bool B = false>
+bool VerifyEquipmentVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
 
 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Vec3 FLATBUFFERS_FINAL_CLASS {
  private:
@@ -333,8 +333,8 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   ::flatbuffers::Vector<const MyGame::Sample::Vec3 *> *mutable_path() {
     return GetPointer<::flatbuffers::Vector<const MyGame::Sample::Vec3 *> *>(VT_PATH);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<MyGame::Sample::Vec3>(verifier, VT_POS, 4) &&
            VerifyField<int16_t>(verifier, VT_MANA, 2) &&
@@ -494,8 +494,8 @@ struct Weapon FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   bool mutate_damage(int16_t _damage = 0) {
     return SetField<int16_t>(VT_DAMAGE, _damage, 0);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_NAME) &&
            verifier.VerifyString(name()) &&
@@ -690,8 +690,8 @@ inline ::flatbuffers::Offset<Weapon> Weapon::Pack(::flatbuffers::FlatBufferBuild
       _damage);
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyEquipment(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Equipment type) {
+template <bool B>
+inline bool VerifyEquipment(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, Equipment type) {
   switch (type) {
     case Equipment_NONE: {
       return true;
@@ -704,8 +704,8 @@ inline bool VerifyEquipment(::flatbuffers::VerifierTemplate<TrackBufferSize> &ve
   }
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyEquipmentVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
+template <bool B>
+inline bool VerifyEquipmentVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@@ -889,15 +889,15 @@ inline MyGame::Sample::Monster *GetMutableSizePrefixedMonster(void *buf) {
   return ::flatbuffers::GetMutableSizePrefixedRoot<MyGame::Sample::Monster>(buf);
 }
 
-template <bool TrackBufferSize = false>
+template <bool B = false>
 inline bool VerifyMonsterBuffer(
-    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
   return verifier.template VerifyBuffer<MyGame::Sample::Monster>(nullptr);
 }
 
-template <bool TrackBufferSize = false>
+template <bool B = false>
 inline bool VerifySizePrefixedMonsterBuffer(
-    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
   return verifier.template VerifySizePrefixedBuffer<MyGame::Sample::Monster>(nullptr);
 }
 
diff --git a/src/idl_gen_cpp.cpp b/src/idl_gen_cpp.cpp
index d8ba6cf5abf..d3441db4c0c 100644
--- a/src/idl_gen_cpp.cpp
+++ b/src/idl_gen_cpp.cpp
@@ -681,18 +681,16 @@ class CppGenerator : public BaseGenerator {
         code_.SetValue("ID", "nullptr");
       }
 
-      code_ += "template <bool TrackBufferSize = false>";
+      code_ += "template <bool B = false>";
       code_ += "inline bool Verify{{STRUCT_NAME}}Buffer(";
-      code_ +=
-          "    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {";
+      code_ += "    ::flatbuffers::VerifierTemplate<B> &verifier) {";
       code_ += "  return verifier.template VerifyBuffer<{{CPP_NAME}}>({{ID}});";
       code_ += "}";
       code_ += "";
 
-      code_ += "template <bool TrackBufferSize = false>";
+      code_ += "template <bool B = false>";
       code_ += "inline bool VerifySizePrefixed{{STRUCT_NAME}}Buffer(";
-      code_ +=
-          "    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {";
+      code_ += "    ::flatbuffers::VerifierTemplate<B> &verifier) {";
       code_ +=
           "  return "
           "verifier.template "
@@ -1109,21 +1107,17 @@ class CppGenerator : public BaseGenerator {
 
   // For the initial declaration, we specify the template parameters,
   // including template default arguments.
-  std::string UnionVerifyTemplateDecl() {
-    return "template <bool TrackBufferSize = false>";
-  }
+  std::string UnionVerifyTemplateDecl() { return "template <bool B = false>"; }
 
   // For the subsequent definition, we must not redeclare the template default
   // arguments.
-  std::string UnionVerifyTemplateDef() {
-    return "template <bool TrackBufferSize>";
-  }
+  std::string UnionVerifyTemplateDef() { return "template <bool B>"; }
 
   // Should be used in conjunction with
   // UnionVerifyTemplateDecl()/UnionVerifyTemplateDef().
   std::string UnionVerifySignature(const EnumDef& enum_def) {
     return "bool Verify" + Name(enum_def) +
-           "(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, " +
+           "(::flatbuffers::VerifierTemplate<B> &verifier, " +
            "const void *obj, " + Name(enum_def) + " type)";
   }
 
@@ -1135,7 +1129,7 @@ class CppGenerator : public BaseGenerator {
         opts_.scoped_enums ? name
                            : GenTypeBasic(enum_def.underlying_type, false);
     return "bool Verify" + name + "Vector" +
-           "(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, " +
+           "(::flatbuffers::VerifierTemplate<B> &verifier, " +
            "const ::flatbuffers::Vector<::flatbuffers::Offset<void>> "
            "*values, " +
            "const ::flatbuffers::Vector<" + type + "> *types)";
@@ -3026,9 +3020,9 @@ class CppGenerator : public BaseGenerator {
 
     // Generate a verifier function that can check a buffer from an untrusted
     // source will never cause reads outside the buffer.
-    code_ += "  template <bool TrackBufferSize = false>";
+    code_ += "  template <bool B = false>";
     code_ +=
-        "  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> "
+        "  bool Verify(::flatbuffers::VerifierTemplate<B> "
         "&verifier) const {";
     code_ += "    return VerifyTableStart(verifier)\\";
     for (const auto& field : struct_def.fields.vec) {
diff --git a/tests/64bit/evolution/v1_generated.h b/tests/64bit/evolution/v1_generated.h
index b9b8ed25f9f..a4222eb5d1e 100644
--- a/tests/64bit/evolution/v1_generated.h
+++ b/tests/64bit/evolution/v1_generated.h
@@ -52,8 +52,8 @@ struct RootTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   ::flatbuffers::Vector<uint8_t> *mutable_b() {
     return GetPointer<::flatbuffers::Vector<uint8_t> *>(VT_B);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<float>(verifier, VT_A, 4) &&
            VerifyOffset(verifier, VT_B) &&
@@ -181,15 +181,15 @@ inline v1::RootTable *GetMutableSizePrefixedRootTable(void *buf) {
   return ::flatbuffers::GetMutableSizePrefixedRoot<v1::RootTable>(buf);
 }
 
-template <bool TrackBufferSize = false>
+template <bool B = false>
 inline bool VerifyRootTableBuffer(
-    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
   return verifier.template VerifyBuffer<v1::RootTable>(nullptr);
 }
 
-template <bool TrackBufferSize = false>
+template <bool B = false>
 inline bool VerifySizePrefixedRootTableBuffer(
-    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
   return verifier.template VerifySizePrefixedBuffer<v1::RootTable>(nullptr);
 }
 
diff --git a/tests/64bit/evolution/v2_generated.h b/tests/64bit/evolution/v2_generated.h
index 00249ae65ab..ee618639d2f 100644
--- a/tests/64bit/evolution/v2_generated.h
+++ b/tests/64bit/evolution/v2_generated.h
@@ -60,8 +60,8 @@ struct RootTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   ::flatbuffers::Vector64<uint8_t> *mutable_big_vector() {
     return GetPointer64<::flatbuffers::Vector64<uint8_t> *>(VT_BIG_VECTOR);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<float>(verifier, VT_A, 4) &&
            VerifyOffset(verifier, VT_B) &&
@@ -205,15 +205,15 @@ inline v2::RootTable *GetMutableSizePrefixedRootTable(void *buf) {
   return ::flatbuffers::GetMutableSizePrefixedRoot<v2::RootTable,::flatbuffers::uoffset64_t>(buf);
 }
 
-template <bool TrackBufferSize = false>
+template <bool B = false>
 inline bool VerifyRootTableBuffer(
-    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
   return verifier.template VerifyBuffer<v2::RootTable>(nullptr);
 }
 
-template <bool TrackBufferSize = false>
+template <bool B = false>
 inline bool VerifySizePrefixedRootTableBuffer(
-    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
   return verifier.template VerifySizePrefixedBuffer<v2::RootTable,::flatbuffers::uoffset64_t>(nullptr);
 }
 
diff --git a/tests/64bit/test_64bit_generated.h b/tests/64bit/test_64bit_generated.h
index 2100e3743c9..4d669dc0bce 100644
--- a/tests/64bit/test_64bit_generated.h
+++ b/tests/64bit/test_64bit_generated.h
@@ -108,8 +108,8 @@ struct WrapperTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   ::flatbuffers::Vector<int8_t> *mutable_vector() {
     return GetPointer64<::flatbuffers::Vector<int8_t> *>(VT_VECTOR);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset64(verifier, VT_VECTOR) &&
            verifier.VerifyVector(vector()) &&
@@ -259,8 +259,8 @@ struct RootTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   ::flatbuffers::Vector64<uint8_t> *mutable_forced_aligned_vector() {
     return GetPointer64<::flatbuffers::Vector64<uint8_t> *>(VT_FORCED_ALIGNED_VECTOR);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset64(verifier, VT_FAR_VECTOR) &&
            verifier.VerifyVector(far_vector()) &&
@@ -618,15 +618,15 @@ inline RootTable *GetMutableSizePrefixedRootTable(void *buf) {
   return ::flatbuffers::GetMutableSizePrefixedRoot<RootTable,::flatbuffers::uoffset64_t>(buf);
 }
 
-template <bool TrackBufferSize = false>
+template <bool B = false>
 inline bool VerifyRootTableBuffer(
-    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
   return verifier.template VerifyBuffer<RootTable>(nullptr);
 }
 
-template <bool TrackBufferSize = false>
+template <bool B = false>
 inline bool VerifySizePrefixedRootTableBuffer(
-    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
   return verifier.template VerifySizePrefixedBuffer<RootTable,::flatbuffers::uoffset64_t>(nullptr);
 }
 
diff --git a/tests/cpp17/generated_cpp17/monster_test_generated.h b/tests/cpp17/generated_cpp17/monster_test_generated.h
index 1be5fa3a3f2..c056e38f49d 100644
--- a/tests/cpp17/generated_cpp17/monster_test_generated.h
+++ b/tests/cpp17/generated_cpp17/monster_test_generated.h
@@ -323,10 +323,10 @@ struct AnyUnion {
   }
 };
 
-template <bool TrackBufferSize = false>
-bool VerifyAny(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Any type);
-template <bool TrackBufferSize = false>
-bool VerifyAnyVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Any> *types);
+template <bool B = false>
+bool VerifyAny(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, Any type);
+template <bool B = false>
+bool VerifyAnyVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Any> *types);
 
 enum class AnyUniqueAliases : uint8_t {
   NONE = 0,
@@ -452,10 +452,10 @@ struct AnyUniqueAliasesUnion {
   }
 };
 
-template <bool TrackBufferSize = false>
-bool VerifyAnyUniqueAliases(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, AnyUniqueAliases type);
-template <bool TrackBufferSize = false>
-bool VerifyAnyUniqueAliasesVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<AnyUniqueAliases> *types);
+template <bool B = false>
+bool VerifyAnyUniqueAliases(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, AnyUniqueAliases type);
+template <bool B = false>
+bool VerifyAnyUniqueAliasesVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<AnyUniqueAliases> *types);
 
 enum class AnyAmbiguousAliases : uint8_t {
   NONE = 0,
@@ -539,10 +539,10 @@ struct AnyAmbiguousAliasesUnion {
   }
 };
 
-template <bool TrackBufferSize = false>
-bool VerifyAnyAmbiguousAliases(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, AnyAmbiguousAliases type);
-template <bool TrackBufferSize = false>
-bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<AnyAmbiguousAliases> *types);
+template <bool B = false>
+bool VerifyAnyAmbiguousAliases(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, AnyAmbiguousAliases type);
+template <bool B = false>
+bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<AnyAmbiguousAliases> *types);
 
 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(2) Test FLATBUFFERS_FINAL_CLASS {
  private:
@@ -887,8 +887,8 @@ struct InParentNamespace FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
   static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
     return InParentNamespaceTypeTable();
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            verifier.EndTable();
   }
@@ -942,8 +942,8 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
     return MonsterTypeTable();
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            verifier.EndTable();
   }
@@ -1014,8 +1014,8 @@ struct TestSimpleTableWithEnum FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::
          if constexpr (Index == 0) return color();
     else static_assert(Index != -1, "Invalid Field Index");
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint8_t>(verifier, VT_COLOR, 1) &&
            verifier.EndTable();
@@ -1116,8 +1116,8 @@ struct Stat FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
     else if constexpr (Index == 2) return count();
     else static_assert(Index != -1, "Invalid Field Index");
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_ID) &&
            verifier.VerifyString(id()) &&
@@ -1228,8 +1228,8 @@ struct Referrable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
          if constexpr (Index == 0) return id();
     else static_assert(Index != -1, "Invalid Field Index");
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint64_t>(verifier, VT_ID, 8) &&
            verifier.EndTable();
@@ -1897,8 +1897,8 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
     else if constexpr (Index == 60) return double_inf_default();
     else static_assert(Index != -1, "Invalid Field Index");
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<MyGame::Example::Vec3>(verifier, VT_POS, 8) &&
            VerifyField<int16_t>(verifier, VT_MANA, 2) &&
@@ -2704,8 +2704,8 @@ struct TypeAliases FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
     else if constexpr (Index == 11) return vf64();
     else static_assert(Index != -1, "Invalid Field Index");
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int8_t>(verifier, VT_I8, 1) &&
            VerifyField<uint8_t>(verifier, VT_U8, 1) &&
@@ -3398,8 +3398,8 @@ inline ::flatbuffers::Offset<TypeAliases> TypeAliases::Pack(::flatbuffers::FlatB
       _vf64);
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyAny(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Any type) {
+template <bool B>
+inline bool VerifyAny(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, Any type) {
   switch (type) {
     case Any::NONE: {
       return true;
@@ -3420,8 +3420,8 @@ inline bool VerifyAny(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier
   }
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyAnyVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Any> *types) {
+template <bool B>
+inline bool VerifyAnyVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Any> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@@ -3513,8 +3513,8 @@ inline void AnyUnion::Reset() {
   type = Any::NONE;
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyAnyUniqueAliases(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, AnyUniqueAliases type) {
+template <bool B>
+inline bool VerifyAnyUniqueAliases(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, AnyUniqueAliases type) {
   switch (type) {
     case AnyUniqueAliases::NONE: {
       return true;
@@ -3535,8 +3535,8 @@ inline bool VerifyAnyUniqueAliases(::flatbuffers::VerifierTemplate<TrackBufferSi
   }
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyAnyUniqueAliasesVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<AnyUniqueAliases> *types) {
+template <bool B>
+inline bool VerifyAnyUniqueAliasesVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<AnyUniqueAliases> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@@ -3628,8 +3628,8 @@ inline void AnyUniqueAliasesUnion::Reset() {
   type = AnyUniqueAliases::NONE;
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyAnyAmbiguousAliases(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, AnyAmbiguousAliases type) {
+template <bool B>
+inline bool VerifyAnyAmbiguousAliases(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, AnyAmbiguousAliases type) {
   switch (type) {
     case AnyAmbiguousAliases::NONE: {
       return true;
@@ -3650,8 +3650,8 @@ inline bool VerifyAnyAmbiguousAliases(::flatbuffers::VerifierTemplate<TrackBuffe
   }
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<AnyAmbiguousAliases> *types) {
+template <bool B>
+inline bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<AnyAmbiguousAliases> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@@ -4260,15 +4260,15 @@ inline bool SizePrefixedMonsterBufferHasIdentifier(const void *buf) {
       buf, MonsterIdentifier(), true);
 }
 
-template <bool TrackBufferSize = false>
+template <bool B = false>
 inline bool VerifyMonsterBuffer(
-    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
   return verifier.template VerifyBuffer<MyGame::Example::Monster>(MonsterIdentifier());
 }
 
-template <bool TrackBufferSize = false>
+template <bool B = false>
 inline bool VerifySizePrefixedMonsterBuffer(
-    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
   return verifier.template VerifySizePrefixedBuffer<MyGame::Example::Monster>(MonsterIdentifier());
 }
 
diff --git a/tests/cpp17/generated_cpp17/optional_scalars_generated.h b/tests/cpp17/generated_cpp17/optional_scalars_generated.h
index 3f048e867ac..bb415c7692c 100644
--- a/tests/cpp17/generated_cpp17/optional_scalars_generated.h
+++ b/tests/cpp17/generated_cpp17/optional_scalars_generated.h
@@ -395,8 +395,8 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
     else if constexpr (Index == 35) return default_enum();
     else static_assert(Index != -1, "Invalid Field Index");
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int8_t>(verifier, VT_JUST_I8, 1) &&
            VerifyField<int8_t>(verifier, VT_MAYBE_I8, 1) &&
@@ -959,15 +959,15 @@ inline bool SizePrefixedScalarStuffBufferHasIdentifier(const void *buf) {
       buf, ScalarStuffIdentifier(), true);
 }
 
-template <bool TrackBufferSize = false>
+template <bool B = false>
 inline bool VerifyScalarStuffBuffer(
-    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
   return verifier.template VerifyBuffer<optional_scalars::ScalarStuff>(ScalarStuffIdentifier());
 }
 
-template <bool TrackBufferSize = false>
+template <bool B = false>
 inline bool VerifySizePrefixedScalarStuffBuffer(
-    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
   return verifier.template VerifySizePrefixedBuffer<optional_scalars::ScalarStuff>(ScalarStuffIdentifier());
 }
 
diff --git a/tests/cpp17/generated_cpp17/union_vector_generated.h b/tests/cpp17/generated_cpp17/union_vector_generated.h
index bed386ff86c..e81f1d6a359 100644
--- a/tests/cpp17/generated_cpp17/union_vector_generated.h
+++ b/tests/cpp17/generated_cpp17/union_vector_generated.h
@@ -158,10 +158,10 @@ struct CharacterUnion {
   }
 };
 
-template <bool TrackBufferSize = false>
-bool VerifyCharacter(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Character type);
-template <bool TrackBufferSize = false>
-bool VerifyCharacterVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Character> *types);
+template <bool B = false>
+bool VerifyCharacter(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, Character type);
+template <bool B = false>
+bool VerifyCharacterVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Character> *types);
 
 enum class Gadget : uint8_t {
   NONE = 0,
@@ -268,10 +268,10 @@ struct GadgetUnion {
   }
 };
 
-template <bool TrackBufferSize = false>
-bool VerifyGadget(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Gadget type);
-template <bool TrackBufferSize = false>
-bool VerifyGadgetVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Gadget> *types);
+template <bool B = false>
+bool VerifyGadget(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, Gadget type);
+template <bool B = false>
+bool VerifyGadgetVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Gadget> *types);
 
 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Rapunzel FLATBUFFERS_FINAL_CLASS {
  private:
@@ -422,8 +422,8 @@ struct Attacker FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
          if constexpr (Index == 0) return sword_attack_damage();
     else static_assert(Index != -1, "Invalid Field Index");
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int32_t>(verifier, VT_SWORD_ATTACK_DAMAGE, 4) &&
            verifier.EndTable();
@@ -500,8 +500,8 @@ struct HandFan FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
          if constexpr (Index == 0) return length();
     else static_assert(Index != -1, "Invalid Field Index");
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int32_t>(verifier, VT_LENGTH, 4) &&
            verifier.EndTable();
@@ -618,8 +618,8 @@ struct Movie FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
     else if constexpr (Index == 3) return characters();
     else static_assert(Index != -1, "Invalid Field Index");
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint8_t>(verifier, VT_MAIN_CHARACTER_TYPE, 1) &&
            VerifyOffset(verifier, VT_MAIN_CHARACTER) &&
@@ -798,8 +798,8 @@ inline ::flatbuffers::Offset<Movie> Movie::Pack(::flatbuffers::FlatBufferBuilder
       _characters);
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyCharacter(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Character type) {
+template <bool B>
+inline bool VerifyCharacter(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, Character type) {
   switch (type) {
     case Character::NONE: {
       return true;
@@ -829,8 +829,8 @@ inline bool VerifyCharacter(::flatbuffers::VerifierTemplate<TrackBufferSize> &ve
   }
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyCharacterVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Character> *types) {
+template <bool B>
+inline bool VerifyCharacterVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Character> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@@ -973,8 +973,8 @@ inline void CharacterUnion::Reset() {
   type = Character::NONE;
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyGadget(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Gadget type) {
+template <bool B>
+inline bool VerifyGadget(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, Gadget type) {
   switch (type) {
     case Gadget::NONE: {
       return true;
@@ -990,8 +990,8 @@ inline bool VerifyGadget(::flatbuffers::VerifierTemplate<TrackBufferSize> &verif
   }
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyGadgetVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Gadget> *types) {
+template <bool B>
+inline bool VerifyGadgetVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Gadget> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@@ -1237,15 +1237,15 @@ inline bool SizePrefixedMovieBufferHasIdentifier(const void *buf) {
       buf, MovieIdentifier(), true);
 }
 
-template <bool TrackBufferSize = false>
+template <bool B = false>
 inline bool VerifyMovieBuffer(
-    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
   return verifier.template VerifyBuffer<Movie>(MovieIdentifier());
 }
 
-template <bool TrackBufferSize = false>
+template <bool B = false>
 inline bool VerifySizePrefixedMovieBuffer(
-    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
   return verifier.template VerifySizePrefixedBuffer<Movie>(MovieIdentifier());
 }
 
diff --git a/tests/evolution_test/evolution_v1_generated.h b/tests/evolution_test/evolution_v1_generated.h
index 023edcd35f5..827d058aed0 100644
--- a/tests/evolution_test/evolution_v1_generated.h
+++ b/tests/evolution_test/evolution_v1_generated.h
@@ -102,10 +102,10 @@ template<> struct UnionTraits<Evolution::V1::TableB> {
   static const Union enum_value = Union::TableB;
 };
 
-template <bool TrackBufferSize = false>
-bool VerifyUnion(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Union type);
-template <bool TrackBufferSize = false>
-bool VerifyUnionVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Union> *types);
+template <bool B = false>
+bool VerifyUnion(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, Union type);
+template <bool B = false>
+bool VerifyUnionVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Union> *types);
 
 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Struct FLATBUFFERS_FINAL_CLASS {
  private:
@@ -158,8 +158,8 @@ struct TableA FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   int32_t b() const {
     return GetField<int32_t>(VT_B, 0);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<float>(verifier, VT_A, 4) &&
            VerifyField<int32_t>(verifier, VT_B, 4) &&
@@ -206,8 +206,8 @@ struct TableB FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   int32_t a() const {
     return GetField<int32_t>(VT_A, 0);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int32_t>(verifier, VT_A, 4) &&
            verifier.EndTable();
@@ -306,8 +306,8 @@ struct Root FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const Evolution::V1::TableB *j_as_TableB() const {
     return j_type() == Evolution::V1::Union::TableB ? static_cast<const Evolution::V1::TableB *>(j()) : nullptr;
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int32_t>(verifier, VT_A, 4) &&
            VerifyField<uint8_t>(verifier, VT_B, 1) &&
@@ -460,8 +460,8 @@ inline ::flatbuffers::Offset<Root> CreateRootDirect(
       j);
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyUnion(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Union type) {
+template <bool B>
+inline bool VerifyUnion(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, Union type) {
   switch (type) {
     case Union::NONE: {
       return true;
@@ -478,8 +478,8 @@ inline bool VerifyUnion(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifi
   }
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyUnionVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Union> *types) {
+template <bool B>
+inline bool VerifyUnionVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Union> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@@ -499,15 +499,15 @@ inline const Evolution::V1::Root *GetSizePrefixedRoot(const void *buf) {
   return ::flatbuffers::GetSizePrefixedRoot<Evolution::V1::Root>(buf);
 }
 
-template <bool TrackBufferSize = false>
+template <bool B = false>
 inline bool VerifyRootBuffer(
-    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
   return verifier.template VerifyBuffer<Evolution::V1::Root>(nullptr);
 }
 
-template <bool TrackBufferSize = false>
+template <bool B = false>
 inline bool VerifySizePrefixedRootBuffer(
-    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
   return verifier.template VerifySizePrefixedBuffer<Evolution::V1::Root>(nullptr);
 }
 
diff --git a/tests/evolution_test/evolution_v2_generated.h b/tests/evolution_test/evolution_v2_generated.h
index 768142896ef..885830d4caa 100644
--- a/tests/evolution_test/evolution_v2_generated.h
+++ b/tests/evolution_test/evolution_v2_generated.h
@@ -118,10 +118,10 @@ template<> struct UnionTraits<Evolution::V2::TableC> {
   static const Union enum_value = Union::TableC;
 };
 
-template <bool TrackBufferSize = false>
-bool VerifyUnion(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Union type);
-template <bool TrackBufferSize = false>
-bool VerifyUnionVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Union> *types);
+template <bool B = false>
+bool VerifyUnion(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, Union type);
+template <bool B = false>
+bool VerifyUnionVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Union> *types);
 
 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Struct FLATBUFFERS_FINAL_CLASS {
  private:
@@ -178,8 +178,8 @@ struct TableA FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const ::flatbuffers::String *c() const {
     return GetPointer<const ::flatbuffers::String *>(VT_C);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<float>(verifier, VT_A, 4) &&
            VerifyField<int32_t>(verifier, VT_B, 4) &&
@@ -246,8 +246,8 @@ struct TableB FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   int32_t a() const {
     return GetField<int32_t>(VT_A, 0);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int32_t>(verifier, VT_A, 4) &&
            verifier.EndTable();
@@ -292,8 +292,8 @@ struct TableC FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const ::flatbuffers::String *b() const {
     return GetPointer<const ::flatbuffers::String *>(VT_B);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<double>(verifier, VT_A, 8) &&
            VerifyOffset(verifier, VT_B) &&
@@ -402,8 +402,8 @@ struct Root FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   uint8_t l() const {
     return GetField<uint8_t>(VT_L, 56);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint8_t>(verifier, VT_B, 1) &&
            VerifyField<uint8_t>(verifier, VT_C_TYPE, 1) &&
@@ -544,8 +544,8 @@ inline ::flatbuffers::Offset<Root> CreateRootDirect(
       l);
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyUnion(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Union type) {
+template <bool B>
+inline bool VerifyUnion(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, Union type) {
   switch (type) {
     case Union::NONE: {
       return true;
@@ -566,8 +566,8 @@ inline bool VerifyUnion(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifi
   }
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyUnionVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Union> *types) {
+template <bool B>
+inline bool VerifyUnionVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Union> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@@ -587,15 +587,15 @@ inline const Evolution::V2::Root *GetSizePrefixedRoot(const void *buf) {
   return ::flatbuffers::GetSizePrefixedRoot<Evolution::V2::Root>(buf);
 }
 
-template <bool TrackBufferSize = false>
+template <bool B = false>
 inline bool VerifyRootBuffer(
-    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
   return verifier.template VerifyBuffer<Evolution::V2::Root>(nullptr);
 }
 
-template <bool TrackBufferSize = false>
+template <bool B = false>
 inline bool VerifySizePrefixedRootBuffer(
-    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
   return verifier.template VerifySizePrefixedBuffer<Evolution::V2::Root>(nullptr);
 }
 
diff --git a/tests/key_field/key_field_sample_generated.h b/tests/key_field/key_field_sample_generated.h
index 5f3ef279e79..cba74688fa6 100644
--- a/tests/key_field/key_field_sample_generated.h
+++ b/tests/key_field/key_field_sample_generated.h
@@ -634,8 +634,8 @@ struct FooTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   ::flatbuffers::Vector<const keyfield::sample::Grain *> *mutable_h() {
     return GetPointer<::flatbuffers::Vector<const keyfield::sample::Grain *> *>(VT_H);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int32_t>(verifier, VT_A, 4) &&
            VerifyField<int32_t>(verifier, VT_B, 4) &&
@@ -991,15 +991,15 @@ inline keyfield::sample::FooTable *GetMutableSizePrefixedFooTable(void *buf) {
   return ::flatbuffers::GetMutableSizePrefixedRoot<keyfield::sample::FooTable>(buf);
 }
 
-template <bool TrackBufferSize = false>
+template <bool B = false>
 inline bool VerifyFooTableBuffer(
-    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
   return verifier.template VerifyBuffer<keyfield::sample::FooTable>(nullptr);
 }
 
-template <bool TrackBufferSize = false>
+template <bool B = false>
 inline bool VerifySizePrefixedFooTableBuffer(
-    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
   return verifier.template VerifySizePrefixedBuffer<keyfield::sample::FooTable>(nullptr);
 }
 
diff --git a/tests/monster_extra_generated.h b/tests/monster_extra_generated.h
index 2138a9ab33a..a87f7d92438 100644
--- a/tests/monster_extra_generated.h
+++ b/tests/monster_extra_generated.h
@@ -116,8 +116,8 @@ struct MonsterExtra FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   ::flatbuffers::Vector<float> *mutable_fvec() {
     return GetPointer<::flatbuffers::Vector<float> *>(VT_FVEC);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<double>(verifier, VT_D0, 8) &&
            VerifyField<double>(verifier, VT_D1, 8) &&
@@ -375,15 +375,15 @@ inline bool SizePrefixedMonsterExtraBufferHasIdentifier(const void *buf) {
       buf, MonsterExtraIdentifier(), true);
 }
 
-template <bool TrackBufferSize = false>
+template <bool B = false>
 inline bool VerifyMonsterExtraBuffer(
-    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
   return verifier.template VerifyBuffer<MyGame::MonsterExtra>(MonsterExtraIdentifier());
 }
 
-template <bool TrackBufferSize = false>
+template <bool B = false>
 inline bool VerifySizePrefixedMonsterExtraBuffer(
-    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
   return verifier.template VerifySizePrefixedBuffer<MyGame::MonsterExtra>(MonsterExtraIdentifier());
 }
 
diff --git a/tests/monster_test_generated.h b/tests/monster_test_generated.h
index 4fbfdf97c80..594670baa7b 100644
--- a/tests/monster_test_generated.h
+++ b/tests/monster_test_generated.h
@@ -386,10 +386,10 @@ inline bool operator!=(const AnyUnion &lhs, const AnyUnion &rhs) {
     return !(lhs == rhs);
 }
 
-template <bool TrackBufferSize = false>
-bool VerifyAny(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Any type);
-template <bool TrackBufferSize = false>
-bool VerifyAnyVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
+template <bool B = false>
+bool VerifyAny(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, Any type);
+template <bool B = false>
+bool VerifyAnyVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
 
 enum AnyUniqueAliases : uint8_t {
   AnyUniqueAliases_NONE = 0,
@@ -544,10 +544,10 @@ inline bool operator!=(const AnyUniqueAliasesUnion &lhs, const AnyUniqueAliasesU
     return !(lhs == rhs);
 }
 
-template <bool TrackBufferSize = false>
-bool VerifyAnyUniqueAliases(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, AnyUniqueAliases type);
-template <bool TrackBufferSize = false>
-bool VerifyAnyUniqueAliasesVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
+template <bool B = false>
+bool VerifyAnyUniqueAliases(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, AnyUniqueAliases type);
+template <bool B = false>
+bool VerifyAnyUniqueAliasesVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
 
 enum AnyAmbiguousAliases : uint8_t {
   AnyAmbiguousAliases_NONE = 0,
@@ -660,10 +660,10 @@ inline bool operator!=(const AnyAmbiguousAliasesUnion &lhs, const AnyAmbiguousAl
     return !(lhs == rhs);
 }
 
-template <bool TrackBufferSize = false>
-bool VerifyAnyAmbiguousAliases(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, AnyAmbiguousAliases type);
-template <bool TrackBufferSize = false>
-bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
+template <bool B = false>
+bool VerifyAnyAmbiguousAliases(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, AnyAmbiguousAliases type);
+template <bool B = false>
+bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
 
 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(2) Test FLATBUFFERS_FINAL_CLASS {
  private:
@@ -959,8 +959,8 @@ struct InParentNamespace FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
   static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
     return InParentNamespaceTypeTable();
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            verifier.EndTable();
   }
@@ -1005,8 +1005,8 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
     return MonsterTypeTable();
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            verifier.EndTable();
   }
@@ -1063,8 +1063,8 @@ struct TestSimpleTableWithEnum FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::
   bool mutate_color(MyGame::Example::Color _color = static_cast<MyGame::Example::Color>(2)) {
     return SetField<uint8_t>(VT_COLOR, static_cast<uint8_t>(_color), 2);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint8_t>(verifier, VT_COLOR, 1) &&
            verifier.EndTable();
@@ -1145,8 +1145,8 @@ struct Stat FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   int KeyCompareWithValue(uint16_t _count) const {
     return static_cast<int>(count() > _count) - static_cast<int>(count() < _count);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_ID) &&
            verifier.VerifyString(id()) &&
@@ -1237,8 +1237,8 @@ struct Referrable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   int KeyCompareWithValue(uint64_t _id) const {
     return static_cast<int>(id() > _id) - static_cast<int>(id() < _id);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint64_t>(verifier, VT_ID, 8) &&
            verifier.EndTable();
@@ -1828,8 +1828,8 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   bool mutate_double_inf_default(double _double_inf_default = std::numeric_limits<double>::infinity()) {
     return SetField<double>(VT_DOUBLE_INF_DEFAULT, _double_inf_default, std::numeric_limits<double>::infinity());
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<MyGame::Example::Vec3>(verifier, VT_POS, 8) &&
            VerifyField<int16_t>(verifier, VT_MANA, 2) &&
@@ -2546,8 +2546,8 @@ struct TypeAliases FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   ::flatbuffers::Vector<double> *mutable_vf64() {
     return GetPointer<::flatbuffers::Vector<double> *>(VT_VF64);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int8_t>(verifier, VT_I8, 1) &&
            VerifyField<uint8_t>(verifier, VT_U8, 1) &&
@@ -3361,8 +3361,8 @@ inline ::flatbuffers::Offset<TypeAliases> TypeAliases::Pack(::flatbuffers::FlatB
       _vf64);
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyAny(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Any type) {
+template <bool B>
+inline bool VerifyAny(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, Any type) {
   switch (type) {
     case Any_NONE: {
       return true;
@@ -3383,8 +3383,8 @@ inline bool VerifyAny(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier
   }
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyAnyVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
+template <bool B>
+inline bool VerifyAnyVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@@ -3476,8 +3476,8 @@ inline void AnyUnion::Reset() {
   type = Any_NONE;
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyAnyUniqueAliases(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, AnyUniqueAliases type) {
+template <bool B>
+inline bool VerifyAnyUniqueAliases(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, AnyUniqueAliases type) {
   switch (type) {
     case AnyUniqueAliases_NONE: {
       return true;
@@ -3498,8 +3498,8 @@ inline bool VerifyAnyUniqueAliases(::flatbuffers::VerifierTemplate<TrackBufferSi
   }
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyAnyUniqueAliasesVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
+template <bool B>
+inline bool VerifyAnyUniqueAliasesVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@@ -3591,8 +3591,8 @@ inline void AnyUniqueAliasesUnion::Reset() {
   type = AnyUniqueAliases_NONE;
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyAnyAmbiguousAliases(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, AnyAmbiguousAliases type) {
+template <bool B>
+inline bool VerifyAnyAmbiguousAliases(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, AnyAmbiguousAliases type) {
   switch (type) {
     case AnyAmbiguousAliases_NONE: {
       return true;
@@ -3613,8 +3613,8 @@ inline bool VerifyAnyAmbiguousAliases(::flatbuffers::VerifierTemplate<TrackBuffe
   }
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
+template <bool B>
+inline bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@@ -4223,15 +4223,15 @@ inline bool SizePrefixedMonsterBufferHasIdentifier(const void *buf) {
       buf, MonsterIdentifier(), true);
 }
 
-template <bool TrackBufferSize = false>
+template <bool B = false>
 inline bool VerifyMonsterBuffer(
-    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
   return verifier.template VerifyBuffer<MyGame::Example::Monster>(MonsterIdentifier());
 }
 
-template <bool TrackBufferSize = false>
+template <bool B = false>
 inline bool VerifySizePrefixedMonsterBuffer(
-    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
   return verifier.template VerifySizePrefixedBuffer<MyGame::Example::Monster>(MonsterIdentifier());
 }
 
diff --git a/tests/monster_test_suffix/ext_only/monster_test_generated.hpp b/tests/monster_test_suffix/ext_only/monster_test_generated.hpp
index cde02153f26..b3db30d3be2 100644
--- a/tests/monster_test_suffix/ext_only/monster_test_generated.hpp
+++ b/tests/monster_test_suffix/ext_only/monster_test_generated.hpp
@@ -383,10 +383,10 @@ inline bool operator!=(const AnyUnion &lhs, const AnyUnion &rhs) {
     return !(lhs == rhs);
 }
 
-template <bool TrackBufferSize = false>
-bool VerifyAny(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Any type);
-template <bool TrackBufferSize = false>
-bool VerifyAnyVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
+template <bool B = false>
+bool VerifyAny(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, Any type);
+template <bool B = false>
+bool VerifyAnyVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
 
 enum AnyUniqueAliases : uint8_t {
   AnyUniqueAliases_NONE = 0,
@@ -541,10 +541,10 @@ inline bool operator!=(const AnyUniqueAliasesUnion &lhs, const AnyUniqueAliasesU
     return !(lhs == rhs);
 }
 
-template <bool TrackBufferSize = false>
-bool VerifyAnyUniqueAliases(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, AnyUniqueAliases type);
-template <bool TrackBufferSize = false>
-bool VerifyAnyUniqueAliasesVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
+template <bool B = false>
+bool VerifyAnyUniqueAliases(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, AnyUniqueAliases type);
+template <bool B = false>
+bool VerifyAnyUniqueAliasesVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
 
 enum AnyAmbiguousAliases : uint8_t {
   AnyAmbiguousAliases_NONE = 0,
@@ -657,10 +657,10 @@ inline bool operator!=(const AnyAmbiguousAliasesUnion &lhs, const AnyAmbiguousAl
     return !(lhs == rhs);
 }
 
-template <bool TrackBufferSize = false>
-bool VerifyAnyAmbiguousAliases(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, AnyAmbiguousAliases type);
-template <bool TrackBufferSize = false>
-bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
+template <bool B = false>
+bool VerifyAnyAmbiguousAliases(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, AnyAmbiguousAliases type);
+template <bool B = false>
+bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
 
 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(2) Test FLATBUFFERS_FINAL_CLASS {
  private:
@@ -955,8 +955,8 @@ struct InParentNamespace FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
   static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
     return InParentNamespaceTypeTable();
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            verifier.EndTable();
   }
@@ -1000,8 +1000,8 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
     return MonsterTypeTable();
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            verifier.EndTable();
   }
@@ -1057,8 +1057,8 @@ struct TestSimpleTableWithEnum FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::
   bool mutate_color(MyGame::Example::Color _color = static_cast<MyGame::Example::Color>(2)) {
     return SetField<uint8_t>(VT_COLOR, static_cast<uint8_t>(_color), 2);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint8_t>(verifier, VT_COLOR, 1) &&
            verifier.EndTable();
@@ -1138,8 +1138,8 @@ struct Stat FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   int KeyCompareWithValue(uint16_t _count) const {
     return static_cast<int>(count() > _count) - static_cast<int>(count() < _count);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_ID) &&
            verifier.VerifyString(id()) &&
@@ -1229,8 +1229,8 @@ struct Referrable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   int KeyCompareWithValue(uint64_t _id) const {
     return static_cast<int>(id() > _id) - static_cast<int>(id() < _id);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint64_t>(verifier, VT_ID, 8) &&
            verifier.EndTable();
@@ -1819,8 +1819,8 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   bool mutate_double_inf_default(double _double_inf_default = std::numeric_limits<double>::infinity()) {
     return SetField<double>(VT_DOUBLE_INF_DEFAULT, _double_inf_default, std::numeric_limits<double>::infinity());
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<MyGame::Example::Vec3>(verifier, VT_POS, 8) &&
            VerifyField<int16_t>(verifier, VT_MANA, 2) &&
@@ -2536,8 +2536,8 @@ struct TypeAliases FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   ::flatbuffers::Vector<double> *mutable_vf64() {
     return GetPointer<::flatbuffers::Vector<double> *>(VT_VF64);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int8_t>(verifier, VT_I8, 1) &&
            VerifyField<uint8_t>(verifier, VT_U8, 1) &&
@@ -3351,8 +3351,8 @@ inline ::flatbuffers::Offset<TypeAliases> TypeAliases::Pack(::flatbuffers::FlatB
       _vf64);
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyAny(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Any type) {
+template <bool B>
+inline bool VerifyAny(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, Any type) {
   switch (type) {
     case Any_NONE: {
       return true;
@@ -3373,8 +3373,8 @@ inline bool VerifyAny(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier
   }
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyAnyVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
+template <bool B>
+inline bool VerifyAnyVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@@ -3466,8 +3466,8 @@ inline void AnyUnion::Reset() {
   type = Any_NONE;
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyAnyUniqueAliases(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, AnyUniqueAliases type) {
+template <bool B>
+inline bool VerifyAnyUniqueAliases(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, AnyUniqueAliases type) {
   switch (type) {
     case AnyUniqueAliases_NONE: {
       return true;
@@ -3488,8 +3488,8 @@ inline bool VerifyAnyUniqueAliases(::flatbuffers::VerifierTemplate<TrackBufferSi
   }
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyAnyUniqueAliasesVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
+template <bool B>
+inline bool VerifyAnyUniqueAliasesVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@@ -3581,8 +3581,8 @@ inline void AnyUniqueAliasesUnion::Reset() {
   type = AnyUniqueAliases_NONE;
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyAnyAmbiguousAliases(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, AnyAmbiguousAliases type) {
+template <bool B>
+inline bool VerifyAnyAmbiguousAliases(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, AnyAmbiguousAliases type) {
   switch (type) {
     case AnyAmbiguousAliases_NONE: {
       return true;
@@ -3603,8 +3603,8 @@ inline bool VerifyAnyAmbiguousAliases(::flatbuffers::VerifierTemplate<TrackBuffe
   }
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
+template <bool B>
+inline bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@@ -4213,15 +4213,15 @@ inline bool SizePrefixedMonsterBufferHasIdentifier(const void *buf) {
       buf, MonsterIdentifier(), true);
 }
 
-template <bool TrackBufferSize = false>
+template <bool B = false>
 inline bool VerifyMonsterBuffer(
-    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
   return verifier.template VerifyBuffer<MyGame::Example::Monster>(MonsterIdentifier());
 }
 
-template <bool TrackBufferSize = false>
+template <bool B = false>
 inline bool VerifySizePrefixedMonsterBuffer(
-    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
   return verifier.template VerifySizePrefixedBuffer<MyGame::Example::Monster>(MonsterIdentifier());
 }
 
diff --git a/tests/monster_test_suffix/filesuffix_only/monster_test_suffix.h b/tests/monster_test_suffix/filesuffix_only/monster_test_suffix.h
index cde02153f26..b3db30d3be2 100644
--- a/tests/monster_test_suffix/filesuffix_only/monster_test_suffix.h
+++ b/tests/monster_test_suffix/filesuffix_only/monster_test_suffix.h
@@ -383,10 +383,10 @@ inline bool operator!=(const AnyUnion &lhs, const AnyUnion &rhs) {
     return !(lhs == rhs);
 }
 
-template <bool TrackBufferSize = false>
-bool VerifyAny(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Any type);
-template <bool TrackBufferSize = false>
-bool VerifyAnyVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
+template <bool B = false>
+bool VerifyAny(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, Any type);
+template <bool B = false>
+bool VerifyAnyVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
 
 enum AnyUniqueAliases : uint8_t {
   AnyUniqueAliases_NONE = 0,
@@ -541,10 +541,10 @@ inline bool operator!=(const AnyUniqueAliasesUnion &lhs, const AnyUniqueAliasesU
     return !(lhs == rhs);
 }
 
-template <bool TrackBufferSize = false>
-bool VerifyAnyUniqueAliases(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, AnyUniqueAliases type);
-template <bool TrackBufferSize = false>
-bool VerifyAnyUniqueAliasesVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
+template <bool B = false>
+bool VerifyAnyUniqueAliases(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, AnyUniqueAliases type);
+template <bool B = false>
+bool VerifyAnyUniqueAliasesVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
 
 enum AnyAmbiguousAliases : uint8_t {
   AnyAmbiguousAliases_NONE = 0,
@@ -657,10 +657,10 @@ inline bool operator!=(const AnyAmbiguousAliasesUnion &lhs, const AnyAmbiguousAl
     return !(lhs == rhs);
 }
 
-template <bool TrackBufferSize = false>
-bool VerifyAnyAmbiguousAliases(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, AnyAmbiguousAliases type);
-template <bool TrackBufferSize = false>
-bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
+template <bool B = false>
+bool VerifyAnyAmbiguousAliases(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, AnyAmbiguousAliases type);
+template <bool B = false>
+bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
 
 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(2) Test FLATBUFFERS_FINAL_CLASS {
  private:
@@ -955,8 +955,8 @@ struct InParentNamespace FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
   static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
     return InParentNamespaceTypeTable();
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            verifier.EndTable();
   }
@@ -1000,8 +1000,8 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
     return MonsterTypeTable();
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            verifier.EndTable();
   }
@@ -1057,8 +1057,8 @@ struct TestSimpleTableWithEnum FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::
   bool mutate_color(MyGame::Example::Color _color = static_cast<MyGame::Example::Color>(2)) {
     return SetField<uint8_t>(VT_COLOR, static_cast<uint8_t>(_color), 2);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint8_t>(verifier, VT_COLOR, 1) &&
            verifier.EndTable();
@@ -1138,8 +1138,8 @@ struct Stat FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   int KeyCompareWithValue(uint16_t _count) const {
     return static_cast<int>(count() > _count) - static_cast<int>(count() < _count);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_ID) &&
            verifier.VerifyString(id()) &&
@@ -1229,8 +1229,8 @@ struct Referrable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   int KeyCompareWithValue(uint64_t _id) const {
     return static_cast<int>(id() > _id) - static_cast<int>(id() < _id);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint64_t>(verifier, VT_ID, 8) &&
            verifier.EndTable();
@@ -1819,8 +1819,8 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   bool mutate_double_inf_default(double _double_inf_default = std::numeric_limits<double>::infinity()) {
     return SetField<double>(VT_DOUBLE_INF_DEFAULT, _double_inf_default, std::numeric_limits<double>::infinity());
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<MyGame::Example::Vec3>(verifier, VT_POS, 8) &&
            VerifyField<int16_t>(verifier, VT_MANA, 2) &&
@@ -2536,8 +2536,8 @@ struct TypeAliases FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   ::flatbuffers::Vector<double> *mutable_vf64() {
     return GetPointer<::flatbuffers::Vector<double> *>(VT_VF64);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int8_t>(verifier, VT_I8, 1) &&
            VerifyField<uint8_t>(verifier, VT_U8, 1) &&
@@ -3351,8 +3351,8 @@ inline ::flatbuffers::Offset<TypeAliases> TypeAliases::Pack(::flatbuffers::FlatB
       _vf64);
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyAny(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Any type) {
+template <bool B>
+inline bool VerifyAny(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, Any type) {
   switch (type) {
     case Any_NONE: {
       return true;
@@ -3373,8 +3373,8 @@ inline bool VerifyAny(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier
   }
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyAnyVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
+template <bool B>
+inline bool VerifyAnyVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@@ -3466,8 +3466,8 @@ inline void AnyUnion::Reset() {
   type = Any_NONE;
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyAnyUniqueAliases(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, AnyUniqueAliases type) {
+template <bool B>
+inline bool VerifyAnyUniqueAliases(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, AnyUniqueAliases type) {
   switch (type) {
     case AnyUniqueAliases_NONE: {
       return true;
@@ -3488,8 +3488,8 @@ inline bool VerifyAnyUniqueAliases(::flatbuffers::VerifierTemplate<TrackBufferSi
   }
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyAnyUniqueAliasesVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
+template <bool B>
+inline bool VerifyAnyUniqueAliasesVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@@ -3581,8 +3581,8 @@ inline void AnyUniqueAliasesUnion::Reset() {
   type = AnyUniqueAliases_NONE;
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyAnyAmbiguousAliases(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, AnyAmbiguousAliases type) {
+template <bool B>
+inline bool VerifyAnyAmbiguousAliases(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, AnyAmbiguousAliases type) {
   switch (type) {
     case AnyAmbiguousAliases_NONE: {
       return true;
@@ -3603,8 +3603,8 @@ inline bool VerifyAnyAmbiguousAliases(::flatbuffers::VerifierTemplate<TrackBuffe
   }
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
+template <bool B>
+inline bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@@ -4213,15 +4213,15 @@ inline bool SizePrefixedMonsterBufferHasIdentifier(const void *buf) {
       buf, MonsterIdentifier(), true);
 }
 
-template <bool TrackBufferSize = false>
+template <bool B = false>
 inline bool VerifyMonsterBuffer(
-    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
   return verifier.template VerifyBuffer<MyGame::Example::Monster>(MonsterIdentifier());
 }
 
-template <bool TrackBufferSize = false>
+template <bool B = false>
 inline bool VerifySizePrefixedMonsterBuffer(
-    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
   return verifier.template VerifySizePrefixedBuffer<MyGame::Example::Monster>(MonsterIdentifier());
 }
 
diff --git a/tests/monster_test_suffix/monster_test_suffix.hpp b/tests/monster_test_suffix/monster_test_suffix.hpp
index cde02153f26..b3db30d3be2 100644
--- a/tests/monster_test_suffix/monster_test_suffix.hpp
+++ b/tests/monster_test_suffix/monster_test_suffix.hpp
@@ -383,10 +383,10 @@ inline bool operator!=(const AnyUnion &lhs, const AnyUnion &rhs) {
     return !(lhs == rhs);
 }
 
-template <bool TrackBufferSize = false>
-bool VerifyAny(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Any type);
-template <bool TrackBufferSize = false>
-bool VerifyAnyVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
+template <bool B = false>
+bool VerifyAny(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, Any type);
+template <bool B = false>
+bool VerifyAnyVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
 
 enum AnyUniqueAliases : uint8_t {
   AnyUniqueAliases_NONE = 0,
@@ -541,10 +541,10 @@ inline bool operator!=(const AnyUniqueAliasesUnion &lhs, const AnyUniqueAliasesU
     return !(lhs == rhs);
 }
 
-template <bool TrackBufferSize = false>
-bool VerifyAnyUniqueAliases(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, AnyUniqueAliases type);
-template <bool TrackBufferSize = false>
-bool VerifyAnyUniqueAliasesVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
+template <bool B = false>
+bool VerifyAnyUniqueAliases(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, AnyUniqueAliases type);
+template <bool B = false>
+bool VerifyAnyUniqueAliasesVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
 
 enum AnyAmbiguousAliases : uint8_t {
   AnyAmbiguousAliases_NONE = 0,
@@ -657,10 +657,10 @@ inline bool operator!=(const AnyAmbiguousAliasesUnion &lhs, const AnyAmbiguousAl
     return !(lhs == rhs);
 }
 
-template <bool TrackBufferSize = false>
-bool VerifyAnyAmbiguousAliases(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, AnyAmbiguousAliases type);
-template <bool TrackBufferSize = false>
-bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
+template <bool B = false>
+bool VerifyAnyAmbiguousAliases(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, AnyAmbiguousAliases type);
+template <bool B = false>
+bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
 
 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(2) Test FLATBUFFERS_FINAL_CLASS {
  private:
@@ -955,8 +955,8 @@ struct InParentNamespace FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
   static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
     return InParentNamespaceTypeTable();
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            verifier.EndTable();
   }
@@ -1000,8 +1000,8 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
     return MonsterTypeTable();
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            verifier.EndTable();
   }
@@ -1057,8 +1057,8 @@ struct TestSimpleTableWithEnum FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::
   bool mutate_color(MyGame::Example::Color _color = static_cast<MyGame::Example::Color>(2)) {
     return SetField<uint8_t>(VT_COLOR, static_cast<uint8_t>(_color), 2);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint8_t>(verifier, VT_COLOR, 1) &&
            verifier.EndTable();
@@ -1138,8 +1138,8 @@ struct Stat FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   int KeyCompareWithValue(uint16_t _count) const {
     return static_cast<int>(count() > _count) - static_cast<int>(count() < _count);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_ID) &&
            verifier.VerifyString(id()) &&
@@ -1229,8 +1229,8 @@ struct Referrable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   int KeyCompareWithValue(uint64_t _id) const {
     return static_cast<int>(id() > _id) - static_cast<int>(id() < _id);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint64_t>(verifier, VT_ID, 8) &&
            verifier.EndTable();
@@ -1819,8 +1819,8 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   bool mutate_double_inf_default(double _double_inf_default = std::numeric_limits<double>::infinity()) {
     return SetField<double>(VT_DOUBLE_INF_DEFAULT, _double_inf_default, std::numeric_limits<double>::infinity());
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<MyGame::Example::Vec3>(verifier, VT_POS, 8) &&
            VerifyField<int16_t>(verifier, VT_MANA, 2) &&
@@ -2536,8 +2536,8 @@ struct TypeAliases FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   ::flatbuffers::Vector<double> *mutable_vf64() {
     return GetPointer<::flatbuffers::Vector<double> *>(VT_VF64);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int8_t>(verifier, VT_I8, 1) &&
            VerifyField<uint8_t>(verifier, VT_U8, 1) &&
@@ -3351,8 +3351,8 @@ inline ::flatbuffers::Offset<TypeAliases> TypeAliases::Pack(::flatbuffers::FlatB
       _vf64);
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyAny(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Any type) {
+template <bool B>
+inline bool VerifyAny(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, Any type) {
   switch (type) {
     case Any_NONE: {
       return true;
@@ -3373,8 +3373,8 @@ inline bool VerifyAny(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier
   }
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyAnyVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
+template <bool B>
+inline bool VerifyAnyVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@@ -3466,8 +3466,8 @@ inline void AnyUnion::Reset() {
   type = Any_NONE;
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyAnyUniqueAliases(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, AnyUniqueAliases type) {
+template <bool B>
+inline bool VerifyAnyUniqueAliases(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, AnyUniqueAliases type) {
   switch (type) {
     case AnyUniqueAliases_NONE: {
       return true;
@@ -3488,8 +3488,8 @@ inline bool VerifyAnyUniqueAliases(::flatbuffers::VerifierTemplate<TrackBufferSi
   }
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyAnyUniqueAliasesVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
+template <bool B>
+inline bool VerifyAnyUniqueAliasesVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@@ -3581,8 +3581,8 @@ inline void AnyUniqueAliasesUnion::Reset() {
   type = AnyUniqueAliases_NONE;
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyAnyAmbiguousAliases(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, AnyAmbiguousAliases type) {
+template <bool B>
+inline bool VerifyAnyAmbiguousAliases(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, AnyAmbiguousAliases type) {
   switch (type) {
     case AnyAmbiguousAliases_NONE: {
       return true;
@@ -3603,8 +3603,8 @@ inline bool VerifyAnyAmbiguousAliases(::flatbuffers::VerifierTemplate<TrackBuffe
   }
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
+template <bool B>
+inline bool VerifyAnyAmbiguousAliasesVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@@ -4213,15 +4213,15 @@ inline bool SizePrefixedMonsterBufferHasIdentifier(const void *buf) {
       buf, MonsterIdentifier(), true);
 }
 
-template <bool TrackBufferSize = false>
+template <bool B = false>
 inline bool VerifyMonsterBuffer(
-    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
   return verifier.template VerifyBuffer<MyGame::Example::Monster>(MonsterIdentifier());
 }
 
-template <bool TrackBufferSize = false>
+template <bool B = false>
 inline bool VerifySizePrefixedMonsterBuffer(
-    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
   return verifier.template VerifySizePrefixedBuffer<MyGame::Example::Monster>(MonsterIdentifier());
 }
 
diff --git a/tests/namespace_test/namespace_test1_generated.h b/tests/namespace_test/namespace_test1_generated.h
index b2f86e00cb5..50d0e487b55 100644
--- a/tests/namespace_test/namespace_test1_generated.h
+++ b/tests/namespace_test/namespace_test1_generated.h
@@ -138,10 +138,10 @@ inline bool operator!=(const UnionInNestedNSUnion &lhs, const UnionInNestedNSUni
     return !(lhs == rhs);
 }
 
-template <bool TrackBufferSize = false>
-bool VerifyUnionInNestedNS(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, UnionInNestedNS type);
-template <bool TrackBufferSize = false>
-bool VerifyUnionInNestedNSVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
+template <bool B = false>
+bool VerifyUnionInNestedNS(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, UnionInNestedNS type);
+template <bool B = false>
+bool VerifyUnionInNestedNSVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
 
 enum EnumInNestedNS : int8_t {
   EnumInNestedNS_A = 0,
@@ -248,8 +248,8 @@ struct TableInNestedNS FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   bool mutate_foo(int32_t _foo = 0) {
     return SetField<int32_t>(VT_FOO, _foo, 0);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int32_t>(verifier, VT_FOO, 4) &&
            verifier.EndTable();
@@ -324,8 +324,8 @@ inline ::flatbuffers::Offset<TableInNestedNS> TableInNestedNS::Pack(::flatbuffer
       _foo);
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyUnionInNestedNS(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, UnionInNestedNS type) {
+template <bool B>
+inline bool VerifyUnionInNestedNS(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, UnionInNestedNS type) {
   switch (type) {
     case UnionInNestedNS_NONE: {
       return true;
@@ -338,8 +338,8 @@ inline bool VerifyUnionInNestedNS(::flatbuffers::VerifierTemplate<TrackBufferSiz
   }
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyUnionInNestedNSVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
+template <bool B>
+inline bool VerifyUnionInNestedNSVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
diff --git a/tests/namespace_test/namespace_test2_generated.h b/tests/namespace_test/namespace_test2_generated.h
index 8270b39c569..99c661057ef 100644
--- a/tests/namespace_test/namespace_test2_generated.h
+++ b/tests/namespace_test/namespace_test2_generated.h
@@ -126,8 +126,8 @@ struct TableInFirstNS FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   NamespaceA::NamespaceB::StructInNestedNS *mutable_foo_struct() {
     return GetStruct<NamespaceA::NamespaceB::StructInNestedNS *>(VT_FOO_STRUCT);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_FOO_TABLE) &&
            verifier.VerifyTable(foo_table()) &&
@@ -237,8 +237,8 @@ struct TableInC FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   NamespaceA::SecondTableInA *mutable_refer_to_a2() {
     return GetPointer<NamespaceA::SecondTableInA *>(VT_REFER_TO_A2);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_REFER_TO_A1) &&
            verifier.VerifyTable(refer_to_a1()) &&
@@ -318,8 +318,8 @@ struct SecondTableInA FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   NamespaceC::TableInC *mutable_refer_to_c() {
     return GetPointer<NamespaceC::TableInC *>(VT_REFER_TO_C);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_REFER_TO_C) &&
            verifier.VerifyTable(refer_to_c()) &&
diff --git a/tests/native_inline_table_test_generated.h b/tests/native_inline_table_test_generated.h
index f82a0f87b5b..3bcdab09b7c 100644
--- a/tests/native_inline_table_test_generated.h
+++ b/tests/native_inline_table_test_generated.h
@@ -50,8 +50,8 @@ struct NativeInlineTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table
   bool mutate_a(int32_t _a = 0) {
     return SetField<int32_t>(VT_A, _a, 0);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int32_t>(verifier, VT_A, 4) &&
            verifier.EndTable();
@@ -109,8 +109,8 @@ struct TestNativeInlineTable FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Ta
   ::flatbuffers::Vector<::flatbuffers::Offset<NativeInlineTable>> *mutable_t() {
     return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<NativeInlineTable>> *>(VT_T);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_T) &&
            verifier.VerifyVector(t()) &&
diff --git a/tests/native_type_test_generated.h b/tests/native_type_test_generated.h
index 719ba27a042..48a33c6438c 100644
--- a/tests/native_type_test_generated.h
+++ b/tests/native_type_test_generated.h
@@ -278,8 +278,8 @@ struct ApplicationData FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   ::flatbuffers::Vector<::flatbuffers::Offset<Geometry::Matrix>> *mutable_matrices() {
     return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<Geometry::Matrix>> *>(VT_MATRICES);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_VECTORS) &&
            verifier.VerifyVector(vectors()) &&
@@ -557,15 +557,15 @@ inline Geometry::ApplicationData *GetMutableSizePrefixedApplicationData(void *bu
   return ::flatbuffers::GetMutableSizePrefixedRoot<Geometry::ApplicationData>(buf);
 }
 
-template <bool TrackBufferSize = false>
+template <bool B = false>
 inline bool VerifyApplicationDataBuffer(
-    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
   return verifier.template VerifyBuffer<Geometry::ApplicationData>(nullptr);
 }
 
-template <bool TrackBufferSize = false>
+template <bool B = false>
 inline bool VerifySizePrefixedApplicationDataBuffer(
-    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
   return verifier.template VerifySizePrefixedBuffer<Geometry::ApplicationData>(nullptr);
 }
 
diff --git a/tests/optional_scalars_generated.h b/tests/optional_scalars_generated.h
index 4989a52f8c2..08338dfe337 100644
--- a/tests/optional_scalars_generated.h
+++ b/tests/optional_scalars_generated.h
@@ -357,8 +357,8 @@ struct ScalarStuff FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   bool mutate_default_enum(optional_scalars::OptionalByte _default_enum = static_cast<optional_scalars::OptionalByte>(1)) {
     return SetField<int8_t>(VT_DEFAULT_ENUM, static_cast<int8_t>(_default_enum), 1);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int8_t>(verifier, VT_JUST_I8, 1) &&
            VerifyField<int8_t>(verifier, VT_MAYBE_I8, 1) &&
@@ -919,15 +919,15 @@ inline bool SizePrefixedScalarStuffBufferHasIdentifier(const void *buf) {
       buf, ScalarStuffIdentifier(), true);
 }
 
-template <bool TrackBufferSize = false>
+template <bool B = false>
 inline bool VerifyScalarStuffBuffer(
-    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
   return verifier.template VerifyBuffer<optional_scalars::ScalarStuff>(ScalarStuffIdentifier());
 }
 
-template <bool TrackBufferSize = false>
+template <bool B = false>
 inline bool VerifySizePrefixedScalarStuffBuffer(
-    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
   return verifier.template VerifySizePrefixedBuffer<optional_scalars::ScalarStuff>(ScalarStuffIdentifier());
 }
 
diff --git a/tests/union_underlying_type_test_generated.h b/tests/union_underlying_type_test_generated.h
index b1c7d5a3222..74ec1f9563b 100644
--- a/tests/union_underlying_type_test_generated.h
+++ b/tests/union_underlying_type_test_generated.h
@@ -194,10 +194,10 @@ inline bool operator!=(const ABCUnion &lhs, const ABCUnion &rhs) {
     return !(lhs == rhs);
 }
 
-template <bool TrackBufferSize = false>
-bool VerifyABC(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, ABC type);
-template <bool TrackBufferSize = false>
-bool VerifyABCVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<ABC> *types);
+template <bool B = false>
+bool VerifyABC(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, ABC type);
+template <bool B = false>
+bool VerifyABCVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<ABC> *types);
 
 struct AT : public ::flatbuffers::NativeTable {
   typedef A TableType;
@@ -219,8 +219,8 @@ struct A FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   bool mutate_a(int32_t _a = 0) {
     return SetField<int32_t>(VT_A, _a, 0);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int32_t>(verifier, VT_A, 4) &&
            verifier.EndTable();
@@ -278,8 +278,8 @@ struct B FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   ::flatbuffers::String *mutable_b() {
     return GetPointer<::flatbuffers::String *>(VT_B);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyOffset(verifier, VT_B) &&
            verifier.VerifyString(b()) &&
@@ -347,8 +347,8 @@ struct C FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   bool mutate_c(bool _c = 0) {
     return SetField<uint8_t>(VT_C, static_cast<uint8_t>(_c), 0);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint8_t>(verifier, VT_C, 1) &&
            verifier.EndTable();
@@ -435,8 +435,8 @@ struct D FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   ::flatbuffers::Vector<::flatbuffers::Offset<void>> *mutable_test_vector_of_union() {
     return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<void>> *>(VT_TEST_VECTOR_OF_UNION);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int32_t>(verifier, VT_TEST_UNION_TYPE, 1) &&
            VerifyOffset(verifier, VT_TEST_UNION) &&
@@ -682,8 +682,8 @@ inline ::flatbuffers::Offset<D> D::Pack(::flatbuffers::FlatBufferBuilder &_fbb,
       _test_vector_of_union);
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyABC(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, ABC type) {
+template <bool B>
+inline bool VerifyABC(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, ABC type) {
   switch (type) {
     case ABC::NONE: {
       return true;
@@ -704,8 +704,8 @@ inline bool VerifyABC(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier
   }
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyABCVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<ABC> *types) {
+template <bool B>
+inline bool VerifyABCVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<ABC> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
diff --git a/tests/union_vector/union_vector_generated.h b/tests/union_vector/union_vector_generated.h
index ddbac9bac36..1117efd80e8 100644
--- a/tests/union_vector/union_vector_generated.h
+++ b/tests/union_vector/union_vector_generated.h
@@ -212,10 +212,10 @@ inline bool operator!=(const CharacterUnion &lhs, const CharacterUnion &rhs) {
     return !(lhs == rhs);
 }
 
-template <bool TrackBufferSize = false>
-bool VerifyCharacter(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Character type);
-template <bool TrackBufferSize = false>
-bool VerifyCharacterVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
+template <bool B = false>
+bool VerifyCharacter(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, Character type);
+template <bool B = false>
+bool VerifyCharacterVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
 
 enum Gadget : uint8_t {
   Gadget_NONE = 0,
@@ -347,10 +347,10 @@ inline bool operator!=(const GadgetUnion &lhs, const GadgetUnion &rhs) {
     return !(lhs == rhs);
 }
 
-template <bool TrackBufferSize = false>
-bool VerifyGadget(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Gadget type);
-template <bool TrackBufferSize = false>
-bool VerifyGadgetVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
+template <bool B = false>
+bool VerifyGadget(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, Gadget type);
+template <bool B = false>
+bool VerifyGadgetVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types);
 
 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Rapunzel FLATBUFFERS_FINAL_CLASS {
  private:
@@ -471,8 +471,8 @@ struct Attacker FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   bool mutate_sword_attack_damage(int32_t _sword_attack_damage = 0) {
     return SetField<int32_t>(VT_SWORD_ATTACK_DAMAGE, _sword_attack_damage, 0);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int32_t>(verifier, VT_SWORD_ATTACK_DAMAGE, 4) &&
            verifier.EndTable();
@@ -530,8 +530,8 @@ struct HandFan FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   bool mutate_length(int32_t _length = 0) {
     return SetField<int32_t>(VT_LENGTH, _length, 0);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int32_t>(verifier, VT_LENGTH, 4) &&
            verifier.EndTable();
@@ -626,8 +626,8 @@ struct Movie FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   ::flatbuffers::Vector<::flatbuffers::Offset<void>> *mutable_characters() {
     return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<void>> *>(VT_CHARACTERS);
   }
-  template <bool TrackBufferSize = false>
-  bool Verify(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint8_t>(verifier, VT_MAIN_CHARACTER_TYPE, 1) &&
            VerifyOffset(verifier, VT_MAIN_CHARACTER) &&
@@ -824,8 +824,8 @@ inline ::flatbuffers::Offset<Movie> Movie::Pack(::flatbuffers::FlatBufferBuilder
       _characters);
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyCharacter(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Character type) {
+template <bool B>
+inline bool VerifyCharacter(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, Character type) {
   switch (type) {
     case Character_NONE: {
       return true;
@@ -855,8 +855,8 @@ inline bool VerifyCharacter(::flatbuffers::VerifierTemplate<TrackBufferSize> &ve
   }
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyCharacterVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
+template <bool B>
+inline bool VerifyCharacterVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@@ -999,8 +999,8 @@ inline void CharacterUnion::Reset() {
   type = Character_NONE;
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyGadget(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const void *obj, Gadget type) {
+template <bool B>
+inline bool VerifyGadget(::flatbuffers::VerifierTemplate<B> &verifier, const void *obj, Gadget type) {
   switch (type) {
     case Gadget_NONE: {
       return true;
@@ -1016,8 +1016,8 @@ inline bool VerifyGadget(::flatbuffers::VerifierTemplate<TrackBufferSize> &verif
   }
 }
 
-template <bool TrackBufferSize>
-inline bool VerifyGadgetVector(::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
+template <bool B>
+inline bool VerifyGadgetVector(::flatbuffers::VerifierTemplate<B> &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<uint8_t> *types) {
   if (!values || !types) return !values && !types;
   if (values->size() != types->size()) return false;
   for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
@@ -1263,15 +1263,15 @@ inline bool SizePrefixedMovieBufferHasIdentifier(const void *buf) {
       buf, MovieIdentifier(), true);
 }
 
-template <bool TrackBufferSize = false>
+template <bool B = false>
 inline bool VerifyMovieBuffer(
-    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
   return verifier.template VerifyBuffer<Movie>(MovieIdentifier());
 }
 
-template <bool TrackBufferSize = false>
+template <bool B = false>
 inline bool VerifySizePrefixedMovieBuffer(
-    ::flatbuffers::VerifierTemplate<TrackBufferSize> &verifier) {
+    ::flatbuffers::VerifierTemplate<B> &verifier) {
   return verifier.template VerifySizePrefixedBuffer<Movie>(MovieIdentifier());
 }
 

From bdaac7a4a6b92b9e98e6a79a282bb9a8aaf323a6 Mon Sep 17 00:00:00 2001
From: Fergus Henderson <fergus@google.com>
Date: Mon, 10 Nov 2025 15:19:08 +0000
Subject: [PATCH 4/4] Update generated files.

---
 tests/native_type_test_generated.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/native_type_test_generated.h b/tests/native_type_test_generated.h
index 48a33c6438c..e128138487e 100644
--- a/tests/native_type_test_generated.h
+++ b/tests/native_type_test_generated.h
@@ -150,7 +150,8 @@ struct Matrix FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   ::flatbuffers::Vector<float> *mutable_values() {
     return GetPointer<::flatbuffers::Vector<float> *>(VT_VALUES);
   }
-  bool Verify(::flatbuffers::Verifier &verifier) const {
+  template <bool B = false>
+  bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<int32_t>(verifier, VT_ROWS, 4) &&
            VerifyField<int32_t>(verifier, VT_COLUMNS, 4) &&