diff --git a/.gitmodules b/.gitmodules
new file mode 100644
index 0000000..fa78bd5
--- /dev/null
+++ b/.gitmodules
@@ -0,0 +1,3 @@
+[submodule "third_party/flatbuffers"]
+	path = third_party/flatbuffers
+	url = https://github.com/google/flatbuffers.git
diff --git a/.travis.yml b/.travis.yml
index e1ae0da..34a5fca 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -28,6 +28,7 @@
     - sudo apt-get install libgoogle-perftools-dev
     - sudo apt-get install python3 python3-dev
     - eval "${MATRIX_EVAL}"
+    - git submodule update --init --recursive
 
 install:
 
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 771e801..fafa1ea 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -197,6 +197,7 @@
 add_executable(surelog ${surelog_SRC})
 add_dependencies(surelog flatc)
 add_dependencies(surelog antlr4_static)
+add_dependencies(surelog flatbuffers)
 
 add_dependencies(surelog GenerateParser)
 add_dependencies(surelog GenerateSerializer)
@@ -210,5 +211,5 @@
 #)
 
 target_link_libraries(
-  surelog -L${PROJECT_SOURCE_DIR}/dist/ libantlr4-runtime.a dl util m rt pthread
+  surelog -L${PROJECT_SOURCE_DIR}/dist/ libantlr4-runtime.a -L${PROJECT_SOURCE_DIR}/build/third_party/flatbuffers libflatbuffers.a dl util m rt pthread
 )
diff --git a/INSTALL.md b/INSTALL.md
index 74107fd..be04204 100644
--- a/INSTALL.md
+++ b/INSTALL.md
@@ -22,6 +22,8 @@
 
 * Surelog Source code
   * git clone https://github.com/alainmarcel/Surelog.git
+  * cd Surelog
+  * git submodule update --init --recursive
 
 * Build
   * make
diff --git a/Makefile b/Makefile
index f7ba901..8e2017f 100644
--- a/Makefile
+++ b/Makefile
@@ -1,8 +1,8 @@
 release:
 	mkdir -p build/tests;
 	mkdir -p dist;
-	cd build; cmake ../; make -j 4
-	cd build; ../src/release.tcl "release tcmalloc"
+	cd build; cmake ../ -DCMAKE_BUILD_TYPE=Release; make -j 4
+	cd build; ../src/release.tcl release show_diff
 	cd build; ../tests/regression.tcl mt=0
 
 test:
diff --git a/src/Cache/header_generated.h b/src/Cache/header_generated.h
index 596c8cf..9b9169e 100644
--- a/src/Cache/header_generated.h
+++ b/src/Cache/header_generated.h
@@ -18,7 +18,7 @@
 struct TimeInfo;
 
 struct Header FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
-  enum {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_M_SL_VERSION = 4,
     VT_M_FLB_VERSION = 6,
     VT_M_SL_DATE_COMPILED = 8,
@@ -42,16 +42,16 @@
   }
   bool Verify(flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
-           VerifyField<flatbuffers::uoffset_t>(verifier, VT_M_SL_VERSION) &&
-           verifier.Verify(m_sl_version()) &&
-           VerifyField<flatbuffers::uoffset_t>(verifier, VT_M_FLB_VERSION) &&
-           verifier.Verify(m_flb_version()) &&
-           VerifyField<flatbuffers::uoffset_t>(verifier, VT_M_SL_DATE_COMPILED) &&
-           verifier.Verify(m_sl_date_compiled()) &&
-           VerifyField<flatbuffers::uoffset_t>(verifier, VT_M_FILE_DATE_COMPILED) &&
-           verifier.Verify(m_file_date_compiled()) &&
-           VerifyField<flatbuffers::uoffset_t>(verifier, VT_M_FILE) &&
-           verifier.Verify(m_file()) &&
+           VerifyOffset(verifier, VT_M_SL_VERSION) &&
+           verifier.VerifyString(m_sl_version()) &&
+           VerifyOffset(verifier, VT_M_FLB_VERSION) &&
+           verifier.VerifyString(m_flb_version()) &&
+           VerifyOffset(verifier, VT_M_SL_DATE_COMPILED) &&
+           verifier.VerifyString(m_sl_date_compiled()) &&
+           VerifyOffset(verifier, VT_M_FILE_DATE_COMPILED) &&
+           verifier.VerifyString(m_file_date_compiled()) &&
+           VerifyOffset(verifier, VT_M_FILE) &&
+           verifier.VerifyString(m_file()) &&
            verifier.EndTable();
   }
 };
@@ -74,13 +74,13 @@
   void add_m_file(flatbuffers::Offset<flatbuffers::String> m_file) {
     fbb_.AddOffset(Header::VT_M_FILE, m_file);
   }
-  HeaderBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit HeaderBuilder(flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
   HeaderBuilder &operator=(const HeaderBuilder &);
   flatbuffers::Offset<Header> Finish() {
-    const auto end = fbb_.EndTable(start_, 5);
+    const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Header>(end);
     return o;
   }
@@ -109,30 +109,35 @@
     const char *m_sl_date_compiled = nullptr,
     const char *m_file_date_compiled = nullptr,
     const char *m_file = nullptr) {
+  auto m_sl_version__ = m_sl_version ? _fbb.CreateString(m_sl_version) : 0;
+  auto m_flb_version__ = m_flb_version ? _fbb.CreateString(m_flb_version) : 0;
+  auto m_sl_date_compiled__ = m_sl_date_compiled ? _fbb.CreateString(m_sl_date_compiled) : 0;
+  auto m_file_date_compiled__ = m_file_date_compiled ? _fbb.CreateString(m_file_date_compiled) : 0;
+  auto m_file__ = m_file ? _fbb.CreateString(m_file) : 0;
   return SURELOG::CACHE::CreateHeader(
       _fbb,
-      m_sl_version ? _fbb.CreateString(m_sl_version) : 0,
-      m_flb_version ? _fbb.CreateString(m_flb_version) : 0,
-      m_sl_date_compiled ? _fbb.CreateString(m_sl_date_compiled) : 0,
-      m_file_date_compiled ? _fbb.CreateString(m_file_date_compiled) : 0,
-      m_file ? _fbb.CreateString(m_file) : 0);
+      m_sl_version__,
+      m_flb_version__,
+      m_sl_date_compiled__,
+      m_file_date_compiled__,
+      m_file__);
 }
 
 struct Error FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
-  enum {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_M_LOCATIONS = 4,
     VT_M_ERRORID = 6
   };
-  const flatbuffers::Vector<flatbuffers::Offset<Location>> *m_locations() const {
-    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Location>> *>(VT_M_LOCATIONS);
+  const flatbuffers::Vector<flatbuffers::Offset<SURELOG::CACHE::Location>> *m_locations() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<SURELOG::CACHE::Location>> *>(VT_M_LOCATIONS);
   }
   uint32_t m_errorId() const {
     return GetField<uint32_t>(VT_M_ERRORID, 0);
   }
   bool Verify(flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
-           VerifyField<flatbuffers::uoffset_t>(verifier, VT_M_LOCATIONS) &&
-           verifier.Verify(m_locations()) &&
+           VerifyOffset(verifier, VT_M_LOCATIONS) &&
+           verifier.VerifyVector(m_locations()) &&
            verifier.VerifyVectorOfTables(m_locations()) &&
            VerifyField<uint32_t>(verifier, VT_M_ERRORID) &&
            verifier.EndTable();
@@ -142,19 +147,19 @@
 struct ErrorBuilder {
   flatbuffers::FlatBufferBuilder &fbb_;
   flatbuffers::uoffset_t start_;
-  void add_m_locations(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Location>>> m_locations) {
+  void add_m_locations(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<SURELOG::CACHE::Location>>> m_locations) {
     fbb_.AddOffset(Error::VT_M_LOCATIONS, m_locations);
   }
   void add_m_errorId(uint32_t m_errorId) {
     fbb_.AddElement<uint32_t>(Error::VT_M_ERRORID, m_errorId, 0);
   }
-  ErrorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit ErrorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
   ErrorBuilder &operator=(const ErrorBuilder &);
   flatbuffers::Offset<Error> Finish() {
-    const auto end = fbb_.EndTable(start_, 2);
+    const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Error>(end);
     return o;
   }
@@ -162,7 +167,7 @@
 
 inline flatbuffers::Offset<Error> CreateError(
     flatbuffers::FlatBufferBuilder &_fbb,
-    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Location>>> m_locations = 0,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<SURELOG::CACHE::Location>>> m_locations = 0,
     uint32_t m_errorId = 0) {
   ErrorBuilder builder_(_fbb);
   builder_.add_m_errorId(m_errorId);
@@ -172,16 +177,17 @@
 
 inline flatbuffers::Offset<Error> CreateErrorDirect(
     flatbuffers::FlatBufferBuilder &_fbb,
-    const std::vector<flatbuffers::Offset<Location>> *m_locations = nullptr,
+    const std::vector<flatbuffers::Offset<SURELOG::CACHE::Location>> *m_locations = nullptr,
     uint32_t m_errorId = 0) {
+  auto m_locations__ = m_locations ? _fbb.CreateVector<flatbuffers::Offset<SURELOG::CACHE::Location>>(*m_locations) : 0;
   return SURELOG::CACHE::CreateError(
       _fbb,
-      m_locations ? _fbb.CreateVector<flatbuffers::Offset<Location>>(*m_locations) : 0,
+      m_locations__,
       m_errorId);
 }
 
 struct Location FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
-  enum {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_M_FILEID = 4,
     VT_M_LINE = 6,
     VT_M_COLUMN = 8,
@@ -224,13 +230,13 @@
   void add_m_object(uint64_t m_object) {
     fbb_.AddElement<uint64_t>(Location::VT_M_OBJECT, m_object, 0);
   }
-  LocationBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit LocationBuilder(flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
   LocationBuilder &operator=(const LocationBuilder &);
   flatbuffers::Offset<Location> Finish() {
-    const auto end = fbb_.EndTable(start_, 4);
+    const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Location>(end);
     return o;
   }
@@ -251,7 +257,7 @@
 }
 
 struct TimeInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
-  enum {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_M_TYPE = 4,
     VT_M_FILEID = 6,
     VT_M_LINE = 8,
@@ -318,13 +324,13 @@
   void add_m_timePrecisionValue(double m_timePrecisionValue) {
     fbb_.AddElement<double>(TimeInfo::VT_M_TIMEPRECISIONVALUE, m_timePrecisionValue, 0.0);
   }
-  TimeInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit TimeInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
   TimeInfoBuilder &operator=(const TimeInfoBuilder &);
   flatbuffers::Offset<TimeInfo> Finish() {
-    const auto end = fbb_.EndTable(start_, 7);
+    const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<TimeInfo>(end);
     return o;
   }
diff --git a/src/Cache/parser_generated.h b/src/Cache/parser_generated.h
index 767195f..718684c 100644
--- a/src/Cache/parser_generated.h
+++ b/src/Cache/parser_generated.h
@@ -17,7 +17,7 @@
 
 struct ParseCache;
 
-MANUALLY_ALIGNED_STRUCT(8) VObject FLATBUFFERS_FINAL_CLASS {
+FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) VObject FLATBUFFERS_FINAL_CLASS {
  private:
   uint64_t m_field1_;
   uint64_t m_field2_;
@@ -25,10 +25,7 @@
 
  public:
   VObject() {
-    memset(this, 0, sizeof(VObject));
-  }
-  VObject(const VObject &_o) {
-    memcpy(this, &_o, sizeof(VObject));
+    memset(static_cast<void *>(this), 0, sizeof(VObject));
   }
   VObject(uint64_t _m_field1, uint64_t _m_field2, uint64_t _m_field3)
       : m_field1_(flatbuffers::EndianScalar(_m_field1)),
@@ -45,10 +42,10 @@
     return flatbuffers::EndianScalar(m_field3_);
   }
 };
-STRUCT_END(VObject, 24);
+FLATBUFFERS_STRUCT_END(VObject, 24);
 
 struct DesignElement FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
-  enum {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_M_NAME = 4,
     VT_M_FILEID = 6,
     VT_M_TYPE = 8,
@@ -89,7 +86,7 @@
            VerifyField<uint32_t>(verifier, VT_M_TYPE) &&
            VerifyField<uint64_t>(verifier, VT_M_UNIQUEID) &&
            VerifyField<uint32_t>(verifier, VT_M_LINE) &&
-           VerifyField<flatbuffers::uoffset_t>(verifier, VT_M_TIMEINFO) &&
+           VerifyOffset(verifier, VT_M_TIMEINFO) &&
            verifier.VerifyTable(m_timeInfo()) &&
            VerifyField<uint64_t>(verifier, VT_M_PARENT) &&
            VerifyField<uint32_t>(verifier, VT_M_NODE) &&
@@ -124,13 +121,13 @@
   void add_m_node(uint32_t m_node) {
     fbb_.AddElement<uint32_t>(DesignElement::VT_M_NODE, m_node, 0);
   }
-  DesignElementBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit DesignElementBuilder(flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
   DesignElementBuilder &operator=(const DesignElementBuilder &);
   flatbuffers::Offset<DesignElement> Finish() {
-    const auto end = fbb_.EndTable(start_, 8);
+    const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<DesignElement>(end);
     return o;
   }
@@ -159,7 +156,7 @@
 }
 
 struct ParseCache FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
-  enum {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_M_HEADER = 4,
     VT_M_ERRORS = 6,
     VT_M_SYMBOLS = 8,
@@ -175,27 +172,27 @@
   const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *m_symbols() const {
     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_M_SYMBOLS);
   }
-  const flatbuffers::Vector<flatbuffers::Offset<DesignElement>> *m_elements() const {
-    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<DesignElement>> *>(VT_M_ELEMENTS);
+  const flatbuffers::Vector<flatbuffers::Offset<SURELOG::PARSECACHE::DesignElement>> *m_elements() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<SURELOG::PARSECACHE::DesignElement>> *>(VT_M_ELEMENTS);
   }
-  const flatbuffers::Vector<const VObject *> *m_objects() const {
-    return GetPointer<const flatbuffers::Vector<const VObject *> *>(VT_M_OBJECTS);
+  const flatbuffers::Vector<const SURELOG::PARSECACHE::VObject *> *m_objects() const {
+    return GetPointer<const flatbuffers::Vector<const SURELOG::PARSECACHE::VObject *> *>(VT_M_OBJECTS);
   }
   bool Verify(flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
-           VerifyField<flatbuffers::uoffset_t>(verifier, VT_M_HEADER) &&
+           VerifyOffset(verifier, VT_M_HEADER) &&
            verifier.VerifyTable(m_header()) &&
-           VerifyField<flatbuffers::uoffset_t>(verifier, VT_M_ERRORS) &&
-           verifier.Verify(m_errors()) &&
+           VerifyOffset(verifier, VT_M_ERRORS) &&
+           verifier.VerifyVector(m_errors()) &&
            verifier.VerifyVectorOfTables(m_errors()) &&
-           VerifyField<flatbuffers::uoffset_t>(verifier, VT_M_SYMBOLS) &&
-           verifier.Verify(m_symbols()) &&
+           VerifyOffset(verifier, VT_M_SYMBOLS) &&
+           verifier.VerifyVector(m_symbols()) &&
            verifier.VerifyVectorOfStrings(m_symbols()) &&
-           VerifyField<flatbuffers::uoffset_t>(verifier, VT_M_ELEMENTS) &&
-           verifier.Verify(m_elements()) &&
+           VerifyOffset(verifier, VT_M_ELEMENTS) &&
+           verifier.VerifyVector(m_elements()) &&
            verifier.VerifyVectorOfTables(m_elements()) &&
-           VerifyField<flatbuffers::uoffset_t>(verifier, VT_M_OBJECTS) &&
-           verifier.Verify(m_objects()) &&
+           VerifyOffset(verifier, VT_M_OBJECTS) &&
+           verifier.VerifyVector(m_objects()) &&
            verifier.EndTable();
   }
 };
@@ -212,19 +209,19 @@
   void add_m_symbols(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> m_symbols) {
     fbb_.AddOffset(ParseCache::VT_M_SYMBOLS, m_symbols);
   }
-  void add_m_elements(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<DesignElement>>> m_elements) {
+  void add_m_elements(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<SURELOG::PARSECACHE::DesignElement>>> m_elements) {
     fbb_.AddOffset(ParseCache::VT_M_ELEMENTS, m_elements);
   }
-  void add_m_objects(flatbuffers::Offset<flatbuffers::Vector<const VObject *>> m_objects) {
+  void add_m_objects(flatbuffers::Offset<flatbuffers::Vector<const SURELOG::PARSECACHE::VObject *>> m_objects) {
     fbb_.AddOffset(ParseCache::VT_M_OBJECTS, m_objects);
   }
-  ParseCacheBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit ParseCacheBuilder(flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
   ParseCacheBuilder &operator=(const ParseCacheBuilder &);
   flatbuffers::Offset<ParseCache> Finish() {
-    const auto end = fbb_.EndTable(start_, 5);
+    const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<ParseCache>(end);
     return o;
   }
@@ -235,8 +232,8 @@
     flatbuffers::Offset<SURELOG::CACHE::Header> m_header = 0,
     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<SURELOG::CACHE::Error>>> m_errors = 0,
     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> m_symbols = 0,
-    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<DesignElement>>> m_elements = 0,
-    flatbuffers::Offset<flatbuffers::Vector<const VObject *>> m_objects = 0) {
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<SURELOG::PARSECACHE::DesignElement>>> m_elements = 0,
+    flatbuffers::Offset<flatbuffers::Vector<const SURELOG::PARSECACHE::VObject *>> m_objects = 0) {
   ParseCacheBuilder builder_(_fbb);
   builder_.add_m_objects(m_objects);
   builder_.add_m_elements(m_elements);
@@ -251,21 +248,29 @@
     flatbuffers::Offset<SURELOG::CACHE::Header> m_header = 0,
     const std::vector<flatbuffers::Offset<SURELOG::CACHE::Error>> *m_errors = nullptr,
     const std::vector<flatbuffers::Offset<flatbuffers::String>> *m_symbols = nullptr,
-    const std::vector<flatbuffers::Offset<DesignElement>> *m_elements = nullptr,
-    const std::vector<const VObject *> *m_objects = nullptr) {
+    const std::vector<flatbuffers::Offset<SURELOG::PARSECACHE::DesignElement>> *m_elements = nullptr,
+    const std::vector<SURELOG::PARSECACHE::VObject> *m_objects = nullptr) {
+  auto m_errors__ = m_errors ? _fbb.CreateVector<flatbuffers::Offset<SURELOG::CACHE::Error>>(*m_errors) : 0;
+  auto m_symbols__ = m_symbols ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*m_symbols) : 0;
+  auto m_elements__ = m_elements ? _fbb.CreateVector<flatbuffers::Offset<SURELOG::PARSECACHE::DesignElement>>(*m_elements) : 0;
+  auto m_objects__ = m_objects ? _fbb.CreateVectorOfStructs<SURELOG::PARSECACHE::VObject>(*m_objects) : 0;
   return SURELOG::PARSECACHE::CreateParseCache(
       _fbb,
       m_header,
-      m_errors ? _fbb.CreateVector<flatbuffers::Offset<SURELOG::CACHE::Error>>(*m_errors) : 0,
-      m_symbols ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*m_symbols) : 0,
-      m_elements ? _fbb.CreateVector<flatbuffers::Offset<DesignElement>>(*m_elements) : 0,
-      m_objects ? _fbb.CreateVector<const VObject *>(*m_objects) : 0);
+      m_errors__,
+      m_symbols__,
+      m_elements__,
+      m_objects__);
 }
 
 inline const SURELOG::PARSECACHE::ParseCache *GetParseCache(const void *buf) {
   return flatbuffers::GetRoot<SURELOG::PARSECACHE::ParseCache>(buf);
 }
 
+inline const SURELOG::PARSECACHE::ParseCache *GetSizePrefixedParseCache(const void *buf) {
+  return flatbuffers::GetSizePrefixedRoot<SURELOG::PARSECACHE::ParseCache>(buf);
+}
+
 inline const char *ParseCacheIdentifier() {
   return "SLPA";
 }
@@ -280,6 +285,11 @@
   return verifier.VerifyBuffer<SURELOG::PARSECACHE::ParseCache>(ParseCacheIdentifier());
 }
 
+inline bool VerifySizePrefixedParseCacheBuffer(
+    flatbuffers::Verifier &verifier) {
+  return verifier.VerifySizePrefixedBuffer<SURELOG::PARSECACHE::ParseCache>(ParseCacheIdentifier());
+}
+
 inline const char *ParseCacheExtension() {
   return "slpa";
 }
@@ -290,6 +300,12 @@
   fbb.Finish(root, ParseCacheIdentifier());
 }
 
+inline void FinishSizePrefixedParseCacheBuffer(
+    flatbuffers::FlatBufferBuilder &fbb,
+    flatbuffers::Offset<SURELOG::PARSECACHE::ParseCache> root) {
+  fbb.FinishSizePrefixed(root, ParseCacheIdentifier());
+}
+
 }  // namespace PARSECACHE
 }  // namespace SURELOG
 
diff --git a/src/Cache/preproc_generated.h b/src/Cache/preproc_generated.h
index 642a082..bf000e7 100644
--- a/src/Cache/preproc_generated.h
+++ b/src/Cache/preproc_generated.h
@@ -22,8 +22,16 @@
   MacroType_MAX = MacroType_WITH_ARGS
 };
 
-inline const char **EnumNamesMacroType() {
-  static const char *names[] = {
+inline const MacroType (&EnumValuesMacroType())[2] {
+  static const MacroType values[] = {
+    MacroType_NO_ARGS,
+    MacroType_WITH_ARGS
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesMacroType() {
+  static const char * const names[3] = {
     "NO_ARGS",
     "WITH_ARGS",
     nullptr
@@ -32,12 +40,13 @@
 }
 
 inline const char *EnumNameMacroType(MacroType e) {
-  const size_t index = static_cast<int>(e);
+  if (e < MacroType_NO_ARGS || e > MacroType_WITH_ARGS) return "";
+  const size_t index = static_cast<size_t>(e);
   return EnumNamesMacroType()[index];
 }
 
 struct Macro FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
-  enum {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_M_NAME = 4,
     VT_M_TYPE = 6,
     VT_M_LINE = 8,
@@ -48,8 +57,8 @@
   const flatbuffers::String *m_name() const {
     return GetPointer<const flatbuffers::String *>(VT_M_NAME);
   }
-  MacroType m_type() const {
-    return static_cast<MacroType>(GetField<int8_t>(VT_M_TYPE, 0));
+  SURELOG::MACROCACHE::MacroType m_type() const {
+    return static_cast<SURELOG::MACROCACHE::MacroType>(GetField<int8_t>(VT_M_TYPE, 0));
   }
   uint32_t m_line() const {
     return GetField<uint32_t>(VT_M_LINE, 0);
@@ -65,16 +74,16 @@
   }
   bool Verify(flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
-           VerifyField<flatbuffers::uoffset_t>(verifier, VT_M_NAME) &&
-           verifier.Verify(m_name()) &&
+           VerifyOffset(verifier, VT_M_NAME) &&
+           verifier.VerifyString(m_name()) &&
            VerifyField<int8_t>(verifier, VT_M_TYPE) &&
            VerifyField<uint32_t>(verifier, VT_M_LINE) &&
            VerifyField<uint16_t>(verifier, VT_M_COLUMN) &&
-           VerifyField<flatbuffers::uoffset_t>(verifier, VT_M_ARGUMENTS) &&
-           verifier.Verify(m_arguments()) &&
+           VerifyOffset(verifier, VT_M_ARGUMENTS) &&
+           verifier.VerifyVector(m_arguments()) &&
            verifier.VerifyVectorOfStrings(m_arguments()) &&
-           VerifyField<flatbuffers::uoffset_t>(verifier, VT_M_TOKENS) &&
-           verifier.Verify(m_tokens()) &&
+           VerifyOffset(verifier, VT_M_TOKENS) &&
+           verifier.VerifyVector(m_tokens()) &&
            verifier.VerifyVectorOfStrings(m_tokens()) &&
            verifier.EndTable();
   }
@@ -86,7 +95,7 @@
   void add_m_name(flatbuffers::Offset<flatbuffers::String> m_name) {
     fbb_.AddOffset(Macro::VT_M_NAME, m_name);
   }
-  void add_m_type(MacroType m_type) {
+  void add_m_type(SURELOG::MACROCACHE::MacroType m_type) {
     fbb_.AddElement<int8_t>(Macro::VT_M_TYPE, static_cast<int8_t>(m_type), 0);
   }
   void add_m_line(uint32_t m_line) {
@@ -101,13 +110,13 @@
   void add_m_tokens(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> m_tokens) {
     fbb_.AddOffset(Macro::VT_M_TOKENS, m_tokens);
   }
-  MacroBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit MacroBuilder(flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
   MacroBuilder &operator=(const MacroBuilder &);
   flatbuffers::Offset<Macro> Finish() {
-    const auto end = fbb_.EndTable(start_, 6);
+    const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Macro>(end);
     return o;
   }
@@ -116,7 +125,7 @@
 inline flatbuffers::Offset<Macro> CreateMacro(
     flatbuffers::FlatBufferBuilder &_fbb,
     flatbuffers::Offset<flatbuffers::String> m_name = 0,
-    MacroType m_type = MacroType_NO_ARGS,
+    SURELOG::MACROCACHE::MacroType m_type = SURELOG::MACROCACHE::MacroType_NO_ARGS,
     uint32_t m_line = 0,
     uint16_t m_column = 0,
     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> m_arguments = 0,
@@ -134,23 +143,26 @@
 inline flatbuffers::Offset<Macro> CreateMacroDirect(
     flatbuffers::FlatBufferBuilder &_fbb,
     const char *m_name = nullptr,
-    MacroType m_type = MacroType_NO_ARGS,
+    SURELOG::MACROCACHE::MacroType m_type = SURELOG::MACROCACHE::MacroType_NO_ARGS,
     uint32_t m_line = 0,
     uint16_t m_column = 0,
     const std::vector<flatbuffers::Offset<flatbuffers::String>> *m_arguments = nullptr,
     const std::vector<flatbuffers::Offset<flatbuffers::String>> *m_tokens = nullptr) {
+  auto m_name__ = m_name ? _fbb.CreateString(m_name) : 0;
+  auto m_arguments__ = m_arguments ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*m_arguments) : 0;
+  auto m_tokens__ = m_tokens ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*m_tokens) : 0;
   return SURELOG::MACROCACHE::CreateMacro(
       _fbb,
-      m_name ? _fbb.CreateString(m_name) : 0,
+      m_name__,
       m_type,
       m_line,
       m_column,
-      m_arguments ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*m_arguments) : 0,
-      m_tokens ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*m_tokens) : 0);
+      m_arguments__,
+      m_tokens__);
 }
 
 struct PPCache FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
-  enum {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_M_HEADER = 4,
     VT_M_MACROS = 6,
     VT_M_INCLUDES = 8,
@@ -164,8 +176,8 @@
   const SURELOG::CACHE::Header *m_header() const {
     return GetPointer<const SURELOG::CACHE::Header *>(VT_M_HEADER);
   }
-  const flatbuffers::Vector<flatbuffers::Offset<Macro>> *m_macros() const {
-    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Macro>> *>(VT_M_MACROS);
+  const flatbuffers::Vector<flatbuffers::Offset<SURELOG::MACROCACHE::Macro>> *m_macros() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<SURELOG::MACROCACHE::Macro>> *>(VT_M_MACROS);
   }
   const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *m_includes() const {
     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_M_INCLUDES);
@@ -190,30 +202,30 @@
   }
   bool Verify(flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
-           VerifyField<flatbuffers::uoffset_t>(verifier, VT_M_HEADER) &&
+           VerifyOffset(verifier, VT_M_HEADER) &&
            verifier.VerifyTable(m_header()) &&
-           VerifyField<flatbuffers::uoffset_t>(verifier, VT_M_MACROS) &&
-           verifier.Verify(m_macros()) &&
+           VerifyOffset(verifier, VT_M_MACROS) &&
+           verifier.VerifyVector(m_macros()) &&
            verifier.VerifyVectorOfTables(m_macros()) &&
-           VerifyField<flatbuffers::uoffset_t>(verifier, VT_M_INCLUDES) &&
-           verifier.Verify(m_includes()) &&
+           VerifyOffset(verifier, VT_M_INCLUDES) &&
+           verifier.VerifyVector(m_includes()) &&
            verifier.VerifyVectorOfStrings(m_includes()) &&
-           VerifyField<flatbuffers::uoffset_t>(verifier, VT_M_BODY) &&
-           verifier.Verify(m_body()) &&
-           VerifyField<flatbuffers::uoffset_t>(verifier, VT_M_ERRORS) &&
-           verifier.Verify(m_errors()) &&
+           VerifyOffset(verifier, VT_M_BODY) &&
+           verifier.VerifyString(m_body()) &&
+           VerifyOffset(verifier, VT_M_ERRORS) &&
+           verifier.VerifyVector(m_errors()) &&
            verifier.VerifyVectorOfTables(m_errors()) &&
-           VerifyField<flatbuffers::uoffset_t>(verifier, VT_M_SYMBOLS) &&
-           verifier.Verify(m_symbols()) &&
+           VerifyOffset(verifier, VT_M_SYMBOLS) &&
+           verifier.VerifyVector(m_symbols()) &&
            verifier.VerifyVectorOfStrings(m_symbols()) &&
-           VerifyField<flatbuffers::uoffset_t>(verifier, VT_M_CMD_INCLUDE_PATHS) &&
-           verifier.Verify(m_cmd_include_paths()) &&
+           VerifyOffset(verifier, VT_M_CMD_INCLUDE_PATHS) &&
+           verifier.VerifyVector(m_cmd_include_paths()) &&
            verifier.VerifyVectorOfStrings(m_cmd_include_paths()) &&
-           VerifyField<flatbuffers::uoffset_t>(verifier, VT_M_CMD_DEFINE_OPTIONS) &&
-           verifier.Verify(m_cmd_define_options()) &&
+           VerifyOffset(verifier, VT_M_CMD_DEFINE_OPTIONS) &&
+           verifier.VerifyVector(m_cmd_define_options()) &&
            verifier.VerifyVectorOfStrings(m_cmd_define_options()) &&
-           VerifyField<flatbuffers::uoffset_t>(verifier, VT_M_TIMEINFO) &&
-           verifier.Verify(m_timeInfo()) &&
+           VerifyOffset(verifier, VT_M_TIMEINFO) &&
+           verifier.VerifyVector(m_timeInfo()) &&
            verifier.VerifyVectorOfTables(m_timeInfo()) &&
            verifier.EndTable();
   }
@@ -225,7 +237,7 @@
   void add_m_header(flatbuffers::Offset<SURELOG::CACHE::Header> m_header) {
     fbb_.AddOffset(PPCache::VT_M_HEADER, m_header);
   }
-  void add_m_macros(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Macro>>> m_macros) {
+  void add_m_macros(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<SURELOG::MACROCACHE::Macro>>> m_macros) {
     fbb_.AddOffset(PPCache::VT_M_MACROS, m_macros);
   }
   void add_m_includes(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> m_includes) {
@@ -249,13 +261,13 @@
   void add_m_timeInfo(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<SURELOG::CACHE::TimeInfo>>> m_timeInfo) {
     fbb_.AddOffset(PPCache::VT_M_TIMEINFO, m_timeInfo);
   }
-  PPCacheBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit PPCacheBuilder(flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
   PPCacheBuilder &operator=(const PPCacheBuilder &);
   flatbuffers::Offset<PPCache> Finish() {
-    const auto end = fbb_.EndTable(start_, 9);
+    const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<PPCache>(end);
     return o;
   }
@@ -264,7 +276,7 @@
 inline flatbuffers::Offset<PPCache> CreatePPCache(
     flatbuffers::FlatBufferBuilder &_fbb,
     flatbuffers::Offset<SURELOG::CACHE::Header> m_header = 0,
-    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Macro>>> m_macros = 0,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<SURELOG::MACROCACHE::Macro>>> m_macros = 0,
     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> m_includes = 0,
     flatbuffers::Offset<flatbuffers::String> m_body = 0,
     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<SURELOG::CACHE::Error>>> m_errors = 0,
@@ -288,7 +300,7 @@
 inline flatbuffers::Offset<PPCache> CreatePPCacheDirect(
     flatbuffers::FlatBufferBuilder &_fbb,
     flatbuffers::Offset<SURELOG::CACHE::Header> m_header = 0,
-    const std::vector<flatbuffers::Offset<Macro>> *m_macros = nullptr,
+    const std::vector<flatbuffers::Offset<SURELOG::MACROCACHE::Macro>> *m_macros = nullptr,
     const std::vector<flatbuffers::Offset<flatbuffers::String>> *m_includes = nullptr,
     const char *m_body = nullptr,
     const std::vector<flatbuffers::Offset<SURELOG::CACHE::Error>> *m_errors = nullptr,
@@ -296,23 +308,35 @@
     const std::vector<flatbuffers::Offset<flatbuffers::String>> *m_cmd_include_paths = nullptr,
     const std::vector<flatbuffers::Offset<flatbuffers::String>> *m_cmd_define_options = nullptr,
     const std::vector<flatbuffers::Offset<SURELOG::CACHE::TimeInfo>> *m_timeInfo = nullptr) {
+  auto m_macros__ = m_macros ? _fbb.CreateVector<flatbuffers::Offset<SURELOG::MACROCACHE::Macro>>(*m_macros) : 0;
+  auto m_includes__ = m_includes ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*m_includes) : 0;
+  auto m_body__ = m_body ? _fbb.CreateString(m_body) : 0;
+  auto m_errors__ = m_errors ? _fbb.CreateVector<flatbuffers::Offset<SURELOG::CACHE::Error>>(*m_errors) : 0;
+  auto m_symbols__ = m_symbols ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*m_symbols) : 0;
+  auto m_cmd_include_paths__ = m_cmd_include_paths ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*m_cmd_include_paths) : 0;
+  auto m_cmd_define_options__ = m_cmd_define_options ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*m_cmd_define_options) : 0;
+  auto m_timeInfo__ = m_timeInfo ? _fbb.CreateVector<flatbuffers::Offset<SURELOG::CACHE::TimeInfo>>(*m_timeInfo) : 0;
   return SURELOG::MACROCACHE::CreatePPCache(
       _fbb,
       m_header,
-      m_macros ? _fbb.CreateVector<flatbuffers::Offset<Macro>>(*m_macros) : 0,
-      m_includes ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*m_includes) : 0,
-      m_body ? _fbb.CreateString(m_body) : 0,
-      m_errors ? _fbb.CreateVector<flatbuffers::Offset<SURELOG::CACHE::Error>>(*m_errors) : 0,
-      m_symbols ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*m_symbols) : 0,
-      m_cmd_include_paths ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*m_cmd_include_paths) : 0,
-      m_cmd_define_options ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*m_cmd_define_options) : 0,
-      m_timeInfo ? _fbb.CreateVector<flatbuffers::Offset<SURELOG::CACHE::TimeInfo>>(*m_timeInfo) : 0);
+      m_macros__,
+      m_includes__,
+      m_body__,
+      m_errors__,
+      m_symbols__,
+      m_cmd_include_paths__,
+      m_cmd_define_options__,
+      m_timeInfo__);
 }
 
 inline const SURELOG::MACROCACHE::PPCache *GetPPCache(const void *buf) {
   return flatbuffers::GetRoot<SURELOG::MACROCACHE::PPCache>(buf);
 }
 
+inline const SURELOG::MACROCACHE::PPCache *GetSizePrefixedPPCache(const void *buf) {
+  return flatbuffers::GetSizePrefixedRoot<SURELOG::MACROCACHE::PPCache>(buf);
+}
+
 inline const char *PPCacheIdentifier() {
   return "SLPP";
 }
@@ -327,6 +351,11 @@
   return verifier.VerifyBuffer<SURELOG::MACROCACHE::PPCache>(PPCacheIdentifier());
 }
 
+inline bool VerifySizePrefixedPPCacheBuffer(
+    flatbuffers::Verifier &verifier) {
+  return verifier.VerifySizePrefixedBuffer<SURELOG::MACROCACHE::PPCache>(PPCacheIdentifier());
+}
+
 inline const char *PPCacheExtension() {
   return "slpp";
 }
@@ -337,6 +366,12 @@
   fbb.Finish(root, PPCacheIdentifier());
 }
 
+inline void FinishSizePrefixedPPCacheBuffer(
+    flatbuffers::FlatBufferBuilder &fbb,
+    flatbuffers::Offset<SURELOG::MACROCACHE::PPCache> root) {
+  fbb.FinishSizePrefixed(root, PPCacheIdentifier());
+}
+
 }  // namespace MACROCACHE
 }  // namespace SURELOG
 
diff --git a/src/Cache/python_api_generated.h b/src/Cache/python_api_generated.h
index 383084a..a52e0c3 100644
--- a/src/Cache/python_api_generated.h
+++ b/src/Cache/python_api_generated.h
@@ -14,7 +14,7 @@
 struct PythonAPICache;
 
 struct PythonAPICache FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
-  enum {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
     VT_M_HEADER = 4,
     VT_M_PYTHON_SCRIPT_FILE = 6,
     VT_M_ERRORS = 8,
@@ -34,15 +34,15 @@
   }
   bool Verify(flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
-           VerifyField<flatbuffers::uoffset_t>(verifier, VT_M_HEADER) &&
+           VerifyOffset(verifier, VT_M_HEADER) &&
            verifier.VerifyTable(m_header()) &&
-           VerifyField<flatbuffers::uoffset_t>(verifier, VT_M_PYTHON_SCRIPT_FILE) &&
-           verifier.Verify(m_python_script_file()) &&
-           VerifyField<flatbuffers::uoffset_t>(verifier, VT_M_ERRORS) &&
-           verifier.Verify(m_errors()) &&
+           VerifyOffset(verifier, VT_M_PYTHON_SCRIPT_FILE) &&
+           verifier.VerifyString(m_python_script_file()) &&
+           VerifyOffset(verifier, VT_M_ERRORS) &&
+           verifier.VerifyVector(m_errors()) &&
            verifier.VerifyVectorOfTables(m_errors()) &&
-           VerifyField<flatbuffers::uoffset_t>(verifier, VT_M_SYMBOLS) &&
-           verifier.Verify(m_symbols()) &&
+           VerifyOffset(verifier, VT_M_SYMBOLS) &&
+           verifier.VerifyVector(m_symbols()) &&
            verifier.VerifyVectorOfStrings(m_symbols()) &&
            verifier.EndTable();
   }
@@ -63,13 +63,13 @@
   void add_m_symbols(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> m_symbols) {
     fbb_.AddOffset(PythonAPICache::VT_M_SYMBOLS, m_symbols);
   }
-  PythonAPICacheBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+  explicit PythonAPICacheBuilder(flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
   PythonAPICacheBuilder &operator=(const PythonAPICacheBuilder &);
   flatbuffers::Offset<PythonAPICache> Finish() {
-    const auto end = fbb_.EndTable(start_, 4);
+    const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<PythonAPICache>(end);
     return o;
   }
@@ -95,18 +95,25 @@
     const char *m_python_script_file = nullptr,
     const std::vector<flatbuffers::Offset<SURELOG::CACHE::Error>> *m_errors = nullptr,
     const std::vector<flatbuffers::Offset<flatbuffers::String>> *m_symbols = nullptr) {
+  auto m_python_script_file__ = m_python_script_file ? _fbb.CreateString(m_python_script_file) : 0;
+  auto m_errors__ = m_errors ? _fbb.CreateVector<flatbuffers::Offset<SURELOG::CACHE::Error>>(*m_errors) : 0;
+  auto m_symbols__ = m_symbols ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*m_symbols) : 0;
   return SURELOG::PYTHONAPICACHE::CreatePythonAPICache(
       _fbb,
       m_header,
-      m_python_script_file ? _fbb.CreateString(m_python_script_file) : 0,
-      m_errors ? _fbb.CreateVector<flatbuffers::Offset<SURELOG::CACHE::Error>>(*m_errors) : 0,
-      m_symbols ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*m_symbols) : 0);
+      m_python_script_file__,
+      m_errors__,
+      m_symbols__);
 }
 
 inline const SURELOG::PYTHONAPICACHE::PythonAPICache *GetPythonAPICache(const void *buf) {
   return flatbuffers::GetRoot<SURELOG::PYTHONAPICACHE::PythonAPICache>(buf);
 }
 
+inline const SURELOG::PYTHONAPICACHE::PythonAPICache *GetSizePrefixedPythonAPICache(const void *buf) {
+  return flatbuffers::GetSizePrefixedRoot<SURELOG::PYTHONAPICACHE::PythonAPICache>(buf);
+}
+
 inline const char *PythonAPICacheIdentifier() {
   return "SLPY";
 }
@@ -121,6 +128,11 @@
   return verifier.VerifyBuffer<SURELOG::PYTHONAPICACHE::PythonAPICache>(PythonAPICacheIdentifier());
 }
 
+inline bool VerifySizePrefixedPythonAPICacheBuffer(
+    flatbuffers::Verifier &verifier) {
+  return verifier.VerifySizePrefixedBuffer<SURELOG::PYTHONAPICACHE::PythonAPICache>(PythonAPICacheIdentifier());
+}
+
 inline const char *PythonAPICacheExtension() {
   return "slpy";
 }
@@ -131,6 +143,12 @@
   fbb.Finish(root, PythonAPICacheIdentifier());
 }
 
+inline void FinishSizePrefixedPythonAPICacheBuffer(
+    flatbuffers::FlatBufferBuilder &fbb,
+    flatbuffers::Offset<SURELOG::PYTHONAPICACHE::PythonAPICache> root) {
+  fbb.FinishSizePrefixed(root, PythonAPICacheIdentifier());
+}
+
 }  // namespace PYTHONAPICACHE
 }  // namespace SURELOG
 
diff --git a/third_party/flatbuffers b/third_party/flatbuffers
new file mode 160000
index 0000000..6beb9f4
--- /dev/null
+++ b/third_party/flatbuffers
@@ -0,0 +1 @@
+Subproject commit 6beb9f49cb44095c4c17be43f13906c6eb09d7c7