// automatically generated by the FlatBuffers compiler, do not modify


#ifndef FLATBUFFERS_GENERATED_BYTECODE_METADATA_H_
#define FLATBUFFERS_GENERATED_BYTECODE_METADATA_H_

#include "flatbuffers/flatbuffers.h"

// Ensure the included flatbuffers.h is the same version as when this file was
// generated, otherwise it may not be compatible.
static_assert(FLATBUFFERS_VERSION_MAJOR == 24 &&
              FLATBUFFERS_VERSION_MINOR == 3 &&
              FLATBUFFERS_VERSION_REVISION == 7,
             "Non-compatible flatbuffers version included");

namespace metadata {

struct LineInfo;

struct Function;
struct FunctionBuilder;

struct Field;
struct FieldBuilder;

struct UDT;
struct UDTBuilder;

struct EnumVal;
struct EnumValBuilder;

struct Enum;
struct EnumBuilder;

struct Ident;
struct IdentBuilder;

struct SpecIdent;

struct MetadataFile;
struct MetadataFileBuilder;

FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) LineInfo FLATBUFFERS_FINAL_CLASS {
 private:
  int32_t line_;
  int32_t fileidx_;

 public:
  LineInfo()
      : line_(0),
        fileidx_(0) {
  }
  LineInfo(int32_t _line, int32_t _fileidx)
      : line_(::flatbuffers::EndianScalar(_line)),
        fileidx_(::flatbuffers::EndianScalar(_fileidx)) {
  }
  int32_t line() const {
    return ::flatbuffers::EndianScalar(line_);
  }
  int32_t fileidx() const {
    return ::flatbuffers::EndianScalar(fileidx_);
  }
};
FLATBUFFERS_STRUCT_END(LineInfo, 8);

FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) SpecIdent FLATBUFFERS_FINAL_CLASS {
 private:
  int32_t ididx_;
  int32_t typeidx_;
  uint8_t used_as_freevar_;
  int8_t padding0__;  int16_t padding1__;
  int32_t idx_;

 public:
  SpecIdent()
      : ididx_(0),
        typeidx_(0),
        used_as_freevar_(0),
        padding0__(0),
        padding1__(0),
        idx_(0) {
    (void)padding0__;
    (void)padding1__;
  }
  SpecIdent(int32_t _ididx, int32_t _typeidx, bool _used_as_freevar, int32_t _idx)
      : ididx_(::flatbuffers::EndianScalar(_ididx)),
        typeidx_(::flatbuffers::EndianScalar(_typeidx)),
        used_as_freevar_(::flatbuffers::EndianScalar(static_cast<uint8_t>(_used_as_freevar))),
        padding0__(0),
        padding1__(0),
        idx_(::flatbuffers::EndianScalar(_idx)) {
    (void)padding0__;
    (void)padding1__;
  }
  int32_t ididx() const {
    return ::flatbuffers::EndianScalar(ididx_);
  }
  int32_t typeidx() const {
    return ::flatbuffers::EndianScalar(typeidx_);
  }
  bool used_as_freevar() const {
    return ::flatbuffers::EndianScalar(used_as_freevar_) != 0;
  }
  int32_t idx() const {
    return ::flatbuffers::EndianScalar(idx_);
  }
};
FLATBUFFERS_STRUCT_END(SpecIdent, 16);

struct Function FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef FunctionBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NAME = 4
  };
  const ::flatbuffers::String *name() const {
    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_NAME) &&
           verifier.VerifyString(name()) &&
           verifier.EndTable();
  }
};

struct FunctionBuilder {
  typedef Function Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
    fbb_.AddOffset(Function::VT_NAME, name);
  }
  explicit FunctionBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Function> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Function>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<Function> CreateFunction(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> name = 0) {
  FunctionBuilder builder_(_fbb);
  builder_.add_name(name);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<Function> CreateFunctionDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *name = nullptr) {
  auto name__ = name ? _fbb.CreateString(name) : 0;
  return metadata::CreateFunction(
      _fbb,
      name__);
}

struct Field FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef FieldBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NAME = 4,
    VT_OFFSET = 6
  };
  const ::flatbuffers::String *name() const {
    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
  }
  int32_t offset() const {
    return GetField<int32_t>(VT_OFFSET, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_NAME) &&
           verifier.VerifyString(name()) &&
           VerifyField<int32_t>(verifier, VT_OFFSET, 4) &&
           verifier.EndTable();
  }
};

struct FieldBuilder {
  typedef Field Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
    fbb_.AddOffset(Field::VT_NAME, name);
  }
  void add_offset(int32_t offset) {
    fbb_.AddElement<int32_t>(Field::VT_OFFSET, offset, 0);
  }
  explicit FieldBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Field> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Field>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<Field> CreateField(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> name = 0,
    int32_t offset = 0) {
  FieldBuilder builder_(_fbb);
  builder_.add_offset(offset);
  builder_.add_name(name);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<Field> CreateFieldDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *name = nullptr,
    int32_t offset = 0) {
  auto name__ = name ? _fbb.CreateString(name) : 0;
  return metadata::CreateField(
      _fbb,
      name__,
      offset);
}

struct UDT FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef UDTBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NAME = 4,
    VT_IDX = 6,
    VT_FIELDS = 8,
    VT_SIZE = 10,
    VT_SUPER_IDX = 12,
    VT_TYPEIDX = 14
  };
  const ::flatbuffers::String *name() const {
    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
  }
  int32_t idx() const {
    return GetField<int32_t>(VT_IDX, 0);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<metadata::Field>> *fields() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<metadata::Field>> *>(VT_FIELDS);
  }
  int32_t size() const {
    return GetField<int32_t>(VT_SIZE, 0);
  }
  int32_t super_idx() const {
    return GetField<int32_t>(VT_SUPER_IDX, 0);
  }
  int32_t typeidx() const {
    return GetField<int32_t>(VT_TYPEIDX, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_NAME) &&
           verifier.VerifyString(name()) &&
           VerifyField<int32_t>(verifier, VT_IDX, 4) &&
           VerifyOffset(verifier, VT_FIELDS) &&
           verifier.VerifyVector(fields()) &&
           verifier.VerifyVectorOfTables(fields()) &&
           VerifyField<int32_t>(verifier, VT_SIZE, 4) &&
           VerifyField<int32_t>(verifier, VT_SUPER_IDX, 4) &&
           VerifyField<int32_t>(verifier, VT_TYPEIDX, 4) &&
           verifier.EndTable();
  }
};

struct UDTBuilder {
  typedef UDT Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
    fbb_.AddOffset(UDT::VT_NAME, name);
  }
  void add_idx(int32_t idx) {
    fbb_.AddElement<int32_t>(UDT::VT_IDX, idx, 0);
  }
  void add_fields(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<metadata::Field>>> fields) {
    fbb_.AddOffset(UDT::VT_FIELDS, fields);
  }
  void add_size(int32_t size) {
    fbb_.AddElement<int32_t>(UDT::VT_SIZE, size, 0);
  }
  void add_super_idx(int32_t super_idx) {
    fbb_.AddElement<int32_t>(UDT::VT_SUPER_IDX, super_idx, 0);
  }
  void add_typeidx(int32_t typeidx) {
    fbb_.AddElement<int32_t>(UDT::VT_TYPEIDX, typeidx, 0);
  }
  explicit UDTBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<UDT> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<UDT>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<UDT> CreateUDT(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> name = 0,
    int32_t idx = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<metadata::Field>>> fields = 0,
    int32_t size = 0,
    int32_t super_idx = 0,
    int32_t typeidx = 0) {
  UDTBuilder builder_(_fbb);
  builder_.add_typeidx(typeidx);
  builder_.add_super_idx(super_idx);
  builder_.add_size(size);
  builder_.add_fields(fields);
  builder_.add_idx(idx);
  builder_.add_name(name);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<UDT> CreateUDTDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *name = nullptr,
    int32_t idx = 0,
    const std::vector<::flatbuffers::Offset<metadata::Field>> *fields = nullptr,
    int32_t size = 0,
    int32_t super_idx = 0,
    int32_t typeidx = 0) {
  auto name__ = name ? _fbb.CreateString(name) : 0;
  auto fields__ = fields ? _fbb.CreateVector<::flatbuffers::Offset<metadata::Field>>(*fields) : 0;
  return metadata::CreateUDT(
      _fbb,
      name__,
      idx,
      fields__,
      size,
      super_idx,
      typeidx);
}

struct EnumVal FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef EnumValBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NAME = 4,
    VT_VAL = 6
  };
  const ::flatbuffers::String *name() const {
    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
  }
  int64_t val() const {
    return GetField<int64_t>(VT_VAL, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_NAME) &&
           verifier.VerifyString(name()) &&
           VerifyField<int64_t>(verifier, VT_VAL, 8) &&
           verifier.EndTable();
  }
};

struct EnumValBuilder {
  typedef EnumVal Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
    fbb_.AddOffset(EnumVal::VT_NAME, name);
  }
  void add_val(int64_t val) {
    fbb_.AddElement<int64_t>(EnumVal::VT_VAL, val, 0);
  }
  explicit EnumValBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<EnumVal> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<EnumVal>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<EnumVal> CreateEnumVal(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> name = 0,
    int64_t val = 0) {
  EnumValBuilder builder_(_fbb);
  builder_.add_val(val);
  builder_.add_name(name);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<EnumVal> CreateEnumValDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *name = nullptr,
    int64_t val = 0) {
  auto name__ = name ? _fbb.CreateString(name) : 0;
  return metadata::CreateEnumVal(
      _fbb,
      name__,
      val);
}

struct Enum FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef EnumBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NAME = 4,
    VT_VALS = 6,
    VT_FLAGS = 8
  };
  const ::flatbuffers::String *name() const {
    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<metadata::EnumVal>> *vals() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<metadata::EnumVal>> *>(VT_VALS);
  }
  bool flags() const {
    return GetField<uint8_t>(VT_FLAGS, 0) != 0;
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_NAME) &&
           verifier.VerifyString(name()) &&
           VerifyOffset(verifier, VT_VALS) &&
           verifier.VerifyVector(vals()) &&
           verifier.VerifyVectorOfTables(vals()) &&
           VerifyField<uint8_t>(verifier, VT_FLAGS, 1) &&
           verifier.EndTable();
  }
};

struct EnumBuilder {
  typedef Enum Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
    fbb_.AddOffset(Enum::VT_NAME, name);
  }
  void add_vals(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<metadata::EnumVal>>> vals) {
    fbb_.AddOffset(Enum::VT_VALS, vals);
  }
  void add_flags(bool flags) {
    fbb_.AddElement<uint8_t>(Enum::VT_FLAGS, static_cast<uint8_t>(flags), 0);
  }
  explicit EnumBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Enum> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Enum>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<Enum> CreateEnum(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> name = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<metadata::EnumVal>>> vals = 0,
    bool flags = false) {
  EnumBuilder builder_(_fbb);
  builder_.add_vals(vals);
  builder_.add_name(name);
  builder_.add_flags(flags);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<Enum> CreateEnumDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *name = nullptr,
    const std::vector<::flatbuffers::Offset<metadata::EnumVal>> *vals = nullptr,
    bool flags = false) {
  auto name__ = name ? _fbb.CreateString(name) : 0;
  auto vals__ = vals ? _fbb.CreateVector<::flatbuffers::Offset<metadata::EnumVal>>(*vals) : 0;
  return metadata::CreateEnum(
      _fbb,
      name__,
      vals__,
      flags);
}

struct Ident FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef IdentBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NAME = 4,
    VT_READONLY = 6,
    VT_GLOBAL = 8
  };
  const ::flatbuffers::String *name() const {
    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
  }
  bool readonly() const {
    return GetField<uint8_t>(VT_READONLY, 0) != 0;
  }
  bool global() const {
    return GetField<uint8_t>(VT_GLOBAL, 0) != 0;
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_NAME) &&
           verifier.VerifyString(name()) &&
           VerifyField<uint8_t>(verifier, VT_READONLY, 1) &&
           VerifyField<uint8_t>(verifier, VT_GLOBAL, 1) &&
           verifier.EndTable();
  }
};

struct IdentBuilder {
  typedef Ident Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
    fbb_.AddOffset(Ident::VT_NAME, name);
  }
  void add_readonly(bool readonly) {
    fbb_.AddElement<uint8_t>(Ident::VT_READONLY, static_cast<uint8_t>(readonly), 0);
  }
  void add_global(bool global) {
    fbb_.AddElement<uint8_t>(Ident::VT_GLOBAL, static_cast<uint8_t>(global), 0);
  }
  explicit IdentBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Ident> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Ident>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<Ident> CreateIdent(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> name = 0,
    bool readonly = false,
    bool global = false) {
  IdentBuilder builder_(_fbb);
  builder_.add_name(name);
  builder_.add_global(global);
  builder_.add_readonly(readonly);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<Ident> CreateIdentDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *name = nullptr,
    bool readonly = false,
    bool global = false) {
  auto name__ = name ? _fbb.CreateString(name) : 0;
  return metadata::CreateIdent(
      _fbb,
      name__,
      readonly,
      global);
}

struct MetadataFile FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef MetadataFileBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_METADATA_VERSION = 4,
    VT_TYPETABLE = 6,
    VT_STRINGTABLE = 8,
    VT_FILENAMES = 10,
    VT_FUNCTIONS = 12,
    VT_UDTS = 14,
    VT_IDENTS = 16,
    VT_SPECIDENTS = 18,
    VT_ENUMS = 20,
    VT_SER_IDS = 22,
    VT_BUILD_INFO = 24,
    VT_SRC_HASH = 26,
    VT_SUBFUNCTIONS_TO_FUNCTION = 28
  };
  int32_t metadata_version() const {
    return GetField<int32_t>(VT_METADATA_VERSION, 0);
  }
  const ::flatbuffers::Vector<int32_t> *typetable() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_TYPETABLE);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *stringtable() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_STRINGTABLE);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *filenames() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_FILENAMES);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<metadata::Function>> *functions() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<metadata::Function>> *>(VT_FUNCTIONS);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<metadata::UDT>> *udts() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<metadata::UDT>> *>(VT_UDTS);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<metadata::Ident>> *idents() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<metadata::Ident>> *>(VT_IDENTS);
  }
  const ::flatbuffers::Vector<const metadata::SpecIdent *> *specidents() const {
    return GetPointer<const ::flatbuffers::Vector<const metadata::SpecIdent *> *>(VT_SPECIDENTS);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<metadata::Enum>> *enums() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<metadata::Enum>> *>(VT_ENUMS);
  }
  const ::flatbuffers::Vector<int32_t> *ser_ids() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_SER_IDS);
  }
  const ::flatbuffers::String *build_info() const {
    return GetPointer<const ::flatbuffers::String *>(VT_BUILD_INFO);
  }
  uint64_t src_hash() const {
    return GetField<uint64_t>(VT_SRC_HASH, 0);
  }
  const ::flatbuffers::Vector<int32_t> *subfunctions_to_function() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_SUBFUNCTIONS_TO_FUNCTION);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, VT_METADATA_VERSION, 4) &&
           VerifyOffset(verifier, VT_TYPETABLE) &&
           verifier.VerifyVector(typetable()) &&
           VerifyOffset(verifier, VT_STRINGTABLE) &&
           verifier.VerifyVector(stringtable()) &&
           verifier.VerifyVectorOfStrings(stringtable()) &&
           VerifyOffset(verifier, VT_FILENAMES) &&
           verifier.VerifyVector(filenames()) &&
           verifier.VerifyVectorOfStrings(filenames()) &&
           VerifyOffset(verifier, VT_FUNCTIONS) &&
           verifier.VerifyVector(functions()) &&
           verifier.VerifyVectorOfTables(functions()) &&
           VerifyOffset(verifier, VT_UDTS) &&
           verifier.VerifyVector(udts()) &&
           verifier.VerifyVectorOfTables(udts()) &&
           VerifyOffset(verifier, VT_IDENTS) &&
           verifier.VerifyVector(idents()) &&
           verifier.VerifyVectorOfTables(idents()) &&
           VerifyOffset(verifier, VT_SPECIDENTS) &&
           verifier.VerifyVector(specidents()) &&
           VerifyOffset(verifier, VT_ENUMS) &&
           verifier.VerifyVector(enums()) &&
           verifier.VerifyVectorOfTables(enums()) &&
           VerifyOffset(verifier, VT_SER_IDS) &&
           verifier.VerifyVector(ser_ids()) &&
           VerifyOffset(verifier, VT_BUILD_INFO) &&
           verifier.VerifyString(build_info()) &&
           VerifyField<uint64_t>(verifier, VT_SRC_HASH, 8) &&
           VerifyOffset(verifier, VT_SUBFUNCTIONS_TO_FUNCTION) &&
           verifier.VerifyVector(subfunctions_to_function()) &&
           verifier.EndTable();
  }
};

struct MetadataFileBuilder {
  typedef MetadataFile Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_metadata_version(int32_t metadata_version) {
    fbb_.AddElement<int32_t>(MetadataFile::VT_METADATA_VERSION, metadata_version, 0);
  }
  void add_typetable(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> typetable) {
    fbb_.AddOffset(MetadataFile::VT_TYPETABLE, typetable);
  }
  void add_stringtable(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> stringtable) {
    fbb_.AddOffset(MetadataFile::VT_STRINGTABLE, stringtable);
  }
  void add_filenames(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> filenames) {
    fbb_.AddOffset(MetadataFile::VT_FILENAMES, filenames);
  }
  void add_functions(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<metadata::Function>>> functions) {
    fbb_.AddOffset(MetadataFile::VT_FUNCTIONS, functions);
  }
  void add_udts(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<metadata::UDT>>> udts) {
    fbb_.AddOffset(MetadataFile::VT_UDTS, udts);
  }
  void add_idents(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<metadata::Ident>>> idents) {
    fbb_.AddOffset(MetadataFile::VT_IDENTS, idents);
  }
  void add_specidents(::flatbuffers::Offset<::flatbuffers::Vector<const metadata::SpecIdent *>> specidents) {
    fbb_.AddOffset(MetadataFile::VT_SPECIDENTS, specidents);
  }
  void add_enums(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<metadata::Enum>>> enums) {
    fbb_.AddOffset(MetadataFile::VT_ENUMS, enums);
  }
  void add_ser_ids(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> ser_ids) {
    fbb_.AddOffset(MetadataFile::VT_SER_IDS, ser_ids);
  }
  void add_build_info(::flatbuffers::Offset<::flatbuffers::String> build_info) {
    fbb_.AddOffset(MetadataFile::VT_BUILD_INFO, build_info);
  }
  void add_src_hash(uint64_t src_hash) {
    fbb_.AddElement<uint64_t>(MetadataFile::VT_SRC_HASH, src_hash, 0);
  }
  void add_subfunctions_to_function(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> subfunctions_to_function) {
    fbb_.AddOffset(MetadataFile::VT_SUBFUNCTIONS_TO_FUNCTION, subfunctions_to_function);
  }
  explicit MetadataFileBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<MetadataFile> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<MetadataFile>(end);
    return o;
  }
};

inline ::flatbuffers::Offset<MetadataFile> CreateMetadataFile(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int32_t metadata_version = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> typetable = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> stringtable = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> filenames = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<metadata::Function>>> functions = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<metadata::UDT>>> udts = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<metadata::Ident>>> idents = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<const metadata::SpecIdent *>> specidents = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<metadata::Enum>>> enums = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> ser_ids = 0,
    ::flatbuffers::Offset<::flatbuffers::String> build_info = 0,
    uint64_t src_hash = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> subfunctions_to_function = 0) {
  MetadataFileBuilder builder_(_fbb);
  builder_.add_src_hash(src_hash);
  builder_.add_subfunctions_to_function(subfunctions_to_function);
  builder_.add_build_info(build_info);
  builder_.add_ser_ids(ser_ids);
  builder_.add_enums(enums);
  builder_.add_specidents(specidents);
  builder_.add_idents(idents);
  builder_.add_udts(udts);
  builder_.add_functions(functions);
  builder_.add_filenames(filenames);
  builder_.add_stringtable(stringtable);
  builder_.add_typetable(typetable);
  builder_.add_metadata_version(metadata_version);
  return builder_.Finish();
}

inline ::flatbuffers::Offset<MetadataFile> CreateMetadataFileDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int32_t metadata_version = 0,
    const std::vector<int32_t> *typetable = nullptr,
    const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *stringtable = nullptr,
    const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *filenames = nullptr,
    const std::vector<::flatbuffers::Offset<metadata::Function>> *functions = nullptr,
    const std::vector<::flatbuffers::Offset<metadata::UDT>> *udts = nullptr,
    const std::vector<::flatbuffers::Offset<metadata::Ident>> *idents = nullptr,
    const std::vector<metadata::SpecIdent> *specidents = nullptr,
    const std::vector<::flatbuffers::Offset<metadata::Enum>> *enums = nullptr,
    const std::vector<int32_t> *ser_ids = nullptr,
    const char *build_info = nullptr,
    uint64_t src_hash = 0,
    const std::vector<int32_t> *subfunctions_to_function = nullptr) {
  auto typetable__ = typetable ? _fbb.CreateVector<int32_t>(*typetable) : 0;
  auto stringtable__ = stringtable ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*stringtable) : 0;
  auto filenames__ = filenames ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*filenames) : 0;
  auto functions__ = functions ? _fbb.CreateVector<::flatbuffers::Offset<metadata::Function>>(*functions) : 0;
  auto udts__ = udts ? _fbb.CreateVector<::flatbuffers::Offset<metadata::UDT>>(*udts) : 0;
  auto idents__ = idents ? _fbb.CreateVector<::flatbuffers::Offset<metadata::Ident>>(*idents) : 0;
  auto specidents__ = specidents ? _fbb.CreateVectorOfStructs<metadata::SpecIdent>(*specidents) : 0;
  auto enums__ = enums ? _fbb.CreateVector<::flatbuffers::Offset<metadata::Enum>>(*enums) : 0;
  auto ser_ids__ = ser_ids ? _fbb.CreateVector<int32_t>(*ser_ids) : 0;
  auto build_info__ = build_info ? _fbb.CreateString(build_info) : 0;
  auto subfunctions_to_function__ = subfunctions_to_function ? _fbb.CreateVector<int32_t>(*subfunctions_to_function) : 0;
  return metadata::CreateMetadataFile(
      _fbb,
      metadata_version,
      typetable__,
      stringtable__,
      filenames__,
      functions__,
      udts__,
      idents__,
      specidents__,
      enums__,
      ser_ids__,
      build_info__,
      src_hash,
      subfunctions_to_function__);
}

inline const metadata::MetadataFile *GetMetadataFile(const void *buf) {
  return ::flatbuffers::GetRoot<metadata::MetadataFile>(buf);
}

inline const metadata::MetadataFile *GetSizePrefixedMetadataFile(const void *buf) {
  return ::flatbuffers::GetSizePrefixedRoot<metadata::MetadataFile>(buf);
}

inline const char *MetadataFileIdentifier() {
  return "LBCF";
}

inline bool MetadataFileBufferHasIdentifier(const void *buf) {
  return ::flatbuffers::BufferHasIdentifier(
      buf, MetadataFileIdentifier());
}

inline bool SizePrefixedMetadataFileBufferHasIdentifier(const void *buf) {
  return ::flatbuffers::BufferHasIdentifier(
      buf, MetadataFileIdentifier(), true);
}

inline bool VerifyMetadataFileBuffer(
    ::flatbuffers::Verifier &verifier) {
  return verifier.VerifyBuffer<metadata::MetadataFile>(MetadataFileIdentifier());
}

inline bool VerifySizePrefixedMetadataFileBuffer(
    ::flatbuffers::Verifier &verifier) {
  return verifier.VerifySizePrefixedBuffer<metadata::MetadataFile>(MetadataFileIdentifier());
}

inline const char *MetadataFileExtension() {
  return "lbc";
}

inline void FinishMetadataFileBuffer(
    ::flatbuffers::FlatBufferBuilder &fbb,
    ::flatbuffers::Offset<metadata::MetadataFile> root) {
  fbb.Finish(root, MetadataFileIdentifier());
}

inline void FinishSizePrefixedMetadataFileBuffer(
    ::flatbuffers::FlatBufferBuilder &fbb,
    ::flatbuffers::Offset<metadata::MetadataFile> root) {
  fbb.FinishSizePrefixed(root, MetadataFileIdentifier());
}

}  // namespace metadata

#endif  // FLATBUFFERS_GENERATED_BYTECODE_METADATA_H_
