FlatBufferSchema.h

// automatically generated by the FlatBuffers compiler, do not modify
 
#include <RoseFirst.h>
 
 
#ifndef ROSE_BinaryAnalysis_Serialization_FlatBufferSchema_H
#define ROSE_BinaryAnalysis_Serialization_FlatBufferSchema_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 == 25 &&
              FLATBUFFERS_VERSION_MINOR == 9 &&
              FLATBUFFERS_VERSION_REVISION == 23,
             "Non-compatible flatbuffers version included");
 
namespace Rose {
namespace BinaryAnalysis {
namespace Serialization {
namespace FlatBuffers {
 
struct Architecture;
struct ArchitectureBuilder;
 
struct Segment;
struct SegmentBuilder;
 
struct MemoryMap;
struct MemoryMapBuilder;
 
struct Instruction;
struct InstructionBuilder;
 
struct InstructionList;
struct InstructionListBuilder;
 
struct BasicBlock;
struct BasicBlockBuilder;
 
struct BasicBlockList;
struct BasicBlockListBuilder;
 
struct Function;
struct FunctionBuilder;
 
struct FunctionList;
struct FunctionListBuilder;
 
struct CfgEdgeData;
struct CfgEdgeDataBuilder;
 
struct AddressTarget;
struct AddressTargetBuilder;
 
struct IndeterminateTarget;
struct IndeterminateTargetBuilder;
 
struct CfgEdge;
struct CfgEdgeBuilder;
 
struct Cfg;
struct CfgBuilder;
 
struct Root;
struct RootBuilder;
 
enum class Accessibility : uint8_t {
  EXECUTABLE = 1,
  WRITABLE = 2,
  READABLE = 4,
  IMMUTABLE = 8,
  PRIVATE = 16,
  MIN = EXECUTABLE,
  MAX = PRIVATE
};
 
inline const Accessibility (&EnumValuesAccessibility())[5] {
  static const Accessibility values[] = {
    Accessibility::EXECUTABLE,
    Accessibility::WRITABLE,
    Accessibility::READABLE,
    Accessibility::IMMUTABLE,
    Accessibility::PRIVATE
  };
  return values;
}
 
inline const char * const *EnumNamesAccessibility() {
  static const char * const names[17] = {
    "EXECUTABLE",
    "WRITABLE",
    "",
    "READABLE",
    "",
    "",
    "",
    "IMMUTABLE",
    "",
    "",
    "",
    "",
    "",
    "",
    "",
    "PRIVATE",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameAccessibility(Accessibility e) {
  if (::flatbuffers::IsOutRange(e, Accessibility::EXECUTABLE, Accessibility::PRIVATE)) return "";
  const size_t index = static_cast<size_t>(e) - static_cast<size_t>(Accessibility::EXECUTABLE);
  return EnumNamesAccessibility()[index];
}
 
enum class Endianness : uint8_t {
  ORDER_UNSPECIFIED = 0,
  ORDER_LSB = 1,
  ORDER_MSB = 2,
  MIN = ORDER_UNSPECIFIED,
  MAX = ORDER_MSB
};
 
inline const Endianness (&EnumValuesEndianness())[3] {
  static const Endianness values[] = {
    Endianness::ORDER_UNSPECIFIED,
    Endianness::ORDER_LSB,
    Endianness::ORDER_MSB
  };
  return values;
}
 
inline const char * const *EnumNamesEndianness() {
  static const char * const names[4] = {
    "ORDER_UNSPECIFIED",
    "ORDER_LSB",
    "ORDER_MSB",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameEndianness(Endianness e) {
  if (::flatbuffers::IsOutRange(e, Endianness::ORDER_UNSPECIFIED, Endianness::ORDER_MSB)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesEndianness()[index];
}
 
enum class CfgEdgePurpose : uint8_t {
  FunctionCall = 0,
  FunctionTransfer = 1,
  FunctionReturn = 2,
  CallReturn = 3,
  Normal = 4,
  MIN = FunctionCall,
  MAX = Normal
};
 
inline const CfgEdgePurpose (&EnumValuesCfgEdgePurpose())[5] {
  static const CfgEdgePurpose values[] = {
    CfgEdgePurpose::FunctionCall,
    CfgEdgePurpose::FunctionTransfer,
    CfgEdgePurpose::FunctionReturn,
    CfgEdgePurpose::CallReturn,
    CfgEdgePurpose::Normal
  };
  return values;
}
 
inline const char * const *EnumNamesCfgEdgePurpose() {
  static const char * const names[6] = {
    "FunctionCall",
    "FunctionTransfer",
    "FunctionReturn",
    "CallReturn",
    "Normal",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameCfgEdgePurpose(CfgEdgePurpose e) {
  if (::flatbuffers::IsOutRange(e, CfgEdgePurpose::FunctionCall, CfgEdgePurpose::Normal)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesCfgEdgePurpose()[index];
}
 
enum class CfgEdgeTarget : uint8_t {
  NONE = 0,
  AddressTarget = 1,
  IndeterminateTarget = 2,
  MIN = NONE,
  MAX = IndeterminateTarget
};
 
inline const CfgEdgeTarget (&EnumValuesCfgEdgeTarget())[3] {
  static const CfgEdgeTarget values[] = {
    CfgEdgeTarget::NONE,
    CfgEdgeTarget::AddressTarget,
    CfgEdgeTarget::IndeterminateTarget
  };
  return values;
}
 
inline const char * const *EnumNamesCfgEdgeTarget() {
  static const char * const names[4] = {
    "NONE",
    "AddressTarget",
    "IndeterminateTarget",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameCfgEdgeTarget(CfgEdgeTarget e) {
  if (::flatbuffers::IsOutRange(e, CfgEdgeTarget::NONE, CfgEdgeTarget::IndeterminateTarget)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesCfgEdgeTarget()[index];
}
 
template<typename T> struct CfgEdgeTargetTraits {
  static const CfgEdgeTarget enum_value = CfgEdgeTarget::NONE;
};
 
template<> struct CfgEdgeTargetTraits<Rose::BinaryAnalysis::Serialization::FlatBuffers::AddressTarget> {
  static const CfgEdgeTarget enum_value = CfgEdgeTarget::AddressTarget;
};
 
template<> struct CfgEdgeTargetTraits<Rose::BinaryAnalysis::Serialization::FlatBuffers::IndeterminateTarget> {
  static const CfgEdgeTarget enum_value = CfgEdgeTarget::IndeterminateTarget;
};
 
bool VerifyCfgEdgeTarget(::flatbuffers::Verifier &verifier, const void *obj, CfgEdgeTarget type);
bool VerifyCfgEdgeTargetVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<CfgEdgeTarget> *types);
 
struct Architecture FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ArchitectureBuilder 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 ArchitectureBuilder {
  typedef Architecture Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
    fbb_.AddOffset(Architecture::VT_NAME, name);
  }
  explicit ArchitectureBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Architecture> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Architecture>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<Architecture> CreateArchitecture(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::String> name = 0) {
  ArchitectureBuilder builder_(_fbb);
  builder_.add_name(name);
  return builder_.Finish();
}
 
inline ::flatbuffers::Offset<Architecture> CreateArchitectureDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const char *name = nullptr) {
  auto name__ = name ? _fbb.CreateString(name) : 0;
  return Rose::BinaryAnalysis::Serialization::FlatBuffers::CreateArchitecture(
      _fbb,
      name__);
}
 
struct Segment FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef SegmentBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ADDRESS = 4,
    VT_BYTES = 6,
    VT_ACCESSIBILITY = 8,
    VT_NAME = 10
  };
  uint64_t address() const {
    return GetField<uint64_t>(VT_ADDRESS, 0);
  }
  const ::flatbuffers::Vector<uint8_t> *bytes() const {
    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_BYTES);
  }
  uint8_t accessibility() const {
    return GetField<uint8_t>(VT_ACCESSIBILITY, 0);
  }
  const ::flatbuffers::String *name() const {
    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint64_t>(verifier, VT_ADDRESS, 8) &&
           VerifyOffsetRequired(verifier, VT_BYTES) &&
           verifier.VerifyVector(bytes()) &&
           VerifyField<uint8_t>(verifier, VT_ACCESSIBILITY, 1) &&
           VerifyOffset(verifier, VT_NAME) &&
           verifier.VerifyString(name()) &&
           verifier.EndTable();
  }
};
 
struct SegmentBuilder {
  typedef Segment Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_address(uint64_t address) {
    fbb_.AddElement<uint64_t>(Segment::VT_ADDRESS, address, 0);
  }
  void add_bytes(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> bytes) {
    fbb_.AddOffset(Segment::VT_BYTES, bytes);
  }
  void add_accessibility(uint8_t accessibility) {
    fbb_.AddElement<uint8_t>(Segment::VT_ACCESSIBILITY, accessibility, 0);
  }
  void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
    fbb_.AddOffset(Segment::VT_NAME, name);
  }
  explicit SegmentBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Segment> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Segment>(end);
    fbb_.Required(o, Segment::VT_BYTES);
    return o;
  }
};
 
inline ::flatbuffers::Offset<Segment> CreateSegment(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t address = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> bytes = 0,
    uint8_t accessibility = 0,
    ::flatbuffers::Offset<::flatbuffers::String> name = 0) {
  SegmentBuilder builder_(_fbb);
  builder_.add_address(address);
  builder_.add_name(name);
  builder_.add_bytes(bytes);
  builder_.add_accessibility(accessibility);
  return builder_.Finish();
}
 
inline ::flatbuffers::Offset<Segment> CreateSegmentDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t address = 0,
    const std::vector<uint8_t> *bytes = nullptr,
    uint8_t accessibility = 0,
    const char *name = nullptr) {
  auto bytes__ = bytes ? _fbb.CreateVector<uint8_t>(*bytes) : 0;
  auto name__ = name ? _fbb.CreateString(name) : 0;
  return Rose::BinaryAnalysis::Serialization::FlatBuffers::CreateSegment(
      _fbb,
      address,
      bytes__,
      accessibility,
      name__);
}
 
struct MemoryMap FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef MemoryMapBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ENDIANNESS = 4,
    VT_SEGMENTS = 6
  };
  Rose::BinaryAnalysis::Serialization::FlatBuffers::Endianness endianness() const {
    return static_cast<Rose::BinaryAnalysis::Serialization::FlatBuffers::Endianness>(GetField<uint8_t>(VT_ENDIANNESS, 0));
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::Segment>> *segments() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::Segment>> *>(VT_SEGMENTS);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_ENDIANNESS, 1) &&
           VerifyOffsetRequired(verifier, VT_SEGMENTS) &&
           verifier.VerifyVector(segments()) &&
           verifier.VerifyVectorOfTables(segments()) &&
           verifier.EndTable();
  }
};
 
struct MemoryMapBuilder {
  typedef MemoryMap Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_endianness(Rose::BinaryAnalysis::Serialization::FlatBuffers::Endianness endianness) {
    fbb_.AddElement<uint8_t>(MemoryMap::VT_ENDIANNESS, static_cast<uint8_t>(endianness), 0);
  }
  void add_segments(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::Segment>>> segments) {
    fbb_.AddOffset(MemoryMap::VT_SEGMENTS, segments);
  }
  explicit MemoryMapBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<MemoryMap> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<MemoryMap>(end);
    fbb_.Required(o, MemoryMap::VT_SEGMENTS);
    return o;
  }
};
 
inline ::flatbuffers::Offset<MemoryMap> CreateMemoryMap(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    Rose::BinaryAnalysis::Serialization::FlatBuffers::Endianness endianness = Rose::BinaryAnalysis::Serialization::FlatBuffers::Endianness::ORDER_UNSPECIFIED,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::Segment>>> segments = 0) {
  MemoryMapBuilder builder_(_fbb);
  builder_.add_segments(segments);
  builder_.add_endianness(endianness);
  return builder_.Finish();
}
 
inline ::flatbuffers::Offset<MemoryMap> CreateMemoryMapDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    Rose::BinaryAnalysis::Serialization::FlatBuffers::Endianness endianness = Rose::BinaryAnalysis::Serialization::FlatBuffers::Endianness::ORDER_UNSPECIFIED,
    const std::vector<::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::Segment>> *segments = nullptr) {
  auto segments__ = segments ? _fbb.CreateVector<::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::Segment>>(*segments) : 0;
  return Rose::BinaryAnalysis::Serialization::FlatBuffers::CreateMemoryMap(
      _fbb,
      endianness,
      segments__);
}
 
struct Instruction FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef InstructionBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ADDRESS = 4,
    VT_BYTES = 6,
    VT_MNEMONIC = 8,
    VT_OPERANDS = 10
  };
  uint64_t address() const {
    return GetField<uint64_t>(VT_ADDRESS, 0);
  }
  const ::flatbuffers::Vector<uint8_t> *bytes() const {
    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_BYTES);
  }
  const ::flatbuffers::String *mnemonic() const {
    return GetPointer<const ::flatbuffers::String *>(VT_MNEMONIC);
  }
  const ::flatbuffers::String *operands() const {
    return GetPointer<const ::flatbuffers::String *>(VT_OPERANDS);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint64_t>(verifier, VT_ADDRESS, 8) &&
           VerifyOffsetRequired(verifier, VT_BYTES) &&
           verifier.VerifyVector(bytes()) &&
           VerifyOffset(verifier, VT_MNEMONIC) &&
           verifier.VerifyString(mnemonic()) &&
           VerifyOffset(verifier, VT_OPERANDS) &&
           verifier.VerifyString(operands()) &&
           verifier.EndTable();
  }
};
 
struct InstructionBuilder {
  typedef Instruction Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_address(uint64_t address) {
    fbb_.AddElement<uint64_t>(Instruction::VT_ADDRESS, address, 0);
  }
  void add_bytes(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> bytes) {
    fbb_.AddOffset(Instruction::VT_BYTES, bytes);
  }
  void add_mnemonic(::flatbuffers::Offset<::flatbuffers::String> mnemonic) {
    fbb_.AddOffset(Instruction::VT_MNEMONIC, mnemonic);
  }
  void add_operands(::flatbuffers::Offset<::flatbuffers::String> operands) {
    fbb_.AddOffset(Instruction::VT_OPERANDS, operands);
  }
  explicit InstructionBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Instruction> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Instruction>(end);
    fbb_.Required(o, Instruction::VT_BYTES);
    return o;
  }
};
 
inline ::flatbuffers::Offset<Instruction> CreateInstruction(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t address = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> bytes = 0,
    ::flatbuffers::Offset<::flatbuffers::String> mnemonic = 0,
    ::flatbuffers::Offset<::flatbuffers::String> operands = 0) {
  InstructionBuilder builder_(_fbb);
  builder_.add_address(address);
  builder_.add_operands(operands);
  builder_.add_mnemonic(mnemonic);
  builder_.add_bytes(bytes);
  return builder_.Finish();
}
 
inline ::flatbuffers::Offset<Instruction> CreateInstructionDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t address = 0,
    const std::vector<uint8_t> *bytes = nullptr,
    const char *mnemonic = nullptr,
    const char *operands = nullptr) {
  auto bytes__ = bytes ? _fbb.CreateVector<uint8_t>(*bytes) : 0;
  auto mnemonic__ = mnemonic ? _fbb.CreateString(mnemonic) : 0;
  auto operands__ = operands ? _fbb.CreateString(operands) : 0;
  return Rose::BinaryAnalysis::Serialization::FlatBuffers::CreateInstruction(
      _fbb,
      address,
      bytes__,
      mnemonic__,
      operands__);
}
 
struct InstructionList FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef InstructionListBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_INSTRUCTIONS = 4
  };
  const ::flatbuffers::Vector<::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::Instruction>> *instructions() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::Instruction>> *>(VT_INSTRUCTIONS);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffsetRequired(verifier, VT_INSTRUCTIONS) &&
           verifier.VerifyVector(instructions()) &&
           verifier.VerifyVectorOfTables(instructions()) &&
           verifier.EndTable();
  }
};
 
struct InstructionListBuilder {
  typedef InstructionList Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_instructions(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::Instruction>>> instructions) {
    fbb_.AddOffset(InstructionList::VT_INSTRUCTIONS, instructions);
  }
  explicit InstructionListBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<InstructionList> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<InstructionList>(end);
    fbb_.Required(o, InstructionList::VT_INSTRUCTIONS);
    return o;
  }
};
 
inline ::flatbuffers::Offset<InstructionList> CreateInstructionList(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::Instruction>>> instructions = 0) {
  InstructionListBuilder builder_(_fbb);
  builder_.add_instructions(instructions);
  return builder_.Finish();
}
 
inline ::flatbuffers::Offset<InstructionList> CreateInstructionListDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::Instruction>> *instructions = nullptr) {
  auto instructions__ = instructions ? _fbb.CreateVector<::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::Instruction>>(*instructions) : 0;
  return Rose::BinaryAnalysis::Serialization::FlatBuffers::CreateInstructionList(
      _fbb,
      instructions__);
}
 
struct BasicBlock FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef BasicBlockBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ADDRESSES = 4
  };
  const ::flatbuffers::Vector<uint64_t> *addresses() const {
    return GetPointer<const ::flatbuffers::Vector<uint64_t> *>(VT_ADDRESSES);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffsetRequired(verifier, VT_ADDRESSES) &&
           verifier.VerifyVector(addresses()) &&
           verifier.EndTable();
  }
};
 
struct BasicBlockBuilder {
  typedef BasicBlock Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_addresses(::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> addresses) {
    fbb_.AddOffset(BasicBlock::VT_ADDRESSES, addresses);
  }
  explicit BasicBlockBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<BasicBlock> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<BasicBlock>(end);
    fbb_.Required(o, BasicBlock::VT_ADDRESSES);
    return o;
  }
};
 
inline ::flatbuffers::Offset<BasicBlock> CreateBasicBlock(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> addresses = 0) {
  BasicBlockBuilder builder_(_fbb);
  builder_.add_addresses(addresses);
  return builder_.Finish();
}
 
inline ::flatbuffers::Offset<BasicBlock> CreateBasicBlockDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<uint64_t> *addresses = nullptr) {
  auto addresses__ = addresses ? _fbb.CreateVector<uint64_t>(*addresses) : 0;
  return Rose::BinaryAnalysis::Serialization::FlatBuffers::CreateBasicBlock(
      _fbb,
      addresses__);
}
 
struct BasicBlockList FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef BasicBlockListBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_BASIC_BLOCKS = 4
  };
  const ::flatbuffers::Vector<::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::BasicBlock>> *basic_blocks() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::BasicBlock>> *>(VT_BASIC_BLOCKS);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffsetRequired(verifier, VT_BASIC_BLOCKS) &&
           verifier.VerifyVector(basic_blocks()) &&
           verifier.VerifyVectorOfTables(basic_blocks()) &&
           verifier.EndTable();
  }
};
 
struct BasicBlockListBuilder {
  typedef BasicBlockList Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_basic_blocks(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::BasicBlock>>> basic_blocks) {
    fbb_.AddOffset(BasicBlockList::VT_BASIC_BLOCKS, basic_blocks);
  }
  explicit BasicBlockListBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<BasicBlockList> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<BasicBlockList>(end);
    fbb_.Required(o, BasicBlockList::VT_BASIC_BLOCKS);
    return o;
  }
};
 
inline ::flatbuffers::Offset<BasicBlockList> CreateBasicBlockList(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::BasicBlock>>> basic_blocks = 0) {
  BasicBlockListBuilder builder_(_fbb);
  builder_.add_basic_blocks(basic_blocks);
  return builder_.Finish();
}
 
inline ::flatbuffers::Offset<BasicBlockList> CreateBasicBlockListDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::BasicBlock>> *basic_blocks = nullptr) {
  auto basic_blocks__ = basic_blocks ? _fbb.CreateVector<::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::BasicBlock>>(*basic_blocks) : 0;
  return Rose::BinaryAnalysis::Serialization::FlatBuffers::CreateBasicBlockList(
      _fbb,
      basic_blocks__);
}
 
struct Function FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef FunctionBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ENTRY_ADDR = 4,
    VT_INSTRUCTIONS = 6,
    VT_NAME = 8
  };
  uint64_t entry_addr() const {
    return GetField<uint64_t>(VT_ENTRY_ADDR, 0);
  }
  const ::flatbuffers::Vector<uint64_t> *instructions() const {
    return GetPointer<const ::flatbuffers::Vector<uint64_t> *>(VT_INSTRUCTIONS);
  }
  const ::flatbuffers::String *name() const {
    return GetPointer<const ::flatbuffers::String *>(VT_NAME);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint64_t>(verifier, VT_ENTRY_ADDR, 8) &&
           VerifyOffsetRequired(verifier, VT_INSTRUCTIONS) &&
           verifier.VerifyVector(instructions()) &&
           VerifyOffset(verifier, VT_NAME) &&
           verifier.VerifyString(name()) &&
           verifier.EndTable();
  }
};
 
struct FunctionBuilder {
  typedef Function Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_entry_addr(uint64_t entry_addr) {
    fbb_.AddElement<uint64_t>(Function::VT_ENTRY_ADDR, entry_addr, 0);
  }
  void add_instructions(::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> instructions) {
    fbb_.AddOffset(Function::VT_INSTRUCTIONS, instructions);
  }
  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);
    fbb_.Required(o, Function::VT_INSTRUCTIONS);
    return o;
  }
};
 
inline ::flatbuffers::Offset<Function> CreateFunction(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t entry_addr = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> instructions = 0,
    ::flatbuffers::Offset<::flatbuffers::String> name = 0) {
  FunctionBuilder builder_(_fbb);
  builder_.add_entry_addr(entry_addr);
  builder_.add_name(name);
  builder_.add_instructions(instructions);
  return builder_.Finish();
}
 
inline ::flatbuffers::Offset<Function> CreateFunctionDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t entry_addr = 0,
    const std::vector<uint64_t> *instructions = nullptr,
    const char *name = nullptr) {
  auto instructions__ = instructions ? _fbb.CreateVector<uint64_t>(*instructions) : 0;
  auto name__ = name ? _fbb.CreateString(name) : 0;
  return Rose::BinaryAnalysis::Serialization::FlatBuffers::CreateFunction(
      _fbb,
      entry_addr,
      instructions__,
      name__);
}
 
struct FunctionList FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef FunctionListBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_FUNCTIONS = 4
  };
  const ::flatbuffers::Vector<::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::Function>> *functions() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::Function>> *>(VT_FUNCTIONS);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffsetRequired(verifier, VT_FUNCTIONS) &&
           verifier.VerifyVector(functions()) &&
           verifier.VerifyVectorOfTables(functions()) &&
           verifier.EndTable();
  }
};
 
struct FunctionListBuilder {
  typedef FunctionList Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_functions(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::Function>>> functions) {
    fbb_.AddOffset(FunctionList::VT_FUNCTIONS, functions);
  }
  explicit FunctionListBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<FunctionList> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<FunctionList>(end);
    fbb_.Required(o, FunctionList::VT_FUNCTIONS);
    return o;
  }
};
 
inline ::flatbuffers::Offset<FunctionList> CreateFunctionList(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::Function>>> functions = 0) {
  FunctionListBuilder builder_(_fbb);
  builder_.add_functions(functions);
  return builder_.Finish();
}
 
inline ::flatbuffers::Offset<FunctionList> CreateFunctionListDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::Function>> *functions = nullptr) {
  auto functions__ = functions ? _fbb.CreateVector<::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::Function>>(*functions) : 0;
  return Rose::BinaryAnalysis::Serialization::FlatBuffers::CreateFunctionList(
      _fbb,
      functions__);
}
 
struct CfgEdgeData FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef CfgEdgeDataBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_PURPOSE = 4
  };
  Rose::BinaryAnalysis::Serialization::FlatBuffers::CfgEdgePurpose purpose() const {
    return static_cast<Rose::BinaryAnalysis::Serialization::FlatBuffers::CfgEdgePurpose>(GetField<uint8_t>(VT_PURPOSE, 0));
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_PURPOSE, 1) &&
           verifier.EndTable();
  }
};
 
struct CfgEdgeDataBuilder {
  typedef CfgEdgeData Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_purpose(Rose::BinaryAnalysis::Serialization::FlatBuffers::CfgEdgePurpose purpose) {
    fbb_.AddElement<uint8_t>(CfgEdgeData::VT_PURPOSE, static_cast<uint8_t>(purpose), 0);
  }
  explicit CfgEdgeDataBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<CfgEdgeData> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<CfgEdgeData>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<CfgEdgeData> CreateCfgEdgeData(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    Rose::BinaryAnalysis::Serialization::FlatBuffers::CfgEdgePurpose purpose = Rose::BinaryAnalysis::Serialization::FlatBuffers::CfgEdgePurpose::FunctionCall) {
  CfgEdgeDataBuilder builder_(_fbb);
  builder_.add_purpose(purpose);
  return builder_.Finish();
}
 
struct AddressTarget FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef AddressTargetBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ADDRESS = 4
  };
  uint64_t address() const {
    return GetField<uint64_t>(VT_ADDRESS, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint64_t>(verifier, VT_ADDRESS, 8) &&
           verifier.EndTable();
  }
};
 
struct AddressTargetBuilder {
  typedef AddressTarget Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_address(uint64_t address) {
    fbb_.AddElement<uint64_t>(AddressTarget::VT_ADDRESS, address, 0);
  }
  explicit AddressTargetBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<AddressTarget> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<AddressTarget>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<AddressTarget> CreateAddressTarget(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t address = 0) {
  AddressTargetBuilder builder_(_fbb);
  builder_.add_address(address);
  return builder_.Finish();
}
 
struct IndeterminateTarget FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef IndeterminateTargetBuilder Builder;
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};
 
struct IndeterminateTargetBuilder {
  typedef IndeterminateTarget Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit IndeterminateTargetBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<IndeterminateTarget> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<IndeterminateTarget>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<IndeterminateTarget> CreateIndeterminateTarget(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  IndeterminateTargetBuilder builder_(_fbb);
  return builder_.Finish();
}
 
struct CfgEdge FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef CfgEdgeBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SRC = 4,
    VT_TGT_TYPE = 6,
    VT_TGT = 8,
    VT_DATA = 10
  };
  uint64_t src() const {
    return GetField<uint64_t>(VT_SRC, 0);
  }
  Rose::BinaryAnalysis::Serialization::FlatBuffers::CfgEdgeTarget tgt_type() const {
    return static_cast<Rose::BinaryAnalysis::Serialization::FlatBuffers::CfgEdgeTarget>(GetField<uint8_t>(VT_TGT_TYPE, 0));
  }
  const void *tgt() const {
    return GetPointer<const void *>(VT_TGT);
  }
  template<typename T> const T *tgt_as() const;
  const Rose::BinaryAnalysis::Serialization::FlatBuffers::AddressTarget *tgt_as_AddressTarget() const {
    return tgt_type() == Rose::BinaryAnalysis::Serialization::FlatBuffers::CfgEdgeTarget::AddressTarget ? static_cast<const Rose::BinaryAnalysis::Serialization::FlatBuffers::AddressTarget *>(tgt()) : nullptr;
  }
  const Rose::BinaryAnalysis::Serialization::FlatBuffers::IndeterminateTarget *tgt_as_IndeterminateTarget() const {
    return tgt_type() == Rose::BinaryAnalysis::Serialization::FlatBuffers::CfgEdgeTarget::IndeterminateTarget ? static_cast<const Rose::BinaryAnalysis::Serialization::FlatBuffers::IndeterminateTarget *>(tgt()) : nullptr;
  }
  const Rose::BinaryAnalysis::Serialization::FlatBuffers::CfgEdgeData *data() const {
    return GetPointer<const Rose::BinaryAnalysis::Serialization::FlatBuffers::CfgEdgeData *>(VT_DATA);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint64_t>(verifier, VT_SRC, 8) &&
           VerifyField<uint8_t>(verifier, VT_TGT_TYPE, 1) &&
           VerifyOffsetRequired(verifier, VT_TGT) &&
           VerifyCfgEdgeTarget(verifier, tgt(), tgt_type()) &&
           VerifyOffsetRequired(verifier, VT_DATA) &&
           verifier.VerifyTable(data()) &&
           verifier.EndTable();
  }
};
 
template<> inline const Rose::BinaryAnalysis::Serialization::FlatBuffers::AddressTarget *CfgEdge::tgt_as<Rose::BinaryAnalysis::Serialization::FlatBuffers::AddressTarget>() const {
  return tgt_as_AddressTarget();
}
 
template<> inline const Rose::BinaryAnalysis::Serialization::FlatBuffers::IndeterminateTarget *CfgEdge::tgt_as<Rose::BinaryAnalysis::Serialization::FlatBuffers::IndeterminateTarget>() const {
  return tgt_as_IndeterminateTarget();
}
 
struct CfgEdgeBuilder {
  typedef CfgEdge Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_src(uint64_t src) {
    fbb_.AddElement<uint64_t>(CfgEdge::VT_SRC, src, 0);
  }
  void add_tgt_type(Rose::BinaryAnalysis::Serialization::FlatBuffers::CfgEdgeTarget tgt_type) {
    fbb_.AddElement<uint8_t>(CfgEdge::VT_TGT_TYPE, static_cast<uint8_t>(tgt_type), 0);
  }
  void add_tgt(::flatbuffers::Offset<void> tgt) {
    fbb_.AddOffset(CfgEdge::VT_TGT, tgt);
  }
  void add_data(::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::CfgEdgeData> data) {
    fbb_.AddOffset(CfgEdge::VT_DATA, data);
  }
  explicit CfgEdgeBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<CfgEdge> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<CfgEdge>(end);
    fbb_.Required(o, CfgEdge::VT_TGT);
    fbb_.Required(o, CfgEdge::VT_DATA);
    return o;
  }
};
 
inline ::flatbuffers::Offset<CfgEdge> CreateCfgEdge(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t src = 0,
    Rose::BinaryAnalysis::Serialization::FlatBuffers::CfgEdgeTarget tgt_type = Rose::BinaryAnalysis::Serialization::FlatBuffers::CfgEdgeTarget::NONE,
    ::flatbuffers::Offset<void> tgt = 0,
    ::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::CfgEdgeData> data = 0) {
  CfgEdgeBuilder builder_(_fbb);
  builder_.add_src(src);
  builder_.add_data(data);
  builder_.add_tgt(tgt);
  builder_.add_tgt_type(tgt_type);
  return builder_.Finish();
}
 
struct Cfg FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef CfgBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_EDGES = 4
  };
  const ::flatbuffers::Vector<::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::CfgEdge>> *edges() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::CfgEdge>> *>(VT_EDGES);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffsetRequired(verifier, VT_EDGES) &&
           verifier.VerifyVector(edges()) &&
           verifier.VerifyVectorOfTables(edges()) &&
           verifier.EndTable();
  }
};
 
struct CfgBuilder {
  typedef Cfg Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_edges(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::CfgEdge>>> edges) {
    fbb_.AddOffset(Cfg::VT_EDGES, edges);
  }
  explicit CfgBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Cfg> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Cfg>(end);
    fbb_.Required(o, Cfg::VT_EDGES);
    return o;
  }
};
 
inline ::flatbuffers::Offset<Cfg> CreateCfg(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::CfgEdge>>> edges = 0) {
  CfgBuilder builder_(_fbb);
  builder_.add_edges(edges);
  return builder_.Finish();
}
 
inline ::flatbuffers::Offset<Cfg> CreateCfgDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::CfgEdge>> *edges = nullptr) {
  auto edges__ = edges ? _fbb.CreateVector<::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::CfgEdge>>(*edges) : 0;
  return Rose::BinaryAnalysis::Serialization::FlatBuffers::CreateCfg(
      _fbb,
      edges__);
}
 
struct Root FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef RootBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ARCHITECTURE = 4,
    VT_MEMORY_MAP = 6,
    VT_INSTRUCTIONS = 8,
    VT_BASIC_BLOCKS = 10,
    VT_FUNCTIONS = 12,
    VT_CFG = 14
  };
  const Rose::BinaryAnalysis::Serialization::FlatBuffers::Architecture *architecture() const {
    return GetPointer<const Rose::BinaryAnalysis::Serialization::FlatBuffers::Architecture *>(VT_ARCHITECTURE);
  }
  const Rose::BinaryAnalysis::Serialization::FlatBuffers::MemoryMap *memory_map() const {
    return GetPointer<const Rose::BinaryAnalysis::Serialization::FlatBuffers::MemoryMap *>(VT_MEMORY_MAP);
  }
  const Rose::BinaryAnalysis::Serialization::FlatBuffers::InstructionList *instructions() const {
    return GetPointer<const Rose::BinaryAnalysis::Serialization::FlatBuffers::InstructionList *>(VT_INSTRUCTIONS);
  }
  const Rose::BinaryAnalysis::Serialization::FlatBuffers::BasicBlockList *basic_blocks() const {
    return GetPointer<const Rose::BinaryAnalysis::Serialization::FlatBuffers::BasicBlockList *>(VT_BASIC_BLOCKS);
  }
  const Rose::BinaryAnalysis::Serialization::FlatBuffers::FunctionList *functions() const {
    return GetPointer<const Rose::BinaryAnalysis::Serialization::FlatBuffers::FunctionList *>(VT_FUNCTIONS);
  }
  const Rose::BinaryAnalysis::Serialization::FlatBuffers::Cfg *cfg() const {
    return GetPointer<const Rose::BinaryAnalysis::Serialization::FlatBuffers::Cfg *>(VT_CFG);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffsetRequired(verifier, VT_ARCHITECTURE) &&
           verifier.VerifyTable(architecture()) &&
           VerifyOffsetRequired(verifier, VT_MEMORY_MAP) &&
           verifier.VerifyTable(memory_map()) &&
           VerifyOffsetRequired(verifier, VT_INSTRUCTIONS) &&
           verifier.VerifyTable(instructions()) &&
           VerifyOffsetRequired(verifier, VT_BASIC_BLOCKS) &&
           verifier.VerifyTable(basic_blocks()) &&
           VerifyOffsetRequired(verifier, VT_FUNCTIONS) &&
           verifier.VerifyTable(functions()) &&
           VerifyOffsetRequired(verifier, VT_CFG) &&
           verifier.VerifyTable(cfg()) &&
           verifier.EndTable();
  }
};
 
struct RootBuilder {
  typedef Root Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_architecture(::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::Architecture> architecture) {
    fbb_.AddOffset(Root::VT_ARCHITECTURE, architecture);
  }
  void add_memory_map(::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::MemoryMap> memory_map) {
    fbb_.AddOffset(Root::VT_MEMORY_MAP, memory_map);
  }
  void add_instructions(::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::InstructionList> instructions) {
    fbb_.AddOffset(Root::VT_INSTRUCTIONS, instructions);
  }
  void add_basic_blocks(::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::BasicBlockList> basic_blocks) {
    fbb_.AddOffset(Root::VT_BASIC_BLOCKS, basic_blocks);
  }
  void add_functions(::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::FunctionList> functions) {
    fbb_.AddOffset(Root::VT_FUNCTIONS, functions);
  }
  void add_cfg(::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::Cfg> cfg) {
    fbb_.AddOffset(Root::VT_CFG, cfg);
  }
  explicit RootBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<Root> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<Root>(end);
    fbb_.Required(o, Root::VT_ARCHITECTURE);
    fbb_.Required(o, Root::VT_MEMORY_MAP);
    fbb_.Required(o, Root::VT_INSTRUCTIONS);
    fbb_.Required(o, Root::VT_BASIC_BLOCKS);
    fbb_.Required(o, Root::VT_FUNCTIONS);
    fbb_.Required(o, Root::VT_CFG);
    return o;
  }
};
 
inline ::flatbuffers::Offset<Root> CreateRoot(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::Architecture> architecture = 0,
    ::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::MemoryMap> memory_map = 0,
    ::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::InstructionList> instructions = 0,
    ::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::BasicBlockList> basic_blocks = 0,
    ::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::FunctionList> functions = 0,
    ::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::Cfg> cfg = 0) {
  RootBuilder builder_(_fbb);
  builder_.add_cfg(cfg);
  builder_.add_functions(functions);
  builder_.add_basic_blocks(basic_blocks);
  builder_.add_instructions(instructions);
  builder_.add_memory_map(memory_map);
  builder_.add_architecture(architecture);
  return builder_.Finish();
}
 
inline bool VerifyCfgEdgeTarget(::flatbuffers::Verifier &verifier, const void *obj, CfgEdgeTarget type) {
  switch (type) {
    case CfgEdgeTarget::NONE: {
      return true;
    }
    case CfgEdgeTarget::AddressTarget: {
      auto ptr = reinterpret_cast<const Rose::BinaryAnalysis::Serialization::FlatBuffers::AddressTarget *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case CfgEdgeTarget::IndeterminateTarget: {
      auto ptr = reinterpret_cast<const Rose::BinaryAnalysis::Serialization::FlatBuffers::IndeterminateTarget *>(obj);
      return verifier.VerifyTable(ptr);
    }
    default: return true;
  }
}
 
inline bool VerifyCfgEdgeTargetVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<CfgEdgeTarget> *types) {
  if (!values || !types) return !values && !types;
  if (values->size() != types->size()) return false;
  for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
    if (!VerifyCfgEdgeTarget(
        verifier,  values->Get(i), types->GetEnum<CfgEdgeTarget>(i))) {
      return false;
    }
  }
  return true;
}
 
inline const Rose::BinaryAnalysis::Serialization::FlatBuffers::Root *GetRoot(const void *buf) {
  return ::flatbuffers::GetRoot<Rose::BinaryAnalysis::Serialization::FlatBuffers::Root>(buf);
}
 
inline const Rose::BinaryAnalysis::Serialization::FlatBuffers::Root *GetSizePrefixedRoot(const void *buf) {
  return ::flatbuffers::GetSizePrefixedRoot<Rose::BinaryAnalysis::Serialization::FlatBuffers::Root>(buf);
}
 
inline bool VerifyRootBuffer(
    ::flatbuffers::Verifier &verifier) {
  return verifier.VerifyBuffer<Rose::BinaryAnalysis::Serialization::FlatBuffers::Root>(nullptr);
}
 
inline bool VerifySizePrefixedRootBuffer(
    ::flatbuffers::Verifier &verifier) {
  return verifier.VerifySizePrefixedBuffer<Rose::BinaryAnalysis::Serialization::FlatBuffers::Root>(nullptr);
}
 
inline void FinishRootBuffer(
    ::flatbuffers::FlatBufferBuilder &fbb,
    ::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::Root> root) {
  fbb.Finish(root);
}
 
inline void FinishSizePrefixedRootBuffer(
    ::flatbuffers::FlatBufferBuilder &fbb,
    ::flatbuffers::Offset<Rose::BinaryAnalysis::Serialization::FlatBuffers::Root> root) {
  fbb.FinishSizePrefixed(root);
}
 
}  // namespace FlatBuffers
}  // namespace Serialization
}  // namespace BinaryAnalysis
}  // namespace Rose
 
#endif  // FLATBUFFERS_GENERATED_FLATBUFFERSCHEMA_ROSE_BINARYANALYSIS_SERIALIZATION_FLATBUFFERS_H_