diff --git a/include/engine/api/flatbuffers/fbresult.fbs b/include/engine/api/flatbuffers/fbresult.fbs
new file mode 100644
index 00000000000..af648d90565
--- /dev/null
+++ b/include/engine/api/flatbuffers/fbresult.fbs
@@ -0,0 +1,21 @@
+include "match.fbs";
+include "nearest.fbs";
+include "route.fbs";
+include "table.fbs";
+include "trip.fbs";
+
+namespace osrm.engine.api.fbresult;
+
+union ServiceResponse {
+    match: Match,
+    nearest: Nearest,
+    route: Route,
+    table: Table,
+    trip: Trip
+}
+
+table FBResult {
+    code: string;
+    message: string;
+    response: ServiceResponse;
+}
\ No newline at end of file
diff --git a/include/engine/api/flatbuffers/fbresult_generated.h b/include/engine/api/flatbuffers/fbresult_generated.h
new file mode 100644
index 00000000000..30bfb15b511
--- /dev/null
+++ b/include/engine/api/flatbuffers/fbresult_generated.h
@@ -0,0 +1,3445 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+
+#ifndef FLATBUFFERS_GENERATED_FBRESULT_OSRM_ENGINE_API_FBRESULT_H_
+#define FLATBUFFERS_GENERATED_FBRESULT_OSRM_ENGINE_API_FBRESULT_H_
+
+#include "flatbuffers/flatbuffers.h"
+
+namespace osrm {
+namespace engine {
+namespace api {
+namespace fbresult {
+
+struct Position;
+struct PositionT;
+
+struct Waypoint;
+struct WaypointT;
+
+struct Metadata;
+struct MetadataT;
+
+struct Annotation;
+struct AnnotationT;
+
+struct StepManeuver;
+struct StepManeuverT;
+
+struct Lane;
+struct LaneT;
+
+struct Intersection;
+struct IntersectionT;
+
+struct Polyline;
+struct PolylineT;
+
+struct Step;
+struct StepT;
+
+struct Leg;
+struct LegT;
+
+struct RouteObject;
+struct RouteObjectT;
+
+struct Route;
+struct RouteT;
+
+struct Match;
+struct MatchT;
+
+struct Nearest;
+struct NearestT;
+
+struct VectorUint;
+struct VectorUintT;
+
+struct Table;
+struct TableT;
+
+struct Trip;
+struct TripT;
+
+struct FBResult;
+struct FBResultT;
+
+enum ManeuverType {
+  ManeuverType_Turn = 0,
+  ManeuverType_NewName = 1,
+  ManeuverType_Depart = 2,
+  ManeuverType_Arrive = 3,
+  ManeuverType_Merge = 4,
+  ManeuverType_OnRamp = 5,
+  ManeuverType_OffRamp = 6,
+  ManeuverType_Fork = 7,
+  ManeuverType_EndOfRoad = 8,
+  ManeuverType_Continue = 9,
+  ManeuverType_Roundabout = 10,
+  ManeuverType_Rotary = 11,
+  ManeuverType_RoundaboutTurn = 12,
+  ManeuverType_Notification = 13,
+  ManeuverType_ExitRoundabout = 14,
+  ManeuverType_ExitRotary = 15,
+  ManeuverType_MIN = ManeuverType_Turn,
+  ManeuverType_MAX = ManeuverType_ExitRotary
+};
+
+inline const ManeuverType (&EnumValuesManeuverType())[16] {
+  static const ManeuverType values[] = {
+    ManeuverType_Turn,
+    ManeuverType_NewName,
+    ManeuverType_Depart,
+    ManeuverType_Arrive,
+    ManeuverType_Merge,
+    ManeuverType_OnRamp,
+    ManeuverType_OffRamp,
+    ManeuverType_Fork,
+    ManeuverType_EndOfRoad,
+    ManeuverType_Continue,
+    ManeuverType_Roundabout,
+    ManeuverType_Rotary,
+    ManeuverType_RoundaboutTurn,
+    ManeuverType_Notification,
+    ManeuverType_ExitRoundabout,
+    ManeuverType_ExitRotary
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesManeuverType() {
+  static const char * const names[17] = {
+    "Turn",
+    "NewName",
+    "Depart",
+    "Arrive",
+    "Merge",
+    "OnRamp",
+    "OffRamp",
+    "Fork",
+    "EndOfRoad",
+    "Continue",
+    "Roundabout",
+    "Rotary",
+    "RoundaboutTurn",
+    "Notification",
+    "ExitRoundabout",
+    "ExitRotary",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameManeuverType(ManeuverType e) {
+  if (e < ManeuverType_Turn || e > ManeuverType_ExitRotary) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesManeuverType()[index];
+}
+
+enum Turn {
+  Turn_None = 0,
+  Turn_UTurn = 1,
+  Turn_SharpRight = 2,
+  Turn_Right = 3,
+  Turn_SlightRight = 4,
+  Turn_Straight = 5,
+  Turn_SlightLeft = 6,
+  Turn_Left = 7,
+  Turn_SharpLeft = 8,
+  Turn_MIN = Turn_None,
+  Turn_MAX = Turn_SharpLeft
+};
+
+inline const Turn (&EnumValuesTurn())[9] {
+  static const Turn values[] = {
+    Turn_None,
+    Turn_UTurn,
+    Turn_SharpRight,
+    Turn_Right,
+    Turn_SlightRight,
+    Turn_Straight,
+    Turn_SlightLeft,
+    Turn_Left,
+    Turn_SharpLeft
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesTurn() {
+  static const char * const names[10] = {
+    "None",
+    "UTurn",
+    "SharpRight",
+    "Right",
+    "SlightRight",
+    "Straight",
+    "SlightLeft",
+    "Left",
+    "SharpLeft",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameTurn(Turn e) {
+  if (e < Turn_None || e > Turn_SharpLeft) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesTurn()[index];
+}
+
+enum Geometry {
+  Geometry_NONE = 0,
+  Geometry_polyline = 1,
+  Geometry_polyline6 = 2,
+  Geometry_coordinates = 3,
+  Geometry_MIN = Geometry_NONE,
+  Geometry_MAX = Geometry_coordinates
+};
+
+inline const Geometry (&EnumValuesGeometry())[4] {
+  static const Geometry values[] = {
+    Geometry_NONE,
+    Geometry_polyline,
+    Geometry_polyline6,
+    Geometry_coordinates
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesGeometry() {
+  static const char * const names[5] = {
+    "NONE",
+    "polyline",
+    "polyline6",
+    "coordinates",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameGeometry(Geometry e) {
+  if (e < Geometry_NONE || e > Geometry_coordinates) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesGeometry()[index];
+}
+
+struct GeometryUnion {
+  Geometry type;
+  void *value;
+
+  GeometryUnion() : type(Geometry_NONE), value(nullptr) {}
+  GeometryUnion(GeometryUnion&& u) FLATBUFFERS_NOEXCEPT :
+    type(Geometry_NONE), value(nullptr)
+    { std::swap(type, u.type); std::swap(value, u.value); }
+  GeometryUnion(const GeometryUnion &) FLATBUFFERS_NOEXCEPT;
+  GeometryUnion &operator=(const GeometryUnion &u) FLATBUFFERS_NOEXCEPT
+    { GeometryUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; }
+  GeometryUnion &operator=(GeometryUnion &&u) FLATBUFFERS_NOEXCEPT
+    { std::swap(type, u.type); std::swap(value, u.value); return *this; }
+  ~GeometryUnion() { Reset(); }
+
+  void Reset();
+
+  static void *UnPack(const void *obj, Geometry type, const flatbuffers::resolver_function_t *resolver);
+  flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
+
+  std::string *Aspolyline() {
+    return type == Geometry_polyline ?
+      reinterpret_cast<std::string *>(value) : nullptr;
+  }
+  const std::string *Aspolyline() const {
+    return type == Geometry_polyline ?
+      reinterpret_cast<const std::string *>(value) : nullptr;
+  }
+  std::string *Aspolyline6() {
+    return type == Geometry_polyline6 ?
+      reinterpret_cast<std::string *>(value) : nullptr;
+  }
+  const std::string *Aspolyline6() const {
+    return type == Geometry_polyline6 ?
+      reinterpret_cast<const std::string *>(value) : nullptr;
+  }
+  osrm::engine::api::fbresult::PolylineT *Ascoordinates() {
+    return type == Geometry_coordinates ?
+      reinterpret_cast<osrm::engine::api::fbresult::PolylineT *>(value) : nullptr;
+  }
+  const osrm::engine::api::fbresult::PolylineT *Ascoordinates() const {
+    return type == Geometry_coordinates ?
+      reinterpret_cast<const osrm::engine::api::fbresult::PolylineT *>(value) : nullptr;
+  }
+};
+
+bool VerifyGeometry(flatbuffers::Verifier &verifier, const void *obj, Geometry type);
+bool VerifyGeometryVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
+
+enum ServiceResponse {
+  ServiceResponse_NONE = 0,
+  ServiceResponse_match = 1,
+  ServiceResponse_nearest = 2,
+  ServiceResponse_route = 3,
+  ServiceResponse_table = 4,
+  ServiceResponse_trip = 5,
+  ServiceResponse_MIN = ServiceResponse_NONE,
+  ServiceResponse_MAX = ServiceResponse_trip
+};
+
+inline const ServiceResponse (&EnumValuesServiceResponse())[6] {
+  static const ServiceResponse values[] = {
+    ServiceResponse_NONE,
+    ServiceResponse_match,
+    ServiceResponse_nearest,
+    ServiceResponse_route,
+    ServiceResponse_table,
+    ServiceResponse_trip
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesServiceResponse() {
+  static const char * const names[7] = {
+    "NONE",
+    "match",
+    "nearest",
+    "route",
+    "table",
+    "trip",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameServiceResponse(ServiceResponse e) {
+  if (e < ServiceResponse_NONE || e > ServiceResponse_trip) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesServiceResponse()[index];
+}
+
+template<typename T> struct ServiceResponseTraits {
+  static const ServiceResponse enum_value = ServiceResponse_NONE;
+};
+
+template<> struct ServiceResponseTraits<osrm::engine::api::fbresult::Match> {
+  static const ServiceResponse enum_value = ServiceResponse_match;
+};
+
+template<> struct ServiceResponseTraits<osrm::engine::api::fbresult::Nearest> {
+  static const ServiceResponse enum_value = ServiceResponse_nearest;
+};
+
+template<> struct ServiceResponseTraits<osrm::engine::api::fbresult::Route> {
+  static const ServiceResponse enum_value = ServiceResponse_route;
+};
+
+template<> struct ServiceResponseTraits<osrm::engine::api::fbresult::Table> {
+  static const ServiceResponse enum_value = ServiceResponse_table;
+};
+
+template<> struct ServiceResponseTraits<osrm::engine::api::fbresult::Trip> {
+  static const ServiceResponse enum_value = ServiceResponse_trip;
+};
+
+struct ServiceResponseUnion {
+  ServiceResponse type;
+  void *value;
+
+  ServiceResponseUnion() : type(ServiceResponse_NONE), value(nullptr) {}
+  ServiceResponseUnion(ServiceResponseUnion&& u) FLATBUFFERS_NOEXCEPT :
+    type(ServiceResponse_NONE), value(nullptr)
+    { std::swap(type, u.type); std::swap(value, u.value); }
+  ServiceResponseUnion(const ServiceResponseUnion &) FLATBUFFERS_NOEXCEPT;
+  ServiceResponseUnion &operator=(const ServiceResponseUnion &u) FLATBUFFERS_NOEXCEPT
+    { ServiceResponseUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; }
+  ServiceResponseUnion &operator=(ServiceResponseUnion &&u) FLATBUFFERS_NOEXCEPT
+    { std::swap(type, u.type); std::swap(value, u.value); return *this; }
+  ~ServiceResponseUnion() { Reset(); }
+
+  void Reset();
+
+#ifndef FLATBUFFERS_CPP98_STL
+  template <typename T>
+  void Set(T&& val) {
+    using RT = typename std::remove_reference<T>::type;
+    Reset();
+    type = ServiceResponseTraits<typename RT::TableType>::enum_value;
+    if (type != ServiceResponse_NONE) {
+      value = new RT(std::forward<T>(val));
+    }
+  }
+#endif  // FLATBUFFERS_CPP98_STL
+
+  static void *UnPack(const void *obj, ServiceResponse type, const flatbuffers::resolver_function_t *resolver);
+  flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
+
+  osrm::engine::api::fbresult::MatchT *Asmatch() {
+    return type == ServiceResponse_match ?
+      reinterpret_cast<osrm::engine::api::fbresult::MatchT *>(value) : nullptr;
+  }
+  const osrm::engine::api::fbresult::MatchT *Asmatch() const {
+    return type == ServiceResponse_match ?
+      reinterpret_cast<const osrm::engine::api::fbresult::MatchT *>(value) : nullptr;
+  }
+  osrm::engine::api::fbresult::NearestT *Asnearest() {
+    return type == ServiceResponse_nearest ?
+      reinterpret_cast<osrm::engine::api::fbresult::NearestT *>(value) : nullptr;
+  }
+  const osrm::engine::api::fbresult::NearestT *Asnearest() const {
+    return type == ServiceResponse_nearest ?
+      reinterpret_cast<const osrm::engine::api::fbresult::NearestT *>(value) : nullptr;
+  }
+  osrm::engine::api::fbresult::RouteT *Asroute() {
+    return type == ServiceResponse_route ?
+      reinterpret_cast<osrm::engine::api::fbresult::RouteT *>(value) : nullptr;
+  }
+  const osrm::engine::api::fbresult::RouteT *Asroute() const {
+    return type == ServiceResponse_route ?
+      reinterpret_cast<const osrm::engine::api::fbresult::RouteT *>(value) : nullptr;
+  }
+  osrm::engine::api::fbresult::TableT *Astable() {
+    return type == ServiceResponse_table ?
+      reinterpret_cast<osrm::engine::api::fbresult::TableT *>(value) : nullptr;
+  }
+  const osrm::engine::api::fbresult::TableT *Astable() const {
+    return type == ServiceResponse_table ?
+      reinterpret_cast<const osrm::engine::api::fbresult::TableT *>(value) : nullptr;
+  }
+  osrm::engine::api::fbresult::TripT *Astrip() {
+    return type == ServiceResponse_trip ?
+      reinterpret_cast<osrm::engine::api::fbresult::TripT *>(value) : nullptr;
+  }
+  const osrm::engine::api::fbresult::TripT *Astrip() const {
+    return type == ServiceResponse_trip ?
+      reinterpret_cast<const osrm::engine::api::fbresult::TripT *>(value) : nullptr;
+  }
+};
+
+bool VerifyServiceResponse(flatbuffers::Verifier &verifier, const void *obj, ServiceResponse type);
+bool VerifyServiceResponseVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
+
+struct PositionT : public flatbuffers::NativeTable {
+  typedef Position TableType;
+  double longitute;
+  double latitude;
+  PositionT()
+      : longitute(0.0),
+        latitude(0.0) {
+  }
+};
+
+struct Position FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef PositionT NativeTableType;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_LONGITUTE = 4,
+    VT_LATITUDE = 6
+  };
+  double longitute() const {
+    return GetField<double>(VT_LONGITUTE, 0.0);
+  }
+  double latitude() const {
+    return GetField<double>(VT_LATITUDE, 0.0);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<double>(verifier, VT_LONGITUTE) &&
+           VerifyField<double>(verifier, VT_LATITUDE) &&
+           verifier.EndTable();
+  }
+  PositionT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(PositionT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<Position> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PositionT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct PositionBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_longitute(double longitute) {
+    fbb_.AddElement<double>(Position::VT_LONGITUTE, longitute, 0.0);
+  }
+  void add_latitude(double latitude) {
+    fbb_.AddElement<double>(Position::VT_LATITUDE, latitude, 0.0);
+  }
+  explicit PositionBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  PositionBuilder &operator=(const PositionBuilder &);
+  flatbuffers::Offset<Position> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<Position>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Position> CreatePosition(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    double longitute = 0.0,
+    double latitude = 0.0) {
+  PositionBuilder builder_(_fbb);
+  builder_.add_latitude(latitude);
+  builder_.add_longitute(longitute);
+  return builder_.Finish();
+}
+
+flatbuffers::Offset<Position> CreatePosition(flatbuffers::FlatBufferBuilder &_fbb, const PositionT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct WaypointT : public flatbuffers::NativeTable {
+  typedef Waypoint TableType;
+  double longitute;
+  double latitude;
+  std::string name;
+  std::unique_ptr<osrm::engine::api::fbresult::PositionT> location;
+  std::vector<double> nodes;
+  uint32_t matchings_index;
+  uint32_t waypoint_index;
+  uint32_t alternatives_count;
+  uint32_t trips_index;
+  WaypointT()
+      : longitute(0.0),
+        latitude(0.0),
+        matchings_index(0),
+        waypoint_index(0),
+        alternatives_count(0),
+        trips_index(0) {
+  }
+};
+
+struct Waypoint FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef WaypointT NativeTableType;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_LONGITUTE = 4,
+    VT_LATITUDE = 6,
+    VT_NAME = 8,
+    VT_LOCATION = 10,
+    VT_NODES = 12,
+    VT_MATCHINGS_INDEX = 14,
+    VT_WAYPOINT_INDEX = 16,
+    VT_ALTERNATIVES_COUNT = 18,
+    VT_TRIPS_INDEX = 20
+  };
+  double longitute() const {
+    return GetField<double>(VT_LONGITUTE, 0.0);
+  }
+  double latitude() const {
+    return GetField<double>(VT_LATITUDE, 0.0);
+  }
+  const flatbuffers::String *name() const {
+    return GetPointer<const flatbuffers::String *>(VT_NAME);
+  }
+  const osrm::engine::api::fbresult::Position *location() const {
+    return GetPointer<const osrm::engine::api::fbresult::Position *>(VT_LOCATION);
+  }
+  const flatbuffers::Vector<double> *nodes() const {
+    return GetPointer<const flatbuffers::Vector<double> *>(VT_NODES);
+  }
+  uint32_t matchings_index() const {
+    return GetField<uint32_t>(VT_MATCHINGS_INDEX, 0);
+  }
+  uint32_t waypoint_index() const {
+    return GetField<uint32_t>(VT_WAYPOINT_INDEX, 0);
+  }
+  uint32_t alternatives_count() const {
+    return GetField<uint32_t>(VT_ALTERNATIVES_COUNT, 0);
+  }
+  uint32_t trips_index() const {
+    return GetField<uint32_t>(VT_TRIPS_INDEX, 0);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<double>(verifier, VT_LONGITUTE) &&
+           VerifyField<double>(verifier, VT_LATITUDE) &&
+           VerifyOffset(verifier, VT_NAME) &&
+           verifier.VerifyString(name()) &&
+           VerifyOffset(verifier, VT_LOCATION) &&
+           verifier.VerifyTable(location()) &&
+           VerifyOffset(verifier, VT_NODES) &&
+           verifier.VerifyVector(nodes()) &&
+           VerifyField<uint32_t>(verifier, VT_MATCHINGS_INDEX) &&
+           VerifyField<uint32_t>(verifier, VT_WAYPOINT_INDEX) &&
+           VerifyField<uint32_t>(verifier, VT_ALTERNATIVES_COUNT) &&
+           VerifyField<uint32_t>(verifier, VT_TRIPS_INDEX) &&
+           verifier.EndTable();
+  }
+  WaypointT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(WaypointT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<Waypoint> Pack(flatbuffers::FlatBufferBuilder &_fbb, const WaypointT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct WaypointBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_longitute(double longitute) {
+    fbb_.AddElement<double>(Waypoint::VT_LONGITUTE, longitute, 0.0);
+  }
+  void add_latitude(double latitude) {
+    fbb_.AddElement<double>(Waypoint::VT_LATITUDE, latitude, 0.0);
+  }
+  void add_name(flatbuffers::Offset<flatbuffers::String> name) {
+    fbb_.AddOffset(Waypoint::VT_NAME, name);
+  }
+  void add_location(flatbuffers::Offset<osrm::engine::api::fbresult::Position> location) {
+    fbb_.AddOffset(Waypoint::VT_LOCATION, location);
+  }
+  void add_nodes(flatbuffers::Offset<flatbuffers::Vector<double>> nodes) {
+    fbb_.AddOffset(Waypoint::VT_NODES, nodes);
+  }
+  void add_matchings_index(uint32_t matchings_index) {
+    fbb_.AddElement<uint32_t>(Waypoint::VT_MATCHINGS_INDEX, matchings_index, 0);
+  }
+  void add_waypoint_index(uint32_t waypoint_index) {
+    fbb_.AddElement<uint32_t>(Waypoint::VT_WAYPOINT_INDEX, waypoint_index, 0);
+  }
+  void add_alternatives_count(uint32_t alternatives_count) {
+    fbb_.AddElement<uint32_t>(Waypoint::VT_ALTERNATIVES_COUNT, alternatives_count, 0);
+  }
+  void add_trips_index(uint32_t trips_index) {
+    fbb_.AddElement<uint32_t>(Waypoint::VT_TRIPS_INDEX, trips_index, 0);
+  }
+  explicit WaypointBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  WaypointBuilder &operator=(const WaypointBuilder &);
+  flatbuffers::Offset<Waypoint> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<Waypoint>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Waypoint> CreateWaypoint(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    double longitute = 0.0,
+    double latitude = 0.0,
+    flatbuffers::Offset<flatbuffers::String> name = 0,
+    flatbuffers::Offset<osrm::engine::api::fbresult::Position> location = 0,
+    flatbuffers::Offset<flatbuffers::Vector<double>> nodes = 0,
+    uint32_t matchings_index = 0,
+    uint32_t waypoint_index = 0,
+    uint32_t alternatives_count = 0,
+    uint32_t trips_index = 0) {
+  WaypointBuilder builder_(_fbb);
+  builder_.add_latitude(latitude);
+  builder_.add_longitute(longitute);
+  builder_.add_trips_index(trips_index);
+  builder_.add_alternatives_count(alternatives_count);
+  builder_.add_waypoint_index(waypoint_index);
+  builder_.add_matchings_index(matchings_index);
+  builder_.add_nodes(nodes);
+  builder_.add_location(location);
+  builder_.add_name(name);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<Waypoint> CreateWaypointDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    double longitute = 0.0,
+    double latitude = 0.0,
+    const char *name = nullptr,
+    flatbuffers::Offset<osrm::engine::api::fbresult::Position> location = 0,
+    const std::vector<double> *nodes = nullptr,
+    uint32_t matchings_index = 0,
+    uint32_t waypoint_index = 0,
+    uint32_t alternatives_count = 0,
+    uint32_t trips_index = 0) {
+  auto name__ = name ? _fbb.CreateString(name) : 0;
+  auto nodes__ = nodes ? _fbb.CreateVector<double>(*nodes) : 0;
+  return osrm::engine::api::fbresult::CreateWaypoint(
+      _fbb,
+      longitute,
+      latitude,
+      name__,
+      location,
+      nodes__,
+      matchings_index,
+      waypoint_index,
+      alternatives_count,
+      trips_index);
+}
+
+flatbuffers::Offset<Waypoint> CreateWaypoint(flatbuffers::FlatBufferBuilder &_fbb, const WaypointT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct MetadataT : public flatbuffers::NativeTable {
+  typedef Metadata TableType;
+  std::vector<std::string> datasource_names;
+  MetadataT() {
+  }
+};
+
+struct Metadata FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef MetadataT NativeTableType;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_DATASOURCE_NAMES = 4
+  };
+  const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *datasource_names() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_DATASOURCE_NAMES);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_DATASOURCE_NAMES) &&
+           verifier.VerifyVector(datasource_names()) &&
+           verifier.VerifyVectorOfStrings(datasource_names()) &&
+           verifier.EndTable();
+  }
+  MetadataT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(MetadataT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<Metadata> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MetadataT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct MetadataBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_datasource_names(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> datasource_names) {
+    fbb_.AddOffset(Metadata::VT_DATASOURCE_NAMES, datasource_names);
+  }
+  explicit MetadataBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  MetadataBuilder &operator=(const MetadataBuilder &);
+  flatbuffers::Offset<Metadata> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<Metadata>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Metadata> CreateMetadata(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> datasource_names = 0) {
+  MetadataBuilder builder_(_fbb);
+  builder_.add_datasource_names(datasource_names);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<Metadata> CreateMetadataDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const std::vector<flatbuffers::Offset<flatbuffers::String>> *datasource_names = nullptr) {
+  auto datasource_names__ = datasource_names ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*datasource_names) : 0;
+  return osrm::engine::api::fbresult::CreateMetadata(
+      _fbb,
+      datasource_names__);
+}
+
+flatbuffers::Offset<Metadata> CreateMetadata(flatbuffers::FlatBufferBuilder &_fbb, const MetadataT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct AnnotationT : public flatbuffers::NativeTable {
+  typedef Annotation TableType;
+  std::vector<uint32_t> distance;
+  std::vector<uint32_t> duration;
+  std::vector<uint32_t> datasources;
+  std::vector<uint32_t> nodes;
+  std::vector<uint32_t> weight;
+  std::vector<double> speed;
+  std::unique_ptr<osrm::engine::api::fbresult::MetadataT> metadata;
+  AnnotationT() {
+  }
+};
+
+struct Annotation FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef AnnotationT NativeTableType;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_DISTANCE = 4,
+    VT_DURATION = 6,
+    VT_DATASOURCES = 8,
+    VT_NODES = 10,
+    VT_WEIGHT = 12,
+    VT_SPEED = 14,
+    VT_METADATA = 16
+  };
+  const flatbuffers::Vector<uint32_t> *distance() const {
+    return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_DISTANCE);
+  }
+  const flatbuffers::Vector<uint32_t> *duration() const {
+    return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_DURATION);
+  }
+  const flatbuffers::Vector<uint32_t> *datasources() const {
+    return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_DATASOURCES);
+  }
+  const flatbuffers::Vector<uint32_t> *nodes() const {
+    return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_NODES);
+  }
+  const flatbuffers::Vector<uint32_t> *weight() const {
+    return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_WEIGHT);
+  }
+  const flatbuffers::Vector<double> *speed() const {
+    return GetPointer<const flatbuffers::Vector<double> *>(VT_SPEED);
+  }
+  const osrm::engine::api::fbresult::Metadata *metadata() const {
+    return GetPointer<const osrm::engine::api::fbresult::Metadata *>(VT_METADATA);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_DISTANCE) &&
+           verifier.VerifyVector(distance()) &&
+           VerifyOffset(verifier, VT_DURATION) &&
+           verifier.VerifyVector(duration()) &&
+           VerifyOffset(verifier, VT_DATASOURCES) &&
+           verifier.VerifyVector(datasources()) &&
+           VerifyOffset(verifier, VT_NODES) &&
+           verifier.VerifyVector(nodes()) &&
+           VerifyOffset(verifier, VT_WEIGHT) &&
+           verifier.VerifyVector(weight()) &&
+           VerifyOffset(verifier, VT_SPEED) &&
+           verifier.VerifyVector(speed()) &&
+           VerifyOffset(verifier, VT_METADATA) &&
+           verifier.VerifyTable(metadata()) &&
+           verifier.EndTable();
+  }
+  AnnotationT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(AnnotationT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<Annotation> Pack(flatbuffers::FlatBufferBuilder &_fbb, const AnnotationT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct AnnotationBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_distance(flatbuffers::Offset<flatbuffers::Vector<uint32_t>> distance) {
+    fbb_.AddOffset(Annotation::VT_DISTANCE, distance);
+  }
+  void add_duration(flatbuffers::Offset<flatbuffers::Vector<uint32_t>> duration) {
+    fbb_.AddOffset(Annotation::VT_DURATION, duration);
+  }
+  void add_datasources(flatbuffers::Offset<flatbuffers::Vector<uint32_t>> datasources) {
+    fbb_.AddOffset(Annotation::VT_DATASOURCES, datasources);
+  }
+  void add_nodes(flatbuffers::Offset<flatbuffers::Vector<uint32_t>> nodes) {
+    fbb_.AddOffset(Annotation::VT_NODES, nodes);
+  }
+  void add_weight(flatbuffers::Offset<flatbuffers::Vector<uint32_t>> weight) {
+    fbb_.AddOffset(Annotation::VT_WEIGHT, weight);
+  }
+  void add_speed(flatbuffers::Offset<flatbuffers::Vector<double>> speed) {
+    fbb_.AddOffset(Annotation::VT_SPEED, speed);
+  }
+  void add_metadata(flatbuffers::Offset<osrm::engine::api::fbresult::Metadata> metadata) {
+    fbb_.AddOffset(Annotation::VT_METADATA, metadata);
+  }
+  explicit AnnotationBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  AnnotationBuilder &operator=(const AnnotationBuilder &);
+  flatbuffers::Offset<Annotation> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<Annotation>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Annotation> CreateAnnotation(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::Vector<uint32_t>> distance = 0,
+    flatbuffers::Offset<flatbuffers::Vector<uint32_t>> duration = 0,
+    flatbuffers::Offset<flatbuffers::Vector<uint32_t>> datasources = 0,
+    flatbuffers::Offset<flatbuffers::Vector<uint32_t>> nodes = 0,
+    flatbuffers::Offset<flatbuffers::Vector<uint32_t>> weight = 0,
+    flatbuffers::Offset<flatbuffers::Vector<double>> speed = 0,
+    flatbuffers::Offset<osrm::engine::api::fbresult::Metadata> metadata = 0) {
+  AnnotationBuilder builder_(_fbb);
+  builder_.add_metadata(metadata);
+  builder_.add_speed(speed);
+  builder_.add_weight(weight);
+  builder_.add_nodes(nodes);
+  builder_.add_datasources(datasources);
+  builder_.add_duration(duration);
+  builder_.add_distance(distance);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<Annotation> CreateAnnotationDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const std::vector<uint32_t> *distance = nullptr,
+    const std::vector<uint32_t> *duration = nullptr,
+    const std::vector<uint32_t> *datasources = nullptr,
+    const std::vector<uint32_t> *nodes = nullptr,
+    const std::vector<uint32_t> *weight = nullptr,
+    const std::vector<double> *speed = nullptr,
+    flatbuffers::Offset<osrm::engine::api::fbresult::Metadata> metadata = 0) {
+  auto distance__ = distance ? _fbb.CreateVector<uint32_t>(*distance) : 0;
+  auto duration__ = duration ? _fbb.CreateVector<uint32_t>(*duration) : 0;
+  auto datasources__ = datasources ? _fbb.CreateVector<uint32_t>(*datasources) : 0;
+  auto nodes__ = nodes ? _fbb.CreateVector<uint32_t>(*nodes) : 0;
+  auto weight__ = weight ? _fbb.CreateVector<uint32_t>(*weight) : 0;
+  auto speed__ = speed ? _fbb.CreateVector<double>(*speed) : 0;
+  return osrm::engine::api::fbresult::CreateAnnotation(
+      _fbb,
+      distance__,
+      duration__,
+      datasources__,
+      nodes__,
+      weight__,
+      speed__,
+      metadata);
+}
+
+flatbuffers::Offset<Annotation> CreateAnnotation(flatbuffers::FlatBufferBuilder &_fbb, const AnnotationT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct StepManeuverT : public flatbuffers::NativeTable {
+  typedef StepManeuver TableType;
+  std::unique_ptr<osrm::engine::api::fbresult::PositionT> location;
+  uint16_t bearing_before;
+  uint16_t bearing_after;
+  osrm::engine::api::fbresult::ManeuverType type;
+  osrm::engine::api::fbresult::Turn modifier;
+  uint8_t exit;
+  StepManeuverT()
+      : bearing_before(0),
+        bearing_after(0),
+        type(osrm::engine::api::fbresult::ManeuverType_Turn),
+        modifier(osrm::engine::api::fbresult::Turn_None),
+        exit(0) {
+  }
+};
+
+struct StepManeuver FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef StepManeuverT NativeTableType;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_LOCATION = 4,
+    VT_BEARING_BEFORE = 6,
+    VT_BEARING_AFTER = 8,
+    VT_TYPE = 10,
+    VT_MODIFIER = 12,
+    VT_EXIT = 14
+  };
+  const osrm::engine::api::fbresult::Position *location() const {
+    return GetPointer<const osrm::engine::api::fbresult::Position *>(VT_LOCATION);
+  }
+  uint16_t bearing_before() const {
+    return GetField<uint16_t>(VT_BEARING_BEFORE, 0);
+  }
+  uint16_t bearing_after() const {
+    return GetField<uint16_t>(VT_BEARING_AFTER, 0);
+  }
+  osrm::engine::api::fbresult::ManeuverType type() const {
+    return static_cast<osrm::engine::api::fbresult::ManeuverType>(GetField<int8_t>(VT_TYPE, 0));
+  }
+  osrm::engine::api::fbresult::Turn modifier() const {
+    return static_cast<osrm::engine::api::fbresult::Turn>(GetField<int8_t>(VT_MODIFIER, 0));
+  }
+  uint8_t exit() const {
+    return GetField<uint8_t>(VT_EXIT, 0);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_LOCATION) &&
+           verifier.VerifyTable(location()) &&
+           VerifyField<uint16_t>(verifier, VT_BEARING_BEFORE) &&
+           VerifyField<uint16_t>(verifier, VT_BEARING_AFTER) &&
+           VerifyField<int8_t>(verifier, VT_TYPE) &&
+           VerifyField<int8_t>(verifier, VT_MODIFIER) &&
+           VerifyField<uint8_t>(verifier, VT_EXIT) &&
+           verifier.EndTable();
+  }
+  StepManeuverT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(StepManeuverT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<StepManeuver> Pack(flatbuffers::FlatBufferBuilder &_fbb, const StepManeuverT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct StepManeuverBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_location(flatbuffers::Offset<osrm::engine::api::fbresult::Position> location) {
+    fbb_.AddOffset(StepManeuver::VT_LOCATION, location);
+  }
+  void add_bearing_before(uint16_t bearing_before) {
+    fbb_.AddElement<uint16_t>(StepManeuver::VT_BEARING_BEFORE, bearing_before, 0);
+  }
+  void add_bearing_after(uint16_t bearing_after) {
+    fbb_.AddElement<uint16_t>(StepManeuver::VT_BEARING_AFTER, bearing_after, 0);
+  }
+  void add_type(osrm::engine::api::fbresult::ManeuverType type) {
+    fbb_.AddElement<int8_t>(StepManeuver::VT_TYPE, static_cast<int8_t>(type), 0);
+  }
+  void add_modifier(osrm::engine::api::fbresult::Turn modifier) {
+    fbb_.AddElement<int8_t>(StepManeuver::VT_MODIFIER, static_cast<int8_t>(modifier), 0);
+  }
+  void add_exit(uint8_t exit) {
+    fbb_.AddElement<uint8_t>(StepManeuver::VT_EXIT, exit, 0);
+  }
+  explicit StepManeuverBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  StepManeuverBuilder &operator=(const StepManeuverBuilder &);
+  flatbuffers::Offset<StepManeuver> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<StepManeuver>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<StepManeuver> CreateStepManeuver(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<osrm::engine::api::fbresult::Position> location = 0,
+    uint16_t bearing_before = 0,
+    uint16_t bearing_after = 0,
+    osrm::engine::api::fbresult::ManeuverType type = osrm::engine::api::fbresult::ManeuverType_Turn,
+    osrm::engine::api::fbresult::Turn modifier = osrm::engine::api::fbresult::Turn_None,
+    uint8_t exit = 0) {
+  StepManeuverBuilder builder_(_fbb);
+  builder_.add_location(location);
+  builder_.add_bearing_after(bearing_after);
+  builder_.add_bearing_before(bearing_before);
+  builder_.add_exit(exit);
+  builder_.add_modifier(modifier);
+  builder_.add_type(type);
+  return builder_.Finish();
+}
+
+flatbuffers::Offset<StepManeuver> CreateStepManeuver(flatbuffers::FlatBufferBuilder &_fbb, const StepManeuverT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct LaneT : public flatbuffers::NativeTable {
+  typedef Lane TableType;
+  std::vector<osrm::engine::api::fbresult::Turn> indications;
+  bool valid;
+  LaneT()
+      : valid(false) {
+  }
+};
+
+struct Lane FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef LaneT NativeTableType;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_INDICATIONS = 4,
+    VT_VALID = 6
+  };
+  const flatbuffers::Vector<int8_t> *indications() const {
+    return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_INDICATIONS);
+  }
+  bool valid() const {
+    return GetField<uint8_t>(VT_VALID, 0) != 0;
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_INDICATIONS) &&
+           verifier.VerifyVector(indications()) &&
+           VerifyField<uint8_t>(verifier, VT_VALID) &&
+           verifier.EndTable();
+  }
+  LaneT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(LaneT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<Lane> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LaneT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct LaneBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_indications(flatbuffers::Offset<flatbuffers::Vector<int8_t>> indications) {
+    fbb_.AddOffset(Lane::VT_INDICATIONS, indications);
+  }
+  void add_valid(bool valid) {
+    fbb_.AddElement<uint8_t>(Lane::VT_VALID, static_cast<uint8_t>(valid), 0);
+  }
+  explicit LaneBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  LaneBuilder &operator=(const LaneBuilder &);
+  flatbuffers::Offset<Lane> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<Lane>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Lane> CreateLane(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::Vector<int8_t>> indications = 0,
+    bool valid = false) {
+  LaneBuilder builder_(_fbb);
+  builder_.add_indications(indications);
+  builder_.add_valid(valid);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<Lane> CreateLaneDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const std::vector<int8_t> *indications = nullptr,
+    bool valid = false) {
+  auto indications__ = indications ? _fbb.CreateVector<int8_t>(*indications) : 0;
+  return osrm::engine::api::fbresult::CreateLane(
+      _fbb,
+      indications__,
+      valid);
+}
+
+flatbuffers::Offset<Lane> CreateLane(flatbuffers::FlatBufferBuilder &_fbb, const LaneT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct IntersectionT : public flatbuffers::NativeTable {
+  typedef Intersection TableType;
+  std::unique_ptr<osrm::engine::api::fbresult::PositionT> location;
+  std::vector<uint16_t> bearings;
+  std::vector<std::string> classes;
+  std::vector<bool> entry;
+  uint32_t in;
+  uint32_t out;
+  std::vector<std::unique_ptr<osrm::engine::api::fbresult::LaneT>> lanes;
+  IntersectionT()
+      : in(0),
+        out(0) {
+  }
+};
+
+struct Intersection FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef IntersectionT NativeTableType;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_LOCATION = 4,
+    VT_BEARINGS = 6,
+    VT_CLASSES = 8,
+    VT_ENTRY = 10,
+    VT_IN = 12,
+    VT_OUT = 14,
+    VT_LANES = 16
+  };
+  const osrm::engine::api::fbresult::Position *location() const {
+    return GetPointer<const osrm::engine::api::fbresult::Position *>(VT_LOCATION);
+  }
+  const flatbuffers::Vector<uint16_t> *bearings() const {
+    return GetPointer<const flatbuffers::Vector<uint16_t> *>(VT_BEARINGS);
+  }
+  const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *classes() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_CLASSES);
+  }
+  const flatbuffers::Vector<uint8_t> *entry() const {
+    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_ENTRY);
+  }
+  uint32_t in() const {
+    return GetField<uint32_t>(VT_IN, 0);
+  }
+  uint32_t out() const {
+    return GetField<uint32_t>(VT_OUT, 0);
+  }
+  const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Lane>> *lanes() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Lane>> *>(VT_LANES);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_LOCATION) &&
+           verifier.VerifyTable(location()) &&
+           VerifyOffset(verifier, VT_BEARINGS) &&
+           verifier.VerifyVector(bearings()) &&
+           VerifyOffset(verifier, VT_CLASSES) &&
+           verifier.VerifyVector(classes()) &&
+           verifier.VerifyVectorOfStrings(classes()) &&
+           VerifyOffset(verifier, VT_ENTRY) &&
+           verifier.VerifyVector(entry()) &&
+           VerifyField<uint32_t>(verifier, VT_IN) &&
+           VerifyField<uint32_t>(verifier, VT_OUT) &&
+           VerifyOffset(verifier, VT_LANES) &&
+           verifier.VerifyVector(lanes()) &&
+           verifier.VerifyVectorOfTables(lanes()) &&
+           verifier.EndTable();
+  }
+  IntersectionT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(IntersectionT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<Intersection> Pack(flatbuffers::FlatBufferBuilder &_fbb, const IntersectionT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct IntersectionBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_location(flatbuffers::Offset<osrm::engine::api::fbresult::Position> location) {
+    fbb_.AddOffset(Intersection::VT_LOCATION, location);
+  }
+  void add_bearings(flatbuffers::Offset<flatbuffers::Vector<uint16_t>> bearings) {
+    fbb_.AddOffset(Intersection::VT_BEARINGS, bearings);
+  }
+  void add_classes(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> classes) {
+    fbb_.AddOffset(Intersection::VT_CLASSES, classes);
+  }
+  void add_entry(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> entry) {
+    fbb_.AddOffset(Intersection::VT_ENTRY, entry);
+  }
+  void add_in(uint32_t in) {
+    fbb_.AddElement<uint32_t>(Intersection::VT_IN, in, 0);
+  }
+  void add_out(uint32_t out) {
+    fbb_.AddElement<uint32_t>(Intersection::VT_OUT, out, 0);
+  }
+  void add_lanes(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Lane>>> lanes) {
+    fbb_.AddOffset(Intersection::VT_LANES, lanes);
+  }
+  explicit IntersectionBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  IntersectionBuilder &operator=(const IntersectionBuilder &);
+  flatbuffers::Offset<Intersection> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<Intersection>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Intersection> CreateIntersection(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<osrm::engine::api::fbresult::Position> location = 0,
+    flatbuffers::Offset<flatbuffers::Vector<uint16_t>> bearings = 0,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> classes = 0,
+    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> entry = 0,
+    uint32_t in = 0,
+    uint32_t out = 0,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Lane>>> lanes = 0) {
+  IntersectionBuilder builder_(_fbb);
+  builder_.add_lanes(lanes);
+  builder_.add_out(out);
+  builder_.add_in(in);
+  builder_.add_entry(entry);
+  builder_.add_classes(classes);
+  builder_.add_bearings(bearings);
+  builder_.add_location(location);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<Intersection> CreateIntersectionDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<osrm::engine::api::fbresult::Position> location = 0,
+    const std::vector<uint16_t> *bearings = nullptr,
+    const std::vector<flatbuffers::Offset<flatbuffers::String>> *classes = nullptr,
+    const std::vector<uint8_t> *entry = nullptr,
+    uint32_t in = 0,
+    uint32_t out = 0,
+    const std::vector<flatbuffers::Offset<osrm::engine::api::fbresult::Lane>> *lanes = nullptr) {
+  auto bearings__ = bearings ? _fbb.CreateVector<uint16_t>(*bearings) : 0;
+  auto classes__ = classes ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*classes) : 0;
+  auto entry__ = entry ? _fbb.CreateVector<uint8_t>(*entry) : 0;
+  auto lanes__ = lanes ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Lane>>(*lanes) : 0;
+  return osrm::engine::api::fbresult::CreateIntersection(
+      _fbb,
+      location,
+      bearings__,
+      classes__,
+      entry__,
+      in,
+      out,
+      lanes__);
+}
+
+flatbuffers::Offset<Intersection> CreateIntersection(flatbuffers::FlatBufferBuilder &_fbb, const IntersectionT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct PolylineT : public flatbuffers::NativeTable {
+  typedef Polyline TableType;
+  std::vector<std::unique_ptr<osrm::engine::api::fbresult::PositionT>> polyline;
+  PolylineT() {
+  }
+};
+
+struct Polyline FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef PolylineT NativeTableType;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_POLYLINE = 4
+  };
+  const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Position>> *polyline() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Position>> *>(VT_POLYLINE);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_POLYLINE) &&
+           verifier.VerifyVector(polyline()) &&
+           verifier.VerifyVectorOfTables(polyline()) &&
+           verifier.EndTable();
+  }
+  PolylineT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(PolylineT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<Polyline> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PolylineT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct PolylineBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_polyline(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Position>>> polyline) {
+    fbb_.AddOffset(Polyline::VT_POLYLINE, polyline);
+  }
+  explicit PolylineBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  PolylineBuilder &operator=(const PolylineBuilder &);
+  flatbuffers::Offset<Polyline> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<Polyline>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Polyline> CreatePolyline(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Position>>> polyline = 0) {
+  PolylineBuilder builder_(_fbb);
+  builder_.add_polyline(polyline);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<Polyline> CreatePolylineDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const std::vector<flatbuffers::Offset<osrm::engine::api::fbresult::Position>> *polyline = nullptr) {
+  auto polyline__ = polyline ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Position>>(*polyline) : 0;
+  return osrm::engine::api::fbresult::CreatePolyline(
+      _fbb,
+      polyline__);
+}
+
+flatbuffers::Offset<Polyline> CreatePolyline(flatbuffers::FlatBufferBuilder &_fbb, const PolylineT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct StepT : public flatbuffers::NativeTable {
+  typedef Step TableType;
+  double distance;
+  double duration;
+  GeometryUnion geometry;
+  std::string name;
+  uint32_t ref;
+  std::string pronunciation;
+  std::vector<std::string> destinations;
+  std::vector<std::string> exits;
+  std::string mode;
+  std::unique_ptr<osrm::engine::api::fbresult::StepManeuverT> maneuver;
+  std::vector<std::unique_ptr<osrm::engine::api::fbresult::IntersectionT>> intersections;
+  std::string rotary_name;
+  std::string rotary_pronunciation;
+  bool driving_side;
+  StepT()
+      : distance(0.0),
+        duration(0.0),
+        ref(0),
+        driving_side(false) {
+  }
+};
+
+struct Step FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef StepT NativeTableType;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_DISTANCE = 4,
+    VT_DURATION = 6,
+    VT_GEOMETRY_TYPE = 8,
+    VT_GEOMETRY = 10,
+    VT_NAME = 12,
+    VT_REF = 14,
+    VT_PRONUNCIATION = 16,
+    VT_DESTINATIONS = 18,
+    VT_EXITS = 20,
+    VT_MODE = 22,
+    VT_MANEUVER = 24,
+    VT_INTERSECTIONS = 26,
+    VT_ROTARY_NAME = 28,
+    VT_ROTARY_PRONUNCIATION = 30,
+    VT_DRIVING_SIDE = 32
+  };
+  double distance() const {
+    return GetField<double>(VT_DISTANCE, 0.0);
+  }
+  double duration() const {
+    return GetField<double>(VT_DURATION, 0.0);
+  }
+  osrm::engine::api::fbresult::Geometry geometry_type() const {
+    return static_cast<osrm::engine::api::fbresult::Geometry>(GetField<uint8_t>(VT_GEOMETRY_TYPE, 0));
+  }
+  const void *geometry() const {
+    return GetPointer<const void *>(VT_GEOMETRY);
+  }
+  const flatbuffers::String *geometry_as_polyline() const {
+    return geometry_type() == osrm::engine::api::fbresult::Geometry_polyline ? static_cast<const flatbuffers::String *>(geometry()) : nullptr;
+  }
+  const flatbuffers::String *geometry_as_polyline6() const {
+    return geometry_type() == osrm::engine::api::fbresult::Geometry_polyline6 ? static_cast<const flatbuffers::String *>(geometry()) : nullptr;
+  }
+  const osrm::engine::api::fbresult::Polyline *geometry_as_coordinates() const {
+    return geometry_type() == osrm::engine::api::fbresult::Geometry_coordinates ? static_cast<const osrm::engine::api::fbresult::Polyline *>(geometry()) : nullptr;
+  }
+  const flatbuffers::String *name() const {
+    return GetPointer<const flatbuffers::String *>(VT_NAME);
+  }
+  uint32_t ref() const {
+    return GetField<uint32_t>(VT_REF, 0);
+  }
+  const flatbuffers::String *pronunciation() const {
+    return GetPointer<const flatbuffers::String *>(VT_PRONUNCIATION);
+  }
+  const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *destinations() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_DESTINATIONS);
+  }
+  const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *exits() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_EXITS);
+  }
+  const flatbuffers::String *mode() const {
+    return GetPointer<const flatbuffers::String *>(VT_MODE);
+  }
+  const osrm::engine::api::fbresult::StepManeuver *maneuver() const {
+    return GetPointer<const osrm::engine::api::fbresult::StepManeuver *>(VT_MANEUVER);
+  }
+  const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Intersection>> *intersections() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Intersection>> *>(VT_INTERSECTIONS);
+  }
+  const flatbuffers::String *rotary_name() const {
+    return GetPointer<const flatbuffers::String *>(VT_ROTARY_NAME);
+  }
+  const flatbuffers::String *rotary_pronunciation() const {
+    return GetPointer<const flatbuffers::String *>(VT_ROTARY_PRONUNCIATION);
+  }
+  bool driving_side() const {
+    return GetField<uint8_t>(VT_DRIVING_SIDE, 0) != 0;
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<double>(verifier, VT_DISTANCE) &&
+           VerifyField<double>(verifier, VT_DURATION) &&
+           VerifyField<uint8_t>(verifier, VT_GEOMETRY_TYPE) &&
+           VerifyOffset(verifier, VT_GEOMETRY) &&
+           VerifyGeometry(verifier, geometry(), geometry_type()) &&
+           VerifyOffset(verifier, VT_NAME) &&
+           verifier.VerifyString(name()) &&
+           VerifyField<uint32_t>(verifier, VT_REF) &&
+           VerifyOffset(verifier, VT_PRONUNCIATION) &&
+           verifier.VerifyString(pronunciation()) &&
+           VerifyOffset(verifier, VT_DESTINATIONS) &&
+           verifier.VerifyVector(destinations()) &&
+           verifier.VerifyVectorOfStrings(destinations()) &&
+           VerifyOffset(verifier, VT_EXITS) &&
+           verifier.VerifyVector(exits()) &&
+           verifier.VerifyVectorOfStrings(exits()) &&
+           VerifyOffset(verifier, VT_MODE) &&
+           verifier.VerifyString(mode()) &&
+           VerifyOffset(verifier, VT_MANEUVER) &&
+           verifier.VerifyTable(maneuver()) &&
+           VerifyOffset(verifier, VT_INTERSECTIONS) &&
+           verifier.VerifyVector(intersections()) &&
+           verifier.VerifyVectorOfTables(intersections()) &&
+           VerifyOffset(verifier, VT_ROTARY_NAME) &&
+           verifier.VerifyString(rotary_name()) &&
+           VerifyOffset(verifier, VT_ROTARY_PRONUNCIATION) &&
+           verifier.VerifyString(rotary_pronunciation()) &&
+           VerifyField<uint8_t>(verifier, VT_DRIVING_SIDE) &&
+           verifier.EndTable();
+  }
+  StepT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(StepT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<Step> Pack(flatbuffers::FlatBufferBuilder &_fbb, const StepT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct StepBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_distance(double distance) {
+    fbb_.AddElement<double>(Step::VT_DISTANCE, distance, 0.0);
+  }
+  void add_duration(double duration) {
+    fbb_.AddElement<double>(Step::VT_DURATION, duration, 0.0);
+  }
+  void add_geometry_type(osrm::engine::api::fbresult::Geometry geometry_type) {
+    fbb_.AddElement<uint8_t>(Step::VT_GEOMETRY_TYPE, static_cast<uint8_t>(geometry_type), 0);
+  }
+  void add_geometry(flatbuffers::Offset<void> geometry) {
+    fbb_.AddOffset(Step::VT_GEOMETRY, geometry);
+  }
+  void add_name(flatbuffers::Offset<flatbuffers::String> name) {
+    fbb_.AddOffset(Step::VT_NAME, name);
+  }
+  void add_ref(uint32_t ref) {
+    fbb_.AddElement<uint32_t>(Step::VT_REF, ref, 0);
+  }
+  void add_pronunciation(flatbuffers::Offset<flatbuffers::String> pronunciation) {
+    fbb_.AddOffset(Step::VT_PRONUNCIATION, pronunciation);
+  }
+  void add_destinations(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> destinations) {
+    fbb_.AddOffset(Step::VT_DESTINATIONS, destinations);
+  }
+  void add_exits(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> exits) {
+    fbb_.AddOffset(Step::VT_EXITS, exits);
+  }
+  void add_mode(flatbuffers::Offset<flatbuffers::String> mode) {
+    fbb_.AddOffset(Step::VT_MODE, mode);
+  }
+  void add_maneuver(flatbuffers::Offset<osrm::engine::api::fbresult::StepManeuver> maneuver) {
+    fbb_.AddOffset(Step::VT_MANEUVER, maneuver);
+  }
+  void add_intersections(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Intersection>>> intersections) {
+    fbb_.AddOffset(Step::VT_INTERSECTIONS, intersections);
+  }
+  void add_rotary_name(flatbuffers::Offset<flatbuffers::String> rotary_name) {
+    fbb_.AddOffset(Step::VT_ROTARY_NAME, rotary_name);
+  }
+  void add_rotary_pronunciation(flatbuffers::Offset<flatbuffers::String> rotary_pronunciation) {
+    fbb_.AddOffset(Step::VT_ROTARY_PRONUNCIATION, rotary_pronunciation);
+  }
+  void add_driving_side(bool driving_side) {
+    fbb_.AddElement<uint8_t>(Step::VT_DRIVING_SIDE, static_cast<uint8_t>(driving_side), 0);
+  }
+  explicit StepBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  StepBuilder &operator=(const StepBuilder &);
+  flatbuffers::Offset<Step> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<Step>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Step> CreateStep(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    double distance = 0.0,
+    double duration = 0.0,
+    osrm::engine::api::fbresult::Geometry geometry_type = osrm::engine::api::fbresult::Geometry_NONE,
+    flatbuffers::Offset<void> geometry = 0,
+    flatbuffers::Offset<flatbuffers::String> name = 0,
+    uint32_t ref = 0,
+    flatbuffers::Offset<flatbuffers::String> pronunciation = 0,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> destinations = 0,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> exits = 0,
+    flatbuffers::Offset<flatbuffers::String> mode = 0,
+    flatbuffers::Offset<osrm::engine::api::fbresult::StepManeuver> maneuver = 0,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Intersection>>> intersections = 0,
+    flatbuffers::Offset<flatbuffers::String> rotary_name = 0,
+    flatbuffers::Offset<flatbuffers::String> rotary_pronunciation = 0,
+    bool driving_side = false) {
+  StepBuilder builder_(_fbb);
+  builder_.add_duration(duration);
+  builder_.add_distance(distance);
+  builder_.add_rotary_pronunciation(rotary_pronunciation);
+  builder_.add_rotary_name(rotary_name);
+  builder_.add_intersections(intersections);
+  builder_.add_maneuver(maneuver);
+  builder_.add_mode(mode);
+  builder_.add_exits(exits);
+  builder_.add_destinations(destinations);
+  builder_.add_pronunciation(pronunciation);
+  builder_.add_ref(ref);
+  builder_.add_name(name);
+  builder_.add_geometry(geometry);
+  builder_.add_driving_side(driving_side);
+  builder_.add_geometry_type(geometry_type);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<Step> CreateStepDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    double distance = 0.0,
+    double duration = 0.0,
+    osrm::engine::api::fbresult::Geometry geometry_type = osrm::engine::api::fbresult::Geometry_NONE,
+    flatbuffers::Offset<void> geometry = 0,
+    const char *name = nullptr,
+    uint32_t ref = 0,
+    const char *pronunciation = nullptr,
+    const std::vector<flatbuffers::Offset<flatbuffers::String>> *destinations = nullptr,
+    const std::vector<flatbuffers::Offset<flatbuffers::String>> *exits = nullptr,
+    const char *mode = nullptr,
+    flatbuffers::Offset<osrm::engine::api::fbresult::StepManeuver> maneuver = 0,
+    const std::vector<flatbuffers::Offset<osrm::engine::api::fbresult::Intersection>> *intersections = nullptr,
+    const char *rotary_name = nullptr,
+    const char *rotary_pronunciation = nullptr,
+    bool driving_side = false) {
+  auto name__ = name ? _fbb.CreateString(name) : 0;
+  auto pronunciation__ = pronunciation ? _fbb.CreateString(pronunciation) : 0;
+  auto destinations__ = destinations ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*destinations) : 0;
+  auto exits__ = exits ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*exits) : 0;
+  auto mode__ = mode ? _fbb.CreateString(mode) : 0;
+  auto intersections__ = intersections ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Intersection>>(*intersections) : 0;
+  auto rotary_name__ = rotary_name ? _fbb.CreateString(rotary_name) : 0;
+  auto rotary_pronunciation__ = rotary_pronunciation ? _fbb.CreateString(rotary_pronunciation) : 0;
+  return osrm::engine::api::fbresult::CreateStep(
+      _fbb,
+      distance,
+      duration,
+      geometry_type,
+      geometry,
+      name__,
+      ref,
+      pronunciation__,
+      destinations__,
+      exits__,
+      mode__,
+      maneuver,
+      intersections__,
+      rotary_name__,
+      rotary_pronunciation__,
+      driving_side);
+}
+
+flatbuffers::Offset<Step> CreateStep(flatbuffers::FlatBufferBuilder &_fbb, const StepT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct LegT : public flatbuffers::NativeTable {
+  typedef Leg TableType;
+  double distance;
+  double duration;
+  double weight;
+  std::string summary;
+  std::unique_ptr<osrm::engine::api::fbresult::AnnotationT> annotations;
+  std::vector<std::unique_ptr<osrm::engine::api::fbresult::StepT>> steps;
+  LegT()
+      : distance(0.0),
+        duration(0.0),
+        weight(0.0) {
+  }
+};
+
+struct Leg FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef LegT NativeTableType;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_DISTANCE = 4,
+    VT_DURATION = 6,
+    VT_WEIGHT = 8,
+    VT_SUMMARY = 10,
+    VT_ANNOTATIONS = 12,
+    VT_STEPS = 14
+  };
+  double distance() const {
+    return GetField<double>(VT_DISTANCE, 0.0);
+  }
+  double duration() const {
+    return GetField<double>(VT_DURATION, 0.0);
+  }
+  double weight() const {
+    return GetField<double>(VT_WEIGHT, 0.0);
+  }
+  const flatbuffers::String *summary() const {
+    return GetPointer<const flatbuffers::String *>(VT_SUMMARY);
+  }
+  const osrm::engine::api::fbresult::Annotation *annotations() const {
+    return GetPointer<const osrm::engine::api::fbresult::Annotation *>(VT_ANNOTATIONS);
+  }
+  const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Step>> *steps() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Step>> *>(VT_STEPS);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<double>(verifier, VT_DISTANCE) &&
+           VerifyField<double>(verifier, VT_DURATION) &&
+           VerifyField<double>(verifier, VT_WEIGHT) &&
+           VerifyOffset(verifier, VT_SUMMARY) &&
+           verifier.VerifyString(summary()) &&
+           VerifyOffset(verifier, VT_ANNOTATIONS) &&
+           verifier.VerifyTable(annotations()) &&
+           VerifyOffset(verifier, VT_STEPS) &&
+           verifier.VerifyVector(steps()) &&
+           verifier.VerifyVectorOfTables(steps()) &&
+           verifier.EndTable();
+  }
+  LegT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(LegT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<Leg> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LegT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct LegBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_distance(double distance) {
+    fbb_.AddElement<double>(Leg::VT_DISTANCE, distance, 0.0);
+  }
+  void add_duration(double duration) {
+    fbb_.AddElement<double>(Leg::VT_DURATION, duration, 0.0);
+  }
+  void add_weight(double weight) {
+    fbb_.AddElement<double>(Leg::VT_WEIGHT, weight, 0.0);
+  }
+  void add_summary(flatbuffers::Offset<flatbuffers::String> summary) {
+    fbb_.AddOffset(Leg::VT_SUMMARY, summary);
+  }
+  void add_annotations(flatbuffers::Offset<osrm::engine::api::fbresult::Annotation> annotations) {
+    fbb_.AddOffset(Leg::VT_ANNOTATIONS, annotations);
+  }
+  void add_steps(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Step>>> steps) {
+    fbb_.AddOffset(Leg::VT_STEPS, steps);
+  }
+  explicit LegBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  LegBuilder &operator=(const LegBuilder &);
+  flatbuffers::Offset<Leg> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<Leg>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Leg> CreateLeg(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    double distance = 0.0,
+    double duration = 0.0,
+    double weight = 0.0,
+    flatbuffers::Offset<flatbuffers::String> summary = 0,
+    flatbuffers::Offset<osrm::engine::api::fbresult::Annotation> annotations = 0,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Step>>> steps = 0) {
+  LegBuilder builder_(_fbb);
+  builder_.add_weight(weight);
+  builder_.add_duration(duration);
+  builder_.add_distance(distance);
+  builder_.add_steps(steps);
+  builder_.add_annotations(annotations);
+  builder_.add_summary(summary);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<Leg> CreateLegDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    double distance = 0.0,
+    double duration = 0.0,
+    double weight = 0.0,
+    const char *summary = nullptr,
+    flatbuffers::Offset<osrm::engine::api::fbresult::Annotation> annotations = 0,
+    const std::vector<flatbuffers::Offset<osrm::engine::api::fbresult::Step>> *steps = nullptr) {
+  auto summary__ = summary ? _fbb.CreateString(summary) : 0;
+  auto steps__ = steps ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Step>>(*steps) : 0;
+  return osrm::engine::api::fbresult::CreateLeg(
+      _fbb,
+      distance,
+      duration,
+      weight,
+      summary__,
+      annotations,
+      steps__);
+}
+
+flatbuffers::Offset<Leg> CreateLeg(flatbuffers::FlatBufferBuilder &_fbb, const LegT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct RouteObjectT : public flatbuffers::NativeTable {
+  typedef RouteObject TableType;
+  double distance;
+  double duration;
+  double weight;
+  std::string weight_name;
+  double confidence;
+  GeometryUnion geometry;
+  std::vector<std::unique_ptr<osrm::engine::api::fbresult::LegT>> legs;
+  RouteObjectT()
+      : distance(0.0),
+        duration(0.0),
+        weight(0.0),
+        confidence(0.0) {
+  }
+};
+
+struct RouteObject FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef RouteObjectT NativeTableType;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_DISTANCE = 4,
+    VT_DURATION = 6,
+    VT_WEIGHT = 8,
+    VT_WEIGHT_NAME = 10,
+    VT_CONFIDENCE = 12,
+    VT_GEOMETRY_TYPE = 14,
+    VT_GEOMETRY = 16,
+    VT_LEGS = 18
+  };
+  double distance() const {
+    return GetField<double>(VT_DISTANCE, 0.0);
+  }
+  double duration() const {
+    return GetField<double>(VT_DURATION, 0.0);
+  }
+  double weight() const {
+    return GetField<double>(VT_WEIGHT, 0.0);
+  }
+  const flatbuffers::String *weight_name() const {
+    return GetPointer<const flatbuffers::String *>(VT_WEIGHT_NAME);
+  }
+  double confidence() const {
+    return GetField<double>(VT_CONFIDENCE, 0.0);
+  }
+  osrm::engine::api::fbresult::Geometry geometry_type() const {
+    return static_cast<osrm::engine::api::fbresult::Geometry>(GetField<uint8_t>(VT_GEOMETRY_TYPE, 0));
+  }
+  const void *geometry() const {
+    return GetPointer<const void *>(VT_GEOMETRY);
+  }
+  const flatbuffers::String *geometry_as_polyline() const {
+    return geometry_type() == osrm::engine::api::fbresult::Geometry_polyline ? static_cast<const flatbuffers::String *>(geometry()) : nullptr;
+  }
+  const flatbuffers::String *geometry_as_polyline6() const {
+    return geometry_type() == osrm::engine::api::fbresult::Geometry_polyline6 ? static_cast<const flatbuffers::String *>(geometry()) : nullptr;
+  }
+  const osrm::engine::api::fbresult::Polyline *geometry_as_coordinates() const {
+    return geometry_type() == osrm::engine::api::fbresult::Geometry_coordinates ? static_cast<const osrm::engine::api::fbresult::Polyline *>(geometry()) : nullptr;
+  }
+  const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Leg>> *legs() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Leg>> *>(VT_LEGS);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<double>(verifier, VT_DISTANCE) &&
+           VerifyField<double>(verifier, VT_DURATION) &&
+           VerifyField<double>(verifier, VT_WEIGHT) &&
+           VerifyOffset(verifier, VT_WEIGHT_NAME) &&
+           verifier.VerifyString(weight_name()) &&
+           VerifyField<double>(verifier, VT_CONFIDENCE) &&
+           VerifyField<uint8_t>(verifier, VT_GEOMETRY_TYPE) &&
+           VerifyOffset(verifier, VT_GEOMETRY) &&
+           VerifyGeometry(verifier, geometry(), geometry_type()) &&
+           VerifyOffset(verifier, VT_LEGS) &&
+           verifier.VerifyVector(legs()) &&
+           verifier.VerifyVectorOfTables(legs()) &&
+           verifier.EndTable();
+  }
+  RouteObjectT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(RouteObjectT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<RouteObject> Pack(flatbuffers::FlatBufferBuilder &_fbb, const RouteObjectT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct RouteObjectBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_distance(double distance) {
+    fbb_.AddElement<double>(RouteObject::VT_DISTANCE, distance, 0.0);
+  }
+  void add_duration(double duration) {
+    fbb_.AddElement<double>(RouteObject::VT_DURATION, duration, 0.0);
+  }
+  void add_weight(double weight) {
+    fbb_.AddElement<double>(RouteObject::VT_WEIGHT, weight, 0.0);
+  }
+  void add_weight_name(flatbuffers::Offset<flatbuffers::String> weight_name) {
+    fbb_.AddOffset(RouteObject::VT_WEIGHT_NAME, weight_name);
+  }
+  void add_confidence(double confidence) {
+    fbb_.AddElement<double>(RouteObject::VT_CONFIDENCE, confidence, 0.0);
+  }
+  void add_geometry_type(osrm::engine::api::fbresult::Geometry geometry_type) {
+    fbb_.AddElement<uint8_t>(RouteObject::VT_GEOMETRY_TYPE, static_cast<uint8_t>(geometry_type), 0);
+  }
+  void add_geometry(flatbuffers::Offset<void> geometry) {
+    fbb_.AddOffset(RouteObject::VT_GEOMETRY, geometry);
+  }
+  void add_legs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Leg>>> legs) {
+    fbb_.AddOffset(RouteObject::VT_LEGS, legs);
+  }
+  explicit RouteObjectBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  RouteObjectBuilder &operator=(const RouteObjectBuilder &);
+  flatbuffers::Offset<RouteObject> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<RouteObject>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<RouteObject> CreateRouteObject(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    double distance = 0.0,
+    double duration = 0.0,
+    double weight = 0.0,
+    flatbuffers::Offset<flatbuffers::String> weight_name = 0,
+    double confidence = 0.0,
+    osrm::engine::api::fbresult::Geometry geometry_type = osrm::engine::api::fbresult::Geometry_NONE,
+    flatbuffers::Offset<void> geometry = 0,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Leg>>> legs = 0) {
+  RouteObjectBuilder builder_(_fbb);
+  builder_.add_confidence(confidence);
+  builder_.add_weight(weight);
+  builder_.add_duration(duration);
+  builder_.add_distance(distance);
+  builder_.add_legs(legs);
+  builder_.add_geometry(geometry);
+  builder_.add_weight_name(weight_name);
+  builder_.add_geometry_type(geometry_type);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<RouteObject> CreateRouteObjectDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    double distance = 0.0,
+    double duration = 0.0,
+    double weight = 0.0,
+    const char *weight_name = nullptr,
+    double confidence = 0.0,
+    osrm::engine::api::fbresult::Geometry geometry_type = osrm::engine::api::fbresult::Geometry_NONE,
+    flatbuffers::Offset<void> geometry = 0,
+    const std::vector<flatbuffers::Offset<osrm::engine::api::fbresult::Leg>> *legs = nullptr) {
+  auto weight_name__ = weight_name ? _fbb.CreateString(weight_name) : 0;
+  auto legs__ = legs ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Leg>>(*legs) : 0;
+  return osrm::engine::api::fbresult::CreateRouteObject(
+      _fbb,
+      distance,
+      duration,
+      weight,
+      weight_name__,
+      confidence,
+      geometry_type,
+      geometry,
+      legs__);
+}
+
+flatbuffers::Offset<RouteObject> CreateRouteObject(flatbuffers::FlatBufferBuilder &_fbb, const RouteObjectT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct RouteT : public flatbuffers::NativeTable {
+  typedef Route TableType;
+  std::vector<std::unique_ptr<osrm::engine::api::fbresult::RouteObjectT>> routes;
+  std::vector<std::unique_ptr<osrm::engine::api::fbresult::WaypointT>> waypoints;
+  RouteT() {
+  }
+};
+
+struct Route FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef RouteT NativeTableType;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_ROUTES = 4,
+    VT_WAYPOINTS = 6
+  };
+  const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::RouteObject>> *routes() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::RouteObject>> *>(VT_ROUTES);
+  }
+  const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *waypoints() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *>(VT_WAYPOINTS);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_ROUTES) &&
+           verifier.VerifyVector(routes()) &&
+           verifier.VerifyVectorOfTables(routes()) &&
+           VerifyOffset(verifier, VT_WAYPOINTS) &&
+           verifier.VerifyVector(waypoints()) &&
+           verifier.VerifyVectorOfTables(waypoints()) &&
+           verifier.EndTable();
+  }
+  RouteT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(RouteT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<Route> Pack(flatbuffers::FlatBufferBuilder &_fbb, const RouteT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct RouteBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_routes(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::RouteObject>>> routes) {
+    fbb_.AddOffset(Route::VT_ROUTES, routes);
+  }
+  void add_waypoints(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>> waypoints) {
+    fbb_.AddOffset(Route::VT_WAYPOINTS, waypoints);
+  }
+  explicit RouteBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  RouteBuilder &operator=(const RouteBuilder &);
+  flatbuffers::Offset<Route> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<Route>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Route> CreateRoute(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::RouteObject>>> routes = 0,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>> waypoints = 0) {
+  RouteBuilder builder_(_fbb);
+  builder_.add_waypoints(waypoints);
+  builder_.add_routes(routes);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<Route> CreateRouteDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const std::vector<flatbuffers::Offset<osrm::engine::api::fbresult::RouteObject>> *routes = nullptr,
+    const std::vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *waypoints = nullptr) {
+  auto routes__ = routes ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::RouteObject>>(*routes) : 0;
+  auto waypoints__ = waypoints ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>(*waypoints) : 0;
+  return osrm::engine::api::fbresult::CreateRoute(
+      _fbb,
+      routes__,
+      waypoints__);
+}
+
+flatbuffers::Offset<Route> CreateRoute(flatbuffers::FlatBufferBuilder &_fbb, const RouteT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct MatchT : public flatbuffers::NativeTable {
+  typedef Match TableType;
+  std::vector<std::unique_ptr<osrm::engine::api::fbresult::WaypointT>> tracepoints;
+  std::vector<std::unique_ptr<osrm::engine::api::fbresult::RouteT>> matchings;
+  MatchT() {
+  }
+};
+
+struct Match FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef MatchT NativeTableType;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_TRACEPOINTS = 4,
+    VT_MATCHINGS = 6
+  };
+  const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *tracepoints() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *>(VT_TRACEPOINTS);
+  }
+  const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Route>> *matchings() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Route>> *>(VT_MATCHINGS);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_TRACEPOINTS) &&
+           verifier.VerifyVector(tracepoints()) &&
+           verifier.VerifyVectorOfTables(tracepoints()) &&
+           VerifyOffset(verifier, VT_MATCHINGS) &&
+           verifier.VerifyVector(matchings()) &&
+           verifier.VerifyVectorOfTables(matchings()) &&
+           verifier.EndTable();
+  }
+  MatchT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(MatchT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<Match> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MatchT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct MatchBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_tracepoints(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>> tracepoints) {
+    fbb_.AddOffset(Match::VT_TRACEPOINTS, tracepoints);
+  }
+  void add_matchings(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Route>>> matchings) {
+    fbb_.AddOffset(Match::VT_MATCHINGS, matchings);
+  }
+  explicit MatchBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  MatchBuilder &operator=(const MatchBuilder &);
+  flatbuffers::Offset<Match> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<Match>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Match> CreateMatch(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>> tracepoints = 0,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Route>>> matchings = 0) {
+  MatchBuilder builder_(_fbb);
+  builder_.add_matchings(matchings);
+  builder_.add_tracepoints(tracepoints);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<Match> CreateMatchDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const std::vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *tracepoints = nullptr,
+    const std::vector<flatbuffers::Offset<osrm::engine::api::fbresult::Route>> *matchings = nullptr) {
+  auto tracepoints__ = tracepoints ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>(*tracepoints) : 0;
+  auto matchings__ = matchings ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Route>>(*matchings) : 0;
+  return osrm::engine::api::fbresult::CreateMatch(
+      _fbb,
+      tracepoints__,
+      matchings__);
+}
+
+flatbuffers::Offset<Match> CreateMatch(flatbuffers::FlatBufferBuilder &_fbb, const MatchT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct NearestT : public flatbuffers::NativeTable {
+  typedef Nearest TableType;
+  std::vector<std::unique_ptr<osrm::engine::api::fbresult::WaypointT>> waypoints;
+  NearestT() {
+  }
+};
+
+struct Nearest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef NearestT NativeTableType;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_WAYPOINTS = 4
+  };
+  const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *waypoints() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *>(VT_WAYPOINTS);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_WAYPOINTS) &&
+           verifier.VerifyVector(waypoints()) &&
+           verifier.VerifyVectorOfTables(waypoints()) &&
+           verifier.EndTable();
+  }
+  NearestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(NearestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<Nearest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NearestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct NearestBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_waypoints(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>> waypoints) {
+    fbb_.AddOffset(Nearest::VT_WAYPOINTS, waypoints);
+  }
+  explicit NearestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  NearestBuilder &operator=(const NearestBuilder &);
+  flatbuffers::Offset<Nearest> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<Nearest>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Nearest> CreateNearest(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>> waypoints = 0) {
+  NearestBuilder builder_(_fbb);
+  builder_.add_waypoints(waypoints);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<Nearest> CreateNearestDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const std::vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *waypoints = nullptr) {
+  auto waypoints__ = waypoints ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>(*waypoints) : 0;
+  return osrm::engine::api::fbresult::CreateNearest(
+      _fbb,
+      waypoints__);
+}
+
+flatbuffers::Offset<Nearest> CreateNearest(flatbuffers::FlatBufferBuilder &_fbb, const NearestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct VectorUintT : public flatbuffers::NativeTable {
+  typedef VectorUint TableType;
+  std::vector<uint32_t> column;
+  VectorUintT() {
+  }
+};
+
+struct VectorUint FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef VectorUintT NativeTableType;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_COLUMN = 4
+  };
+  const flatbuffers::Vector<uint32_t> *column() const {
+    return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_COLUMN);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_COLUMN) &&
+           verifier.VerifyVector(column()) &&
+           verifier.EndTable();
+  }
+  VectorUintT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(VectorUintT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<VectorUint> Pack(flatbuffers::FlatBufferBuilder &_fbb, const VectorUintT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct VectorUintBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_column(flatbuffers::Offset<flatbuffers::Vector<uint32_t>> column) {
+    fbb_.AddOffset(VectorUint::VT_COLUMN, column);
+  }
+  explicit VectorUintBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  VectorUintBuilder &operator=(const VectorUintBuilder &);
+  flatbuffers::Offset<VectorUint> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<VectorUint>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<VectorUint> CreateVectorUint(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::Vector<uint32_t>> column = 0) {
+  VectorUintBuilder builder_(_fbb);
+  builder_.add_column(column);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<VectorUint> CreateVectorUintDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const std::vector<uint32_t> *column = nullptr) {
+  auto column__ = column ? _fbb.CreateVector<uint32_t>(*column) : 0;
+  return osrm::engine::api::fbresult::CreateVectorUint(
+      _fbb,
+      column__);
+}
+
+flatbuffers::Offset<VectorUint> CreateVectorUint(flatbuffers::FlatBufferBuilder &_fbb, const VectorUintT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct TableT : public flatbuffers::NativeTable {
+  typedef Table TableType;
+  std::vector<std::unique_ptr<osrm::engine::api::fbresult::WaypointT>> waypoints;
+  std::vector<std::unique_ptr<osrm::engine::api::fbresult::VectorUintT>> durations;
+  std::vector<std::unique_ptr<osrm::engine::api::fbresult::VectorUintT>> distances;
+  std::vector<std::unique_ptr<osrm::engine::api::fbresult::WaypointT>> sources;
+  std::vector<std::unique_ptr<osrm::engine::api::fbresult::WaypointT>> destinations;
+  std::vector<std::unique_ptr<osrm::engine::api::fbresult::VectorUintT>> fallback_speed_cells;
+  TableT() {
+  }
+};
+
+struct Table FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef TableT NativeTableType;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_WAYPOINTS = 4,
+    VT_DURATIONS = 6,
+    VT_DISTANCES = 8,
+    VT_SOURCES = 10,
+    VT_DESTINATIONS = 12,
+    VT_FALLBACK_SPEED_CELLS = 14
+  };
+  const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *waypoints() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *>(VT_WAYPOINTS);
+  }
+  const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::VectorUint>> *durations() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::VectorUint>> *>(VT_DURATIONS);
+  }
+  const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::VectorUint>> *distances() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::VectorUint>> *>(VT_DISTANCES);
+  }
+  const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *sources() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *>(VT_SOURCES);
+  }
+  const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *destinations() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *>(VT_DESTINATIONS);
+  }
+  const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::VectorUint>> *fallback_speed_cells() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::VectorUint>> *>(VT_FALLBACK_SPEED_CELLS);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_WAYPOINTS) &&
+           verifier.VerifyVector(waypoints()) &&
+           verifier.VerifyVectorOfTables(waypoints()) &&
+           VerifyOffset(verifier, VT_DURATIONS) &&
+           verifier.VerifyVector(durations()) &&
+           verifier.VerifyVectorOfTables(durations()) &&
+           VerifyOffset(verifier, VT_DISTANCES) &&
+           verifier.VerifyVector(distances()) &&
+           verifier.VerifyVectorOfTables(distances()) &&
+           VerifyOffset(verifier, VT_SOURCES) &&
+           verifier.VerifyVector(sources()) &&
+           verifier.VerifyVectorOfTables(sources()) &&
+           VerifyOffset(verifier, VT_DESTINATIONS) &&
+           verifier.VerifyVector(destinations()) &&
+           verifier.VerifyVectorOfTables(destinations()) &&
+           VerifyOffset(verifier, VT_FALLBACK_SPEED_CELLS) &&
+           verifier.VerifyVector(fallback_speed_cells()) &&
+           verifier.VerifyVectorOfTables(fallback_speed_cells()) &&
+           verifier.EndTable();
+  }
+  TableT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(TableT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<Table> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TableT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct TableBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_waypoints(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>> waypoints) {
+    fbb_.AddOffset(Table::VT_WAYPOINTS, waypoints);
+  }
+  void add_durations(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::VectorUint>>> durations) {
+    fbb_.AddOffset(Table::VT_DURATIONS, durations);
+  }
+  void add_distances(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::VectorUint>>> distances) {
+    fbb_.AddOffset(Table::VT_DISTANCES, distances);
+  }
+  void add_sources(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>> sources) {
+    fbb_.AddOffset(Table::VT_SOURCES, sources);
+  }
+  void add_destinations(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>> destinations) {
+    fbb_.AddOffset(Table::VT_DESTINATIONS, destinations);
+  }
+  void add_fallback_speed_cells(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::VectorUint>>> fallback_speed_cells) {
+    fbb_.AddOffset(Table::VT_FALLBACK_SPEED_CELLS, fallback_speed_cells);
+  }
+  explicit TableBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  TableBuilder &operator=(const TableBuilder &);
+  flatbuffers::Offset<Table> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<Table>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Table> CreateTable(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>> waypoints = 0,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::VectorUint>>> durations = 0,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::VectorUint>>> distances = 0,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>> sources = 0,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>> destinations = 0,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::VectorUint>>> fallback_speed_cells = 0) {
+  TableBuilder builder_(_fbb);
+  builder_.add_fallback_speed_cells(fallback_speed_cells);
+  builder_.add_destinations(destinations);
+  builder_.add_sources(sources);
+  builder_.add_distances(distances);
+  builder_.add_durations(durations);
+  builder_.add_waypoints(waypoints);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<Table> CreateTableDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const std::vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *waypoints = nullptr,
+    const std::vector<flatbuffers::Offset<osrm::engine::api::fbresult::VectorUint>> *durations = nullptr,
+    const std::vector<flatbuffers::Offset<osrm::engine::api::fbresult::VectorUint>> *distances = nullptr,
+    const std::vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *sources = nullptr,
+    const std::vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *destinations = nullptr,
+    const std::vector<flatbuffers::Offset<osrm::engine::api::fbresult::VectorUint>> *fallback_speed_cells = nullptr) {
+  auto waypoints__ = waypoints ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>(*waypoints) : 0;
+  auto durations__ = durations ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::VectorUint>>(*durations) : 0;
+  auto distances__ = distances ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::VectorUint>>(*distances) : 0;
+  auto sources__ = sources ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>(*sources) : 0;
+  auto destinations__ = destinations ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>(*destinations) : 0;
+  auto fallback_speed_cells__ = fallback_speed_cells ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::VectorUint>>(*fallback_speed_cells) : 0;
+  return osrm::engine::api::fbresult::CreateTable(
+      _fbb,
+      waypoints__,
+      durations__,
+      distances__,
+      sources__,
+      destinations__,
+      fallback_speed_cells__);
+}
+
+flatbuffers::Offset<Table> CreateTable(flatbuffers::FlatBufferBuilder &_fbb, const TableT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct TripT : public flatbuffers::NativeTable {
+  typedef Trip TableType;
+  std::vector<std::unique_ptr<osrm::engine::api::fbresult::WaypointT>> waypoints;
+  std::vector<std::unique_ptr<osrm::engine::api::fbresult::RouteT>> trips;
+  TripT() {
+  }
+};
+
+struct Trip FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef TripT NativeTableType;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_WAYPOINTS = 4,
+    VT_TRIPS = 6
+  };
+  const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *waypoints() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *>(VT_WAYPOINTS);
+  }
+  const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Route>> *trips() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Route>> *>(VT_TRIPS);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_WAYPOINTS) &&
+           verifier.VerifyVector(waypoints()) &&
+           verifier.VerifyVectorOfTables(waypoints()) &&
+           VerifyOffset(verifier, VT_TRIPS) &&
+           verifier.VerifyVector(trips()) &&
+           verifier.VerifyVectorOfTables(trips()) &&
+           verifier.EndTable();
+  }
+  TripT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(TripT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<Trip> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TripT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct TripBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_waypoints(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>> waypoints) {
+    fbb_.AddOffset(Trip::VT_WAYPOINTS, waypoints);
+  }
+  void add_trips(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Route>>> trips) {
+    fbb_.AddOffset(Trip::VT_TRIPS, trips);
+  }
+  explicit TripBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  TripBuilder &operator=(const TripBuilder &);
+  flatbuffers::Offset<Trip> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<Trip>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Trip> CreateTrip(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>> waypoints = 0,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<osrm::engine::api::fbresult::Route>>> trips = 0) {
+  TripBuilder builder_(_fbb);
+  builder_.add_trips(trips);
+  builder_.add_waypoints(waypoints);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<Trip> CreateTripDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const std::vector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> *waypoints = nullptr,
+    const std::vector<flatbuffers::Offset<osrm::engine::api::fbresult::Route>> *trips = nullptr) {
+  auto waypoints__ = waypoints ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>>(*waypoints) : 0;
+  auto trips__ = trips ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Route>>(*trips) : 0;
+  return osrm::engine::api::fbresult::CreateTrip(
+      _fbb,
+      waypoints__,
+      trips__);
+}
+
+flatbuffers::Offset<Trip> CreateTrip(flatbuffers::FlatBufferBuilder &_fbb, const TripT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct FBResultT : public flatbuffers::NativeTable {
+  typedef FBResult TableType;
+  std::string code;
+  std::string message;
+  ServiceResponseUnion response;
+  FBResultT() {
+  }
+};
+
+struct FBResult FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef FBResultT NativeTableType;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_CODE = 4,
+    VT_MESSAGE = 6,
+    VT_RESPONSE_TYPE = 8,
+    VT_RESPONSE = 10
+  };
+  const flatbuffers::String *code() const {
+    return GetPointer<const flatbuffers::String *>(VT_CODE);
+  }
+  const flatbuffers::String *message() const {
+    return GetPointer<const flatbuffers::String *>(VT_MESSAGE);
+  }
+  osrm::engine::api::fbresult::ServiceResponse response_type() const {
+    return static_cast<osrm::engine::api::fbresult::ServiceResponse>(GetField<uint8_t>(VT_RESPONSE_TYPE, 0));
+  }
+  const void *response() const {
+    return GetPointer<const void *>(VT_RESPONSE);
+  }
+  template<typename T> const T *response_as() const;
+  const osrm::engine::api::fbresult::Match *response_as_match() const {
+    return response_type() == osrm::engine::api::fbresult::ServiceResponse_match ? static_cast<const osrm::engine::api::fbresult::Match *>(response()) : nullptr;
+  }
+  const osrm::engine::api::fbresult::Nearest *response_as_nearest() const {
+    return response_type() == osrm::engine::api::fbresult::ServiceResponse_nearest ? static_cast<const osrm::engine::api::fbresult::Nearest *>(response()) : nullptr;
+  }
+  const osrm::engine::api::fbresult::Route *response_as_route() const {
+    return response_type() == osrm::engine::api::fbresult::ServiceResponse_route ? static_cast<const osrm::engine::api::fbresult::Route *>(response()) : nullptr;
+  }
+  const osrm::engine::api::fbresult::Table *response_as_table() const {
+    return response_type() == osrm::engine::api::fbresult::ServiceResponse_table ? static_cast<const osrm::engine::api::fbresult::Table *>(response()) : nullptr;
+  }
+  const osrm::engine::api::fbresult::Trip *response_as_trip() const {
+    return response_type() == osrm::engine::api::fbresult::ServiceResponse_trip ? static_cast<const osrm::engine::api::fbresult::Trip *>(response()) : nullptr;
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_CODE) &&
+           verifier.VerifyString(code()) &&
+           VerifyOffset(verifier, VT_MESSAGE) &&
+           verifier.VerifyString(message()) &&
+           VerifyField<uint8_t>(verifier, VT_RESPONSE_TYPE) &&
+           VerifyOffset(verifier, VT_RESPONSE) &&
+           VerifyServiceResponse(verifier, response(), response_type()) &&
+           verifier.EndTable();
+  }
+  FBResultT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(FBResultT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<FBResult> Pack(flatbuffers::FlatBufferBuilder &_fbb, const FBResultT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+template<> inline const osrm::engine::api::fbresult::Match *FBResult::response_as<osrm::engine::api::fbresult::Match>() const {
+  return response_as_match();
+}
+
+template<> inline const osrm::engine::api::fbresult::Nearest *FBResult::response_as<osrm::engine::api::fbresult::Nearest>() const {
+  return response_as_nearest();
+}
+
+template<> inline const osrm::engine::api::fbresult::Route *FBResult::response_as<osrm::engine::api::fbresult::Route>() const {
+  return response_as_route();
+}
+
+template<> inline const osrm::engine::api::fbresult::Table *FBResult::response_as<osrm::engine::api::fbresult::Table>() const {
+  return response_as_table();
+}
+
+template<> inline const osrm::engine::api::fbresult::Trip *FBResult::response_as<osrm::engine::api::fbresult::Trip>() const {
+  return response_as_trip();
+}
+
+struct FBResultBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_code(flatbuffers::Offset<flatbuffers::String> code) {
+    fbb_.AddOffset(FBResult::VT_CODE, code);
+  }
+  void add_message(flatbuffers::Offset<flatbuffers::String> message) {
+    fbb_.AddOffset(FBResult::VT_MESSAGE, message);
+  }
+  void add_response_type(osrm::engine::api::fbresult::ServiceResponse response_type) {
+    fbb_.AddElement<uint8_t>(FBResult::VT_RESPONSE_TYPE, static_cast<uint8_t>(response_type), 0);
+  }
+  void add_response(flatbuffers::Offset<void> response) {
+    fbb_.AddOffset(FBResult::VT_RESPONSE, response);
+  }
+  explicit FBResultBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  FBResultBuilder &operator=(const FBResultBuilder &);
+  flatbuffers::Offset<FBResult> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<FBResult>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<FBResult> CreateFBResult(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::String> code = 0,
+    flatbuffers::Offset<flatbuffers::String> message = 0,
+    osrm::engine::api::fbresult::ServiceResponse response_type = osrm::engine::api::fbresult::ServiceResponse_NONE,
+    flatbuffers::Offset<void> response = 0) {
+  FBResultBuilder builder_(_fbb);
+  builder_.add_response(response);
+  builder_.add_message(message);
+  builder_.add_code(code);
+  builder_.add_response_type(response_type);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<FBResult> CreateFBResultDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const char *code = nullptr,
+    const char *message = nullptr,
+    osrm::engine::api::fbresult::ServiceResponse response_type = osrm::engine::api::fbresult::ServiceResponse_NONE,
+    flatbuffers::Offset<void> response = 0) {
+  auto code__ = code ? _fbb.CreateString(code) : 0;
+  auto message__ = message ? _fbb.CreateString(message) : 0;
+  return osrm::engine::api::fbresult::CreateFBResult(
+      _fbb,
+      code__,
+      message__,
+      response_type,
+      response);
+}
+
+flatbuffers::Offset<FBResult> CreateFBResult(flatbuffers::FlatBufferBuilder &_fbb, const FBResultT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+inline PositionT *Position::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  auto _o = new PositionT();
+  UnPackTo(_o, _resolver);
+  return _o;
+}
+
+inline void Position::UnPackTo(PositionT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = longitute(); _o->longitute = _e; };
+  { auto _e = latitude(); _o->latitude = _e; };
+}
+
+inline flatbuffers::Offset<Position> Position::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PositionT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreatePosition(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<Position> CreatePosition(flatbuffers::FlatBufferBuilder &_fbb, const PositionT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PositionT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _longitute = _o->longitute;
+  auto _latitude = _o->latitude;
+  return osrm::engine::api::fbresult::CreatePosition(
+      _fbb,
+      _longitute,
+      _latitude);
+}
+
+inline WaypointT *Waypoint::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  auto _o = new WaypointT();
+  UnPackTo(_o, _resolver);
+  return _o;
+}
+
+inline void Waypoint::UnPackTo(WaypointT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = longitute(); _o->longitute = _e; };
+  { auto _e = latitude(); _o->latitude = _e; };
+  { auto _e = name(); if (_e) _o->name = _e->str(); };
+  { auto _e = location(); if (_e) _o->location = std::unique_ptr<osrm::engine::api::fbresult::PositionT>(_e->UnPack(_resolver)); };
+  { auto _e = nodes(); if (_e) { _o->nodes.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->nodes[_i] = _e->Get(_i); } } };
+  { auto _e = matchings_index(); _o->matchings_index = _e; };
+  { auto _e = waypoint_index(); _o->waypoint_index = _e; };
+  { auto _e = alternatives_count(); _o->alternatives_count = _e; };
+  { auto _e = trips_index(); _o->trips_index = _e; };
+}
+
+inline flatbuffers::Offset<Waypoint> Waypoint::Pack(flatbuffers::FlatBufferBuilder &_fbb, const WaypointT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreateWaypoint(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<Waypoint> CreateWaypoint(flatbuffers::FlatBufferBuilder &_fbb, const WaypointT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const WaypointT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _longitute = _o->longitute;
+  auto _latitude = _o->latitude;
+  auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name);
+  auto _location = _o->location ? CreatePosition(_fbb, _o->location.get(), _rehasher) : 0;
+  auto _nodes = _o->nodes.size() ? _fbb.CreateVector(_o->nodes) : 0;
+  auto _matchings_index = _o->matchings_index;
+  auto _waypoint_index = _o->waypoint_index;
+  auto _alternatives_count = _o->alternatives_count;
+  auto _trips_index = _o->trips_index;
+  return osrm::engine::api::fbresult::CreateWaypoint(
+      _fbb,
+      _longitute,
+      _latitude,
+      _name,
+      _location,
+      _nodes,
+      _matchings_index,
+      _waypoint_index,
+      _alternatives_count,
+      _trips_index);
+}
+
+inline MetadataT *Metadata::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  auto _o = new MetadataT();
+  UnPackTo(_o, _resolver);
+  return _o;
+}
+
+inline void Metadata::UnPackTo(MetadataT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = datasource_names(); if (_e) { _o->datasource_names.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->datasource_names[_i] = _e->Get(_i)->str(); } } };
+}
+
+inline flatbuffers::Offset<Metadata> Metadata::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MetadataT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreateMetadata(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<Metadata> CreateMetadata(flatbuffers::FlatBufferBuilder &_fbb, const MetadataT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MetadataT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _datasource_names = _o->datasource_names.size() ? _fbb.CreateVectorOfStrings(_o->datasource_names) : 0;
+  return osrm::engine::api::fbresult::CreateMetadata(
+      _fbb,
+      _datasource_names);
+}
+
+inline AnnotationT *Annotation::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  auto _o = new AnnotationT();
+  UnPackTo(_o, _resolver);
+  return _o;
+}
+
+inline void Annotation::UnPackTo(AnnotationT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = distance(); if (_e) { _o->distance.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->distance[_i] = _e->Get(_i); } } };
+  { auto _e = duration(); if (_e) { _o->duration.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->duration[_i] = _e->Get(_i); } } };
+  { auto _e = datasources(); if (_e) { _o->datasources.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->datasources[_i] = _e->Get(_i); } } };
+  { auto _e = nodes(); if (_e) { _o->nodes.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->nodes[_i] = _e->Get(_i); } } };
+  { auto _e = weight(); if (_e) { _o->weight.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->weight[_i] = _e->Get(_i); } } };
+  { auto _e = speed(); if (_e) { _o->speed.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->speed[_i] = _e->Get(_i); } } };
+  { auto _e = metadata(); if (_e) _o->metadata = std::unique_ptr<osrm::engine::api::fbresult::MetadataT>(_e->UnPack(_resolver)); };
+}
+
+inline flatbuffers::Offset<Annotation> Annotation::Pack(flatbuffers::FlatBufferBuilder &_fbb, const AnnotationT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreateAnnotation(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<Annotation> CreateAnnotation(flatbuffers::FlatBufferBuilder &_fbb, const AnnotationT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const AnnotationT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _distance = _o->distance.size() ? _fbb.CreateVector(_o->distance) : 0;
+  auto _duration = _o->duration.size() ? _fbb.CreateVector(_o->duration) : 0;
+  auto _datasources = _o->datasources.size() ? _fbb.CreateVector(_o->datasources) : 0;
+  auto _nodes = _o->nodes.size() ? _fbb.CreateVector(_o->nodes) : 0;
+  auto _weight = _o->weight.size() ? _fbb.CreateVector(_o->weight) : 0;
+  auto _speed = _o->speed.size() ? _fbb.CreateVector(_o->speed) : 0;
+  auto _metadata = _o->metadata ? CreateMetadata(_fbb, _o->metadata.get(), _rehasher) : 0;
+  return osrm::engine::api::fbresult::CreateAnnotation(
+      _fbb,
+      _distance,
+      _duration,
+      _datasources,
+      _nodes,
+      _weight,
+      _speed,
+      _metadata);
+}
+
+inline StepManeuverT *StepManeuver::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  auto _o = new StepManeuverT();
+  UnPackTo(_o, _resolver);
+  return _o;
+}
+
+inline void StepManeuver::UnPackTo(StepManeuverT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = location(); if (_e) _o->location = std::unique_ptr<osrm::engine::api::fbresult::PositionT>(_e->UnPack(_resolver)); };
+  { auto _e = bearing_before(); _o->bearing_before = _e; };
+  { auto _e = bearing_after(); _o->bearing_after = _e; };
+  { auto _e = type(); _o->type = _e; };
+  { auto _e = modifier(); _o->modifier = _e; };
+  { auto _e = exit(); _o->exit = _e; };
+}
+
+inline flatbuffers::Offset<StepManeuver> StepManeuver::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StepManeuverT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreateStepManeuver(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<StepManeuver> CreateStepManeuver(flatbuffers::FlatBufferBuilder &_fbb, const StepManeuverT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const StepManeuverT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _location = _o->location ? CreatePosition(_fbb, _o->location.get(), _rehasher) : 0;
+  auto _bearing_before = _o->bearing_before;
+  auto _bearing_after = _o->bearing_after;
+  auto _type = _o->type;
+  auto _modifier = _o->modifier;
+  auto _exit = _o->exit;
+  return osrm::engine::api::fbresult::CreateStepManeuver(
+      _fbb,
+      _location,
+      _bearing_before,
+      _bearing_after,
+      _type,
+      _modifier,
+      _exit);
+}
+
+inline LaneT *Lane::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  auto _o = new LaneT();
+  UnPackTo(_o, _resolver);
+  return _o;
+}
+
+inline void Lane::UnPackTo(LaneT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = indications(); if (_e) { _o->indications.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->indications[_i] = static_cast<osrm::engine::api::fbresult::Turn>(_e->Get(_i)); } } };
+  { auto _e = valid(); _o->valid = _e; };
+}
+
+inline flatbuffers::Offset<Lane> Lane::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LaneT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreateLane(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<Lane> CreateLane(flatbuffers::FlatBufferBuilder &_fbb, const LaneT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LaneT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _indications = _o->indications.size() ? _fbb.CreateVectorScalarCast<int8_t>(flatbuffers::data(_o->indications), _o->indications.size()) : 0;
+  auto _valid = _o->valid;
+  return osrm::engine::api::fbresult::CreateLane(
+      _fbb,
+      _indications,
+      _valid);
+}
+
+inline IntersectionT *Intersection::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  auto _o = new IntersectionT();
+  UnPackTo(_o, _resolver);
+  return _o;
+}
+
+inline void Intersection::UnPackTo(IntersectionT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = location(); if (_e) _o->location = std::unique_ptr<osrm::engine::api::fbresult::PositionT>(_e->UnPack(_resolver)); };
+  { auto _e = bearings(); if (_e) { _o->bearings.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->bearings[_i] = _e->Get(_i); } } };
+  { auto _e = classes(); if (_e) { _o->classes.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->classes[_i] = _e->Get(_i)->str(); } } };
+  { auto _e = entry(); if (_e) { _o->entry.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->entry[_i] = _e->Get(_i) != 0; } } };
+  { auto _e = in(); _o->in = _e; };
+  { auto _e = out(); _o->out = _e; };
+  { auto _e = lanes(); if (_e) { _o->lanes.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->lanes[_i] = std::unique_ptr<osrm::engine::api::fbresult::LaneT>(_e->Get(_i)->UnPack(_resolver)); } } };
+}
+
+inline flatbuffers::Offset<Intersection> Intersection::Pack(flatbuffers::FlatBufferBuilder &_fbb, const IntersectionT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreateIntersection(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<Intersection> CreateIntersection(flatbuffers::FlatBufferBuilder &_fbb, const IntersectionT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const IntersectionT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _location = _o->location ? CreatePosition(_fbb, _o->location.get(), _rehasher) : 0;
+  auto _bearings = _o->bearings.size() ? _fbb.CreateVector(_o->bearings) : 0;
+  auto _classes = _o->classes.size() ? _fbb.CreateVectorOfStrings(_o->classes) : 0;
+  auto _entry = _o->entry.size() ? _fbb.CreateVector(_o->entry) : 0;
+  auto _in = _o->in;
+  auto _out = _o->out;
+  auto _lanes = _o->lanes.size() ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Lane>> (_o->lanes.size(), [](size_t i, _VectorArgs *__va) { return CreateLane(*__va->__fbb, __va->__o->lanes[i].get(), __va->__rehasher); }, &_va ) : 0;
+  return osrm::engine::api::fbresult::CreateIntersection(
+      _fbb,
+      _location,
+      _bearings,
+      _classes,
+      _entry,
+      _in,
+      _out,
+      _lanes);
+}
+
+inline PolylineT *Polyline::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  auto _o = new PolylineT();
+  UnPackTo(_o, _resolver);
+  return _o;
+}
+
+inline void Polyline::UnPackTo(PolylineT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = polyline(); if (_e) { _o->polyline.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->polyline[_i] = std::unique_ptr<osrm::engine::api::fbresult::PositionT>(_e->Get(_i)->UnPack(_resolver)); } } };
+}
+
+inline flatbuffers::Offset<Polyline> Polyline::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PolylineT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreatePolyline(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<Polyline> CreatePolyline(flatbuffers::FlatBufferBuilder &_fbb, const PolylineT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PolylineT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _polyline = _o->polyline.size() ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Position>> (_o->polyline.size(), [](size_t i, _VectorArgs *__va) { return CreatePosition(*__va->__fbb, __va->__o->polyline[i].get(), __va->__rehasher); }, &_va ) : 0;
+  return osrm::engine::api::fbresult::CreatePolyline(
+      _fbb,
+      _polyline);
+}
+
+inline StepT *Step::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  auto _o = new StepT();
+  UnPackTo(_o, _resolver);
+  return _o;
+}
+
+inline void Step::UnPackTo(StepT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = distance(); _o->distance = _e; };
+  { auto _e = duration(); _o->duration = _e; };
+  { auto _e = geometry_type(); _o->geometry.type = _e; };
+  { auto _e = geometry(); if (_e) _o->geometry.value = GeometryUnion::UnPack(_e, geometry_type(), _resolver); };
+  { auto _e = name(); if (_e) _o->name = _e->str(); };
+  { auto _e = ref(); _o->ref = _e; };
+  { auto _e = pronunciation(); if (_e) _o->pronunciation = _e->str(); };
+  { auto _e = destinations(); if (_e) { _o->destinations.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->destinations[_i] = _e->Get(_i)->str(); } } };
+  { auto _e = exits(); if (_e) { _o->exits.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->exits[_i] = _e->Get(_i)->str(); } } };
+  { auto _e = mode(); if (_e) _o->mode = _e->str(); };
+  { auto _e = maneuver(); if (_e) _o->maneuver = std::unique_ptr<osrm::engine::api::fbresult::StepManeuverT>(_e->UnPack(_resolver)); };
+  { auto _e = intersections(); if (_e) { _o->intersections.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->intersections[_i] = std::unique_ptr<osrm::engine::api::fbresult::IntersectionT>(_e->Get(_i)->UnPack(_resolver)); } } };
+  { auto _e = rotary_name(); if (_e) _o->rotary_name = _e->str(); };
+  { auto _e = rotary_pronunciation(); if (_e) _o->rotary_pronunciation = _e->str(); };
+  { auto _e = driving_side(); _o->driving_side = _e; };
+}
+
+inline flatbuffers::Offset<Step> Step::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StepT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreateStep(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<Step> CreateStep(flatbuffers::FlatBufferBuilder &_fbb, const StepT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const StepT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _distance = _o->distance;
+  auto _duration = _o->duration;
+  auto _geometry_type = _o->geometry.type;
+  auto _geometry = _o->geometry.Pack(_fbb);
+  auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name);
+  auto _ref = _o->ref;
+  auto _pronunciation = _o->pronunciation.empty() ? 0 : _fbb.CreateString(_o->pronunciation);
+  auto _destinations = _o->destinations.size() ? _fbb.CreateVectorOfStrings(_o->destinations) : 0;
+  auto _exits = _o->exits.size() ? _fbb.CreateVectorOfStrings(_o->exits) : 0;
+  auto _mode = _o->mode.empty() ? 0 : _fbb.CreateString(_o->mode);
+  auto _maneuver = _o->maneuver ? CreateStepManeuver(_fbb, _o->maneuver.get(), _rehasher) : 0;
+  auto _intersections = _o->intersections.size() ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Intersection>> (_o->intersections.size(), [](size_t i, _VectorArgs *__va) { return CreateIntersection(*__va->__fbb, __va->__o->intersections[i].get(), __va->__rehasher); }, &_va ) : 0;
+  auto _rotary_name = _o->rotary_name.empty() ? 0 : _fbb.CreateString(_o->rotary_name);
+  auto _rotary_pronunciation = _o->rotary_pronunciation.empty() ? 0 : _fbb.CreateString(_o->rotary_pronunciation);
+  auto _driving_side = _o->driving_side;
+  return osrm::engine::api::fbresult::CreateStep(
+      _fbb,
+      _distance,
+      _duration,
+      _geometry_type,
+      _geometry,
+      _name,
+      _ref,
+      _pronunciation,
+      _destinations,
+      _exits,
+      _mode,
+      _maneuver,
+      _intersections,
+      _rotary_name,
+      _rotary_pronunciation,
+      _driving_side);
+}
+
+inline LegT *Leg::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  auto _o = new LegT();
+  UnPackTo(_o, _resolver);
+  return _o;
+}
+
+inline void Leg::UnPackTo(LegT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = distance(); _o->distance = _e; };
+  { auto _e = duration(); _o->duration = _e; };
+  { auto _e = weight(); _o->weight = _e; };
+  { auto _e = summary(); if (_e) _o->summary = _e->str(); };
+  { auto _e = annotations(); if (_e) _o->annotations = std::unique_ptr<osrm::engine::api::fbresult::AnnotationT>(_e->UnPack(_resolver)); };
+  { auto _e = steps(); if (_e) { _o->steps.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->steps[_i] = std::unique_ptr<osrm::engine::api::fbresult::StepT>(_e->Get(_i)->UnPack(_resolver)); } } };
+}
+
+inline flatbuffers::Offset<Leg> Leg::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LegT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreateLeg(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<Leg> CreateLeg(flatbuffers::FlatBufferBuilder &_fbb, const LegT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LegT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _distance = _o->distance;
+  auto _duration = _o->duration;
+  auto _weight = _o->weight;
+  auto _summary = _o->summary.empty() ? 0 : _fbb.CreateString(_o->summary);
+  auto _annotations = _o->annotations ? CreateAnnotation(_fbb, _o->annotations.get(), _rehasher) : 0;
+  auto _steps = _o->steps.size() ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Step>> (_o->steps.size(), [](size_t i, _VectorArgs *__va) { return CreateStep(*__va->__fbb, __va->__o->steps[i].get(), __va->__rehasher); }, &_va ) : 0;
+  return osrm::engine::api::fbresult::CreateLeg(
+      _fbb,
+      _distance,
+      _duration,
+      _weight,
+      _summary,
+      _annotations,
+      _steps);
+}
+
+inline RouteObjectT *RouteObject::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  auto _o = new RouteObjectT();
+  UnPackTo(_o, _resolver);
+  return _o;
+}
+
+inline void RouteObject::UnPackTo(RouteObjectT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = distance(); _o->distance = _e; };
+  { auto _e = duration(); _o->duration = _e; };
+  { auto _e = weight(); _o->weight = _e; };
+  { auto _e = weight_name(); if (_e) _o->weight_name = _e->str(); };
+  { auto _e = confidence(); _o->confidence = _e; };
+  { auto _e = geometry_type(); _o->geometry.type = _e; };
+  { auto _e = geometry(); if (_e) _o->geometry.value = GeometryUnion::UnPack(_e, geometry_type(), _resolver); };
+  { auto _e = legs(); if (_e) { _o->legs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->legs[_i] = std::unique_ptr<osrm::engine::api::fbresult::LegT>(_e->Get(_i)->UnPack(_resolver)); } } };
+}
+
+inline flatbuffers::Offset<RouteObject> RouteObject::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RouteObjectT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreateRouteObject(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<RouteObject> CreateRouteObject(flatbuffers::FlatBufferBuilder &_fbb, const RouteObjectT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const RouteObjectT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _distance = _o->distance;
+  auto _duration = _o->duration;
+  auto _weight = _o->weight;
+  auto _weight_name = _o->weight_name.empty() ? 0 : _fbb.CreateString(_o->weight_name);
+  auto _confidence = _o->confidence;
+  auto _geometry_type = _o->geometry.type;
+  auto _geometry = _o->geometry.Pack(_fbb);
+  auto _legs = _o->legs.size() ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Leg>> (_o->legs.size(), [](size_t i, _VectorArgs *__va) { return CreateLeg(*__va->__fbb, __va->__o->legs[i].get(), __va->__rehasher); }, &_va ) : 0;
+  return osrm::engine::api::fbresult::CreateRouteObject(
+      _fbb,
+      _distance,
+      _duration,
+      _weight,
+      _weight_name,
+      _confidence,
+      _geometry_type,
+      _geometry,
+      _legs);
+}
+
+inline RouteT *Route::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  auto _o = new RouteT();
+  UnPackTo(_o, _resolver);
+  return _o;
+}
+
+inline void Route::UnPackTo(RouteT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = routes(); if (_e) { _o->routes.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->routes[_i] = std::unique_ptr<osrm::engine::api::fbresult::RouteObjectT>(_e->Get(_i)->UnPack(_resolver)); } } };
+  { auto _e = waypoints(); if (_e) { _o->waypoints.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->waypoints[_i] = std::unique_ptr<osrm::engine::api::fbresult::WaypointT>(_e->Get(_i)->UnPack(_resolver)); } } };
+}
+
+inline flatbuffers::Offset<Route> Route::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RouteT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreateRoute(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<Route> CreateRoute(flatbuffers::FlatBufferBuilder &_fbb, const RouteT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const RouteT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _routes = _o->routes.size() ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::RouteObject>> (_o->routes.size(), [](size_t i, _VectorArgs *__va) { return CreateRouteObject(*__va->__fbb, __va->__o->routes[i].get(), __va->__rehasher); }, &_va ) : 0;
+  auto _waypoints = _o->waypoints.size() ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> (_o->waypoints.size(), [](size_t i, _VectorArgs *__va) { return CreateWaypoint(*__va->__fbb, __va->__o->waypoints[i].get(), __va->__rehasher); }, &_va ) : 0;
+  return osrm::engine::api::fbresult::CreateRoute(
+      _fbb,
+      _routes,
+      _waypoints);
+}
+
+inline MatchT *Match::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  auto _o = new MatchT();
+  UnPackTo(_o, _resolver);
+  return _o;
+}
+
+inline void Match::UnPackTo(MatchT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = tracepoints(); if (_e) { _o->tracepoints.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->tracepoints[_i] = std::unique_ptr<osrm::engine::api::fbresult::WaypointT>(_e->Get(_i)->UnPack(_resolver)); } } };
+  { auto _e = matchings(); if (_e) { _o->matchings.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->matchings[_i] = std::unique_ptr<osrm::engine::api::fbresult::RouteT>(_e->Get(_i)->UnPack(_resolver)); } } };
+}
+
+inline flatbuffers::Offset<Match> Match::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MatchT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreateMatch(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<Match> CreateMatch(flatbuffers::FlatBufferBuilder &_fbb, const MatchT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MatchT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _tracepoints = _o->tracepoints.size() ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> (_o->tracepoints.size(), [](size_t i, _VectorArgs *__va) { return CreateWaypoint(*__va->__fbb, __va->__o->tracepoints[i].get(), __va->__rehasher); }, &_va ) : 0;
+  auto _matchings = _o->matchings.size() ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Route>> (_o->matchings.size(), [](size_t i, _VectorArgs *__va) { return CreateRoute(*__va->__fbb, __va->__o->matchings[i].get(), __va->__rehasher); }, &_va ) : 0;
+  return osrm::engine::api::fbresult::CreateMatch(
+      _fbb,
+      _tracepoints,
+      _matchings);
+}
+
+inline NearestT *Nearest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  auto _o = new NearestT();
+  UnPackTo(_o, _resolver);
+  return _o;
+}
+
+inline void Nearest::UnPackTo(NearestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = waypoints(); if (_e) { _o->waypoints.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->waypoints[_i] = std::unique_ptr<osrm::engine::api::fbresult::WaypointT>(_e->Get(_i)->UnPack(_resolver)); } } };
+}
+
+inline flatbuffers::Offset<Nearest> Nearest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NearestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreateNearest(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<Nearest> CreateNearest(flatbuffers::FlatBufferBuilder &_fbb, const NearestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const NearestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _waypoints = _o->waypoints.size() ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> (_o->waypoints.size(), [](size_t i, _VectorArgs *__va) { return CreateWaypoint(*__va->__fbb, __va->__o->waypoints[i].get(), __va->__rehasher); }, &_va ) : 0;
+  return osrm::engine::api::fbresult::CreateNearest(
+      _fbb,
+      _waypoints);
+}
+
+inline VectorUintT *VectorUint::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  auto _o = new VectorUintT();
+  UnPackTo(_o, _resolver);
+  return _o;
+}
+
+inline void VectorUint::UnPackTo(VectorUintT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = column(); if (_e) { _o->column.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->column[_i] = _e->Get(_i); } } };
+}
+
+inline flatbuffers::Offset<VectorUint> VectorUint::Pack(flatbuffers::FlatBufferBuilder &_fbb, const VectorUintT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreateVectorUint(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<VectorUint> CreateVectorUint(flatbuffers::FlatBufferBuilder &_fbb, const VectorUintT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const VectorUintT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _column = _o->column.size() ? _fbb.CreateVector(_o->column) : 0;
+  return osrm::engine::api::fbresult::CreateVectorUint(
+      _fbb,
+      _column);
+}
+
+inline TableT *Table::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  auto _o = new TableT();
+  UnPackTo(_o, _resolver);
+  return _o;
+}
+
+inline void Table::UnPackTo(TableT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = waypoints(); if (_e) { _o->waypoints.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->waypoints[_i] = std::unique_ptr<osrm::engine::api::fbresult::WaypointT>(_e->Get(_i)->UnPack(_resolver)); } } };
+  { auto _e = durations(); if (_e) { _o->durations.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->durations[_i] = std::unique_ptr<osrm::engine::api::fbresult::VectorUintT>(_e->Get(_i)->UnPack(_resolver)); } } };
+  { auto _e = distances(); if (_e) { _o->distances.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->distances[_i] = std::unique_ptr<osrm::engine::api::fbresult::VectorUintT>(_e->Get(_i)->UnPack(_resolver)); } } };
+  { auto _e = sources(); if (_e) { _o->sources.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->sources[_i] = std::unique_ptr<osrm::engine::api::fbresult::WaypointT>(_e->Get(_i)->UnPack(_resolver)); } } };
+  { auto _e = destinations(); if (_e) { _o->destinations.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->destinations[_i] = std::unique_ptr<osrm::engine::api::fbresult::WaypointT>(_e->Get(_i)->UnPack(_resolver)); } } };
+  { auto _e = fallback_speed_cells(); if (_e) { _o->fallback_speed_cells.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->fallback_speed_cells[_i] = std::unique_ptr<osrm::engine::api::fbresult::VectorUintT>(_e->Get(_i)->UnPack(_resolver)); } } };
+}
+
+inline flatbuffers::Offset<Table> Table::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TableT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreateTable(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<Table> CreateTable(flatbuffers::FlatBufferBuilder &_fbb, const TableT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TableT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _waypoints = _o->waypoints.size() ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> (_o->waypoints.size(), [](size_t i, _VectorArgs *__va) { return CreateWaypoint(*__va->__fbb, __va->__o->waypoints[i].get(), __va->__rehasher); }, &_va ) : 0;
+  auto _durations = _o->durations.size() ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::VectorUint>> (_o->durations.size(), [](size_t i, _VectorArgs *__va) { return CreateVectorUint(*__va->__fbb, __va->__o->durations[i].get(), __va->__rehasher); }, &_va ) : 0;
+  auto _distances = _o->distances.size() ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::VectorUint>> (_o->distances.size(), [](size_t i, _VectorArgs *__va) { return CreateVectorUint(*__va->__fbb, __va->__o->distances[i].get(), __va->__rehasher); }, &_va ) : 0;
+  auto _sources = _o->sources.size() ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> (_o->sources.size(), [](size_t i, _VectorArgs *__va) { return CreateWaypoint(*__va->__fbb, __va->__o->sources[i].get(), __va->__rehasher); }, &_va ) : 0;
+  auto _destinations = _o->destinations.size() ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> (_o->destinations.size(), [](size_t i, _VectorArgs *__va) { return CreateWaypoint(*__va->__fbb, __va->__o->destinations[i].get(), __va->__rehasher); }, &_va ) : 0;
+  auto _fallback_speed_cells = _o->fallback_speed_cells.size() ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::VectorUint>> (_o->fallback_speed_cells.size(), [](size_t i, _VectorArgs *__va) { return CreateVectorUint(*__va->__fbb, __va->__o->fallback_speed_cells[i].get(), __va->__rehasher); }, &_va ) : 0;
+  return osrm::engine::api::fbresult::CreateTable(
+      _fbb,
+      _waypoints,
+      _durations,
+      _distances,
+      _sources,
+      _destinations,
+      _fallback_speed_cells);
+}
+
+inline TripT *Trip::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  auto _o = new TripT();
+  UnPackTo(_o, _resolver);
+  return _o;
+}
+
+inline void Trip::UnPackTo(TripT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = waypoints(); if (_e) { _o->waypoints.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->waypoints[_i] = std::unique_ptr<osrm::engine::api::fbresult::WaypointT>(_e->Get(_i)->UnPack(_resolver)); } } };
+  { auto _e = trips(); if (_e) { _o->trips.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->trips[_i] = std::unique_ptr<osrm::engine::api::fbresult::RouteT>(_e->Get(_i)->UnPack(_resolver)); } } };
+}
+
+inline flatbuffers::Offset<Trip> Trip::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TripT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreateTrip(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<Trip> CreateTrip(flatbuffers::FlatBufferBuilder &_fbb, const TripT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TripT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _waypoints = _o->waypoints.size() ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Waypoint>> (_o->waypoints.size(), [](size_t i, _VectorArgs *__va) { return CreateWaypoint(*__va->__fbb, __va->__o->waypoints[i].get(), __va->__rehasher); }, &_va ) : 0;
+  auto _trips = _o->trips.size() ? _fbb.CreateVector<flatbuffers::Offset<osrm::engine::api::fbresult::Route>> (_o->trips.size(), [](size_t i, _VectorArgs *__va) { return CreateRoute(*__va->__fbb, __va->__o->trips[i].get(), __va->__rehasher); }, &_va ) : 0;
+  return osrm::engine::api::fbresult::CreateTrip(
+      _fbb,
+      _waypoints,
+      _trips);
+}
+
+inline FBResultT *FBResult::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  auto _o = new FBResultT();
+  UnPackTo(_o, _resolver);
+  return _o;
+}
+
+inline void FBResult::UnPackTo(FBResultT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = code(); if (_e) _o->code = _e->str(); };
+  { auto _e = message(); if (_e) _o->message = _e->str(); };
+  { auto _e = response_type(); _o->response.type = _e; };
+  { auto _e = response(); if (_e) _o->response.value = ServiceResponseUnion::UnPack(_e, response_type(), _resolver); };
+}
+
+inline flatbuffers::Offset<FBResult> FBResult::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FBResultT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreateFBResult(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<FBResult> CreateFBResult(flatbuffers::FlatBufferBuilder &_fbb, const FBResultT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const FBResultT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _code = _o->code.empty() ? 0 : _fbb.CreateString(_o->code);
+  auto _message = _o->message.empty() ? 0 : _fbb.CreateString(_o->message);
+  auto _response_type = _o->response.type;
+  auto _response = _o->response.Pack(_fbb);
+  return osrm::engine::api::fbresult::CreateFBResult(
+      _fbb,
+      _code,
+      _message,
+      _response_type,
+      _response);
+}
+
+inline bool VerifyGeometry(flatbuffers::Verifier &verifier, const void *obj, Geometry type) {
+  switch (type) {
+    case Geometry_NONE: {
+      return true;
+    }
+    case Geometry_polyline: {
+      auto ptr = reinterpret_cast<const flatbuffers::String *>(obj);
+      return verifier.VerifyString(ptr);
+    }
+    case Geometry_polyline6: {
+      auto ptr = reinterpret_cast<const flatbuffers::String *>(obj);
+      return verifier.VerifyString(ptr);
+    }
+    case Geometry_coordinates: {
+      auto ptr = reinterpret_cast<const osrm::engine::api::fbresult::Polyline *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    default: return false;
+  }
+}
+
+inline bool VerifyGeometryVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
+  if (!values || !types) return !values && !types;
+  if (values->size() != types->size()) return false;
+  for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
+    if (!VerifyGeometry(
+        verifier,  values->Get(i), types->GetEnum<Geometry>(i))) {
+      return false;
+    }
+  }
+  return true;
+}
+
+inline void *GeometryUnion::UnPack(const void *obj, Geometry type, const flatbuffers::resolver_function_t *resolver) {
+  switch (type) {
+    case Geometry_polyline: {
+      auto ptr = reinterpret_cast<const flatbuffers::String *>(obj);
+      return new std::string(ptr->c_str(), ptr->size());
+    }
+    case Geometry_polyline6: {
+      auto ptr = reinterpret_cast<const flatbuffers::String *>(obj);
+      return new std::string(ptr->c_str(), ptr->size());
+    }
+    case Geometry_coordinates: {
+      auto ptr = reinterpret_cast<const osrm::engine::api::fbresult::Polyline *>(obj);
+      return ptr->UnPack(resolver);
+    }
+    default: return nullptr;
+  }
+}
+
+inline flatbuffers::Offset<void> GeometryUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const {
+  switch (type) {
+    case Geometry_polyline: {
+      auto ptr = reinterpret_cast<const std::string *>(value);
+      return _fbb.CreateString(*ptr).Union();
+    }
+    case Geometry_polyline6: {
+      auto ptr = reinterpret_cast<const std::string *>(value);
+      return _fbb.CreateString(*ptr).Union();
+    }
+    case Geometry_coordinates: {
+      auto ptr = reinterpret_cast<const osrm::engine::api::fbresult::PolylineT *>(value);
+      return CreatePolyline(_fbb, ptr, _rehasher).Union();
+    }
+    default: return 0;
+  }
+}
+
+inline GeometryUnion::GeometryUnion(const GeometryUnion &u) FLATBUFFERS_NOEXCEPT : type(u.type), value(nullptr) {
+  switch (type) {
+    case Geometry_polyline: {
+      value = new std::string(*reinterpret_cast<std::string *>(u.value));
+      break;
+    }
+    case Geometry_polyline6: {
+      value = new std::string(*reinterpret_cast<std::string *>(u.value));
+      break;
+    }
+    case Geometry_coordinates: {
+      FLATBUFFERS_ASSERT(false);  // osrm::engine::api::fbresult::PolylineT not copyable.
+      break;
+    }
+    default:
+      break;
+  }
+}
+
+inline void GeometryUnion::Reset() {
+  switch (type) {
+    case Geometry_polyline: {
+      auto ptr = reinterpret_cast<std::string *>(value);
+      delete ptr;
+      break;
+    }
+    case Geometry_polyline6: {
+      auto ptr = reinterpret_cast<std::string *>(value);
+      delete ptr;
+      break;
+    }
+    case Geometry_coordinates: {
+      auto ptr = reinterpret_cast<osrm::engine::api::fbresult::PolylineT *>(value);
+      delete ptr;
+      break;
+    }
+    default: break;
+  }
+  value = nullptr;
+  type = Geometry_NONE;
+}
+
+inline bool VerifyServiceResponse(flatbuffers::Verifier &verifier, const void *obj, ServiceResponse type) {
+  switch (type) {
+    case ServiceResponse_NONE: {
+      return true;
+    }
+    case ServiceResponse_match: {
+      auto ptr = reinterpret_cast<const osrm::engine::api::fbresult::Match *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case ServiceResponse_nearest: {
+      auto ptr = reinterpret_cast<const osrm::engine::api::fbresult::Nearest *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case ServiceResponse_route: {
+      auto ptr = reinterpret_cast<const osrm::engine::api::fbresult::Route *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case ServiceResponse_table: {
+      auto ptr = reinterpret_cast<const osrm::engine::api::fbresult::Table *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case ServiceResponse_trip: {
+      auto ptr = reinterpret_cast<const osrm::engine::api::fbresult::Trip *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    default: return false;
+  }
+}
+
+inline bool VerifyServiceResponseVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
+  if (!values || !types) return !values && !types;
+  if (values->size() != types->size()) return false;
+  for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
+    if (!VerifyServiceResponse(
+        verifier,  values->Get(i), types->GetEnum<ServiceResponse>(i))) {
+      return false;
+    }
+  }
+  return true;
+}
+
+inline void *ServiceResponseUnion::UnPack(const void *obj, ServiceResponse type, const flatbuffers::resolver_function_t *resolver) {
+  switch (type) {
+    case ServiceResponse_match: {
+      auto ptr = reinterpret_cast<const osrm::engine::api::fbresult::Match *>(obj);
+      return ptr->UnPack(resolver);
+    }
+    case ServiceResponse_nearest: {
+      auto ptr = reinterpret_cast<const osrm::engine::api::fbresult::Nearest *>(obj);
+      return ptr->UnPack(resolver);
+    }
+    case ServiceResponse_route: {
+      auto ptr = reinterpret_cast<const osrm::engine::api::fbresult::Route *>(obj);
+      return ptr->UnPack(resolver);
+    }
+    case ServiceResponse_table: {
+      auto ptr = reinterpret_cast<const osrm::engine::api::fbresult::Table *>(obj);
+      return ptr->UnPack(resolver);
+    }
+    case ServiceResponse_trip: {
+      auto ptr = reinterpret_cast<const osrm::engine::api::fbresult::Trip *>(obj);
+      return ptr->UnPack(resolver);
+    }
+    default: return nullptr;
+  }
+}
+
+inline flatbuffers::Offset<void> ServiceResponseUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const {
+  switch (type) {
+    case ServiceResponse_match: {
+      auto ptr = reinterpret_cast<const osrm::engine::api::fbresult::MatchT *>(value);
+      return CreateMatch(_fbb, ptr, _rehasher).Union();
+    }
+    case ServiceResponse_nearest: {
+      auto ptr = reinterpret_cast<const osrm::engine::api::fbresult::NearestT *>(value);
+      return CreateNearest(_fbb, ptr, _rehasher).Union();
+    }
+    case ServiceResponse_route: {
+      auto ptr = reinterpret_cast<const osrm::engine::api::fbresult::RouteT *>(value);
+      return CreateRoute(_fbb, ptr, _rehasher).Union();
+    }
+    case ServiceResponse_table: {
+      auto ptr = reinterpret_cast<const osrm::engine::api::fbresult::TableT *>(value);
+      return CreateTable(_fbb, ptr, _rehasher).Union();
+    }
+    case ServiceResponse_trip: {
+      auto ptr = reinterpret_cast<const osrm::engine::api::fbresult::TripT *>(value);
+      return CreateTrip(_fbb, ptr, _rehasher).Union();
+    }
+    default: return 0;
+  }
+}
+
+inline ServiceResponseUnion::ServiceResponseUnion(const ServiceResponseUnion &u) FLATBUFFERS_NOEXCEPT : type(u.type), value(nullptr) {
+  switch (type) {
+    case ServiceResponse_match: {
+      FLATBUFFERS_ASSERT(false);  // osrm::engine::api::fbresult::MatchT not copyable.
+      break;
+    }
+    case ServiceResponse_nearest: {
+      FLATBUFFERS_ASSERT(false);  // osrm::engine::api::fbresult::NearestT not copyable.
+      break;
+    }
+    case ServiceResponse_route: {
+      FLATBUFFERS_ASSERT(false);  // osrm::engine::api::fbresult::RouteT not copyable.
+      break;
+    }
+    case ServiceResponse_table: {
+      FLATBUFFERS_ASSERT(false);  // osrm::engine::api::fbresult::TableT not copyable.
+      break;
+    }
+    case ServiceResponse_trip: {
+      FLATBUFFERS_ASSERT(false);  // osrm::engine::api::fbresult::TripT not copyable.
+      break;
+    }
+    default:
+      break;
+  }
+}
+
+inline void ServiceResponseUnion::Reset() {
+  switch (type) {
+    case ServiceResponse_match: {
+      auto ptr = reinterpret_cast<osrm::engine::api::fbresult::MatchT *>(value);
+      delete ptr;
+      break;
+    }
+    case ServiceResponse_nearest: {
+      auto ptr = reinterpret_cast<osrm::engine::api::fbresult::NearestT *>(value);
+      delete ptr;
+      break;
+    }
+    case ServiceResponse_route: {
+      auto ptr = reinterpret_cast<osrm::engine::api::fbresult::RouteT *>(value);
+      delete ptr;
+      break;
+    }
+    case ServiceResponse_table: {
+      auto ptr = reinterpret_cast<osrm::engine::api::fbresult::TableT *>(value);
+      delete ptr;
+      break;
+    }
+    case ServiceResponse_trip: {
+      auto ptr = reinterpret_cast<osrm::engine::api::fbresult::TripT *>(value);
+      delete ptr;
+      break;
+    }
+    default: break;
+  }
+  value = nullptr;
+  type = ServiceResponse_NONE;
+}
+
+}  // namespace fbresult
+}  // namespace api
+}  // namespace engine
+}  // namespace osrm
+
+#endif  // FLATBUFFERS_GENERATED_FBRESULT_OSRM_ENGINE_API_FBRESULT_H_
diff --git a/include/engine/api/flatbuffers/match.fbs b/include/engine/api/flatbuffers/match.fbs
new file mode 100644
index 00000000000..e4a26fe3717
--- /dev/null
+++ b/include/engine/api/flatbuffers/match.fbs
@@ -0,0 +1,7 @@
+include "route.fbs";
+namespace osrm.engine.api.fbresult;
+
+table Match {
+    tracepoints: [Waypoint];
+    matchings: [Route];
+}
\ No newline at end of file
diff --git a/include/engine/api/flatbuffers/nearest.fbs b/include/engine/api/flatbuffers/nearest.fbs
new file mode 100644
index 00000000000..dc12d5f1b17
--- /dev/null
+++ b/include/engine/api/flatbuffers/nearest.fbs
@@ -0,0 +1,6 @@
+include "waypoint.fbs";
+namespace osrm.engine.api.fbresult;
+
+table Nearest {
+    waypoints: [Waypoint];
+}
\ No newline at end of file
diff --git a/include/engine/api/flatbuffers/position.fbs b/include/engine/api/flatbuffers/position.fbs
new file mode 100644
index 00000000000..4793e863da4
--- /dev/null
+++ b/include/engine/api/flatbuffers/position.fbs
@@ -0,0 +1,6 @@
+namespace osrm.engine.api.fbresult;
+
+table Position {
+    longitute: double;
+    latitude:  double;
+}
\ No newline at end of file
diff --git a/include/engine/api/flatbuffers/route.fbs b/include/engine/api/flatbuffers/route.fbs
new file mode 100644
index 00000000000..105541c8334
--- /dev/null
+++ b/include/engine/api/flatbuffers/route.fbs
@@ -0,0 +1,122 @@
+include "waypoint.fbs";
+namespace osrm.engine.api.fbresult;
+
+table Metadata {
+    datasource_names: [string];
+}
+
+table Annotation {
+    distance: [uint];
+    duration: [uint];
+    datasources: [uint];
+    nodes: [uint];
+    weight: [uint];
+    speed: [double];
+    metadata: Metadata;
+}
+
+enum ManeuverType: byte {
+    Turn,
+    NewName,
+    Depart,
+    Arrive,
+    Merge,
+    OnRamp,
+    OffRamp,
+    Fork,
+    EndOfRoad,
+    Continue,
+    Roundabout,
+    Rotary,
+    RoundaboutTurn,
+    Notification,
+    ExitRoundabout,
+    ExitRotary
+}
+
+enum Turn: byte {
+    None,
+    UTurn,
+    SharpRight,
+    Right,
+    SlightRight,
+    Straight,
+    SlightLeft,
+    Left,
+    SharpLeft
+}
+
+table StepManeuver {
+    location: Position;
+    bearing_before: ushort;
+    bearing_after: ushort;
+    type: ManeuverType;
+    modifier: Turn;
+    exit: ubyte;
+}
+
+table Lane {
+    indications: [Turn];
+    valid: bool;
+}
+
+table Intersection {
+    location: Position;
+    bearings: [ushort];
+    classes: [string];
+    entry: [bool];
+    in: uint;
+    out: uint;
+    lanes: [Lane];
+}
+
+table Polyline {
+    polyline: [Position];
+}
+
+union Geometry {
+    polyline: string,
+    polyline6: string,
+    coordinates: Polyline
+}
+
+table Step {
+    distance: double;
+    duration: double;
+    geometry: Geometry;
+    name: string;
+    ref: uint;
+    pronunciation: string;
+    destinations: [string];
+    exits: [string];
+    mode: string;
+    maneuver: StepManeuver;
+    intersections: [Intersection];
+    rotary_name: string;
+    rotary_pronunciation: string;
+    driving_side: bool; //Where true stands for the right side.
+}
+
+table Leg {
+    distance: double;
+    duration: double;
+    weight: double;
+    summary: string;
+    annotations: Annotation;
+    steps: [Step];
+}
+
+table RouteObject {
+    distance: double;
+    duration: double;
+    weight: double;
+    weight_name: string;
+    confidence: double; //Used only by 'Match' service
+    geometry: Geometry;
+    legs: [Leg];
+}
+
+table Route{
+    routes: [RouteObject];
+    waypoints: [Waypoint];
+}
\ No newline at end of file
diff --git a/include/engine/api/flatbuffers/table.fbs b/include/engine/api/flatbuffers/table.fbs
new file mode 100644
index 00000000000..04972ab9bcc
--- /dev/null
+++ b/include/engine/api/flatbuffers/table.fbs
@@ -0,0 +1,15 @@
+include "waypoint.fbs";
+namespace osrm.engine.api.fbresult;
+
+table VectorUint {
+    column: [uint];
+}
+
+table Table {
+    waypoints: [Waypoint];
+    durations: [VectorUint];
+    distances: [VectorUint];
+    sources: [Waypoint];
+    destinations: [Waypoint];
+    fallback_speed_cells: [VectorUint];
+}
\ No newline at end of file
diff --git a/include/engine/api/flatbuffers/trip.fbs b/include/engine/api/flatbuffers/trip.fbs
new file mode 100644
index 00000000000..b2cd3ba7926
--- /dev/null
+++ b/include/engine/api/flatbuffers/trip.fbs
@@ -0,0 +1,7 @@
+include "route.fbs";
+namespace osrm.engine.api.fbresult;
+
+table Trip {
+    waypoints: [Waypoint];
+    trips: [Route];
+}
\ No newline at end of file
diff --git a/include/engine/api/flatbuffers/waypoint.fbs b/include/engine/api/flatbuffers/waypoint.fbs
new file mode 100644
index 00000000000..74fb93a99f4
--- /dev/null
+++ b/include/engine/api/flatbuffers/waypoint.fbs
@@ -0,0 +1,14 @@
+include "position.fbs";
+namespace osrm.engine.api.fbresult;
+
+table Waypoint {
+    longitute: double;
+    latitude:  double;
+    name: string;
+    location: Position;
+    nodes: [double]; //Used only by 'Nearest' service
+    matchings_index: uint; //Used only by 'Match' service
+    waypoint_index: uint; //Used by 'Match' and 'Trip' services
+    alternatives_count: uint; //Used only by 'Match' service
+    trips_index: uint; //Used only by 'Trip' service
+}
\ No newline at end of file