text:
/**
 * Autogenerated by Thrift
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 *  @generated
 */
#pragma once

#include <folly/io/Cursor.h>
#include <folly/io/IOBuf.h>
#include <thrift/lib/cpp/TApplicationException.h>
#include <thrift/lib/cpp2/GeneratedHeaderHelper.h>
#include <thrift/lib/cpp2/Thrift.h>
#include <thrift/lib/cpp2/protocol/Protocol.h>

// BEGIN declare_enums

// END declare_enums
// BEGIN struct_indirection

// END struct_indirection
// BEGIN forward_declare
namespace cpp2 {
class Struct0;
class Struct1;
class Struct2;
class Struct3;
class Struct4;
class Struct5;
class Struct6;
class Struct7;
class Struct8;
class Struct9;
class Struct10;
class Struct11;
class Struct12;
class Struct13;
class Struct14;
class Struct15;
class Struct16;
class Struct17;
class Struct18;
class Struct19;
} // cpp2
// END forward_declare
// BEGIN typedefs

// END typedefs
// BEGIN hash_and_equal_to
// END hash_and_equal_to
namespace cpp2 {
class Struct0 : private apache::thrift::detail::st::ComparisonOperators<Struct0> {
 public:

  Struct0() :
      field1(0),
      field2(0),
      field3(0),
      field7(0),
      field8(0),
      field9(0) {}
  // FragileConstructor for use in initialization lists only

  Struct0(apache::thrift::FragileConstructor, int64_t field1__arg, int16_t field2__arg, int32_t field3__arg, std::set<double> field4__arg, std::map<std::string, std::map<std::map<int16_t, int16_t>, double>> field5__arg, std::vector<double> field6__arg, int8_t field7__arg, bool field8__arg, bool field9__arg) :
      field1(std::move(field1__arg)),
      field2(std::move(field2__arg)),
      field3(std::move(field3__arg)),
      field4(std::move(field4__arg)),
      field5(std::move(field5__arg)),
      field6(std::move(field6__arg)),
      field7(std::move(field7__arg)),
      field8(std::move(field8__arg)),
      field9(std::move(field9__arg)) {
    __isset.field1 = true;
    __isset.field2 = true;
    __isset.field3 = true;
    __isset.field4 = true;
    __isset.field5 = true;
    __isset.field6 = true;
    __isset.field7 = true;
    __isset.field8 = true;
    __isset.field9 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct0(::apache::thrift::detail::argument_wrapper<1, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct0(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field1 = arg.move();
    __isset.field1 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct0(::apache::thrift::detail::argument_wrapper<2, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct0(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field2 = arg.move();
    __isset.field2 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct0(::apache::thrift::detail::argument_wrapper<3, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct0(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field3 = arg.move();
    __isset.field3 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct0(::apache::thrift::detail::argument_wrapper<4, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct0(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field4 = arg.move();
    __isset.field4 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct0(::apache::thrift::detail::argument_wrapper<5, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct0(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field5 = arg.move();
    __isset.field5 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct0(::apache::thrift::detail::argument_wrapper<6, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct0(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field6 = arg.move();
    __isset.field6 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct0(::apache::thrift::detail::argument_wrapper<7, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct0(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field7 = arg.move();
    __isset.field7 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct0(::apache::thrift::detail::argument_wrapper<8, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct0(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field8 = arg.move();
    __isset.field8 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct0(::apache::thrift::detail::argument_wrapper<9, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct0(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field9 = arg.move();
    __isset.field9 = true;
  }

  Struct0(Struct0&&) = default;

  Struct0(const Struct0&) = default;

  Struct0& operator=(Struct0&&) = default;

  Struct0& operator=(const Struct0&) = default;
  void __clear();

  virtual ~Struct0() {}

  int64_t field1;
  int16_t field2;
  int32_t field3;
  std::set<double> field4;
  std::map<std::string, std::map<std::map<int16_t, int16_t>, double>> field5;
  std::vector<double> field6;
  int8_t field7;
  bool field8;
  bool field9;

  struct __isset {
    void __clear() {
      field1 = false;
      field2 = false;
      field3 = false;
      field4 = false;
      field5 = false;
      field6 = false;
      field7 = false;
      field8 = false;
      field9 = false;
    }

    bool field1 = false;
    bool field2 = false;
    bool field3 = false;
    bool field4 = false;
    bool field5 = false;
    bool field6 = false;
    bool field7 = false;
    bool field8 = false;
    bool field9 = false;
  } __isset;
  bool operator==(const Struct0& rhs) const;

  bool operator < (const Struct0& rhs) const {
    if (!(field1 == rhs.field1)) {
      return field1 < rhs.field1;
    }
    if (!(field2 == rhs.field2)) {
      return field2 < rhs.field2;
    }
    if (!(field3 == rhs.field3)) {
      return field3 < rhs.field3;
    }
    if (!(field4 == rhs.field4)) {
      return field4 < rhs.field4;
    }
    if (!(field5 == rhs.field5)) {
      return field5 < rhs.field5;
    }
    if (!(field6 == rhs.field6)) {
      return field6 < rhs.field6;
    }
    if (!(field7 == rhs.field7)) {
      return field7 < rhs.field7;
    }
    if (!(field8 == rhs.field8)) {
      return field8 < rhs.field8;
    }
    if (!(field9 == rhs.field9)) {
      return field9 < rhs.field9;
    }
    (void)rhs;
    return false;
  }

  int64_t get_field1() const {
    return field1;
  }

  int64_t& set_field1(int64_t field1_) {
    field1 = field1_;
    __isset.field1 = true;
    return field1;
  }

  int16_t get_field2() const {
    return field2;
  }

  int16_t& set_field2(int16_t field2_) {
    field2 = field2_;
    __isset.field2 = true;
    return field2;
  }

  int32_t get_field3() const {
    return field3;
  }

  int32_t& set_field3(int32_t field3_) {
    field3 = field3_;
    __isset.field3 = true;
    return field3;
  }
  const std::set<double>& get_field4() const&;
  std::set<double> get_field4() &&;

  template <typename T_Struct0_field4_struct_setter>
  std::set<double>& set_field4(T_Struct0_field4_struct_setter&& field4_) {
    field4 = std::forward<T_Struct0_field4_struct_setter>(field4_);
    __isset.field4 = true;
    return field4;
  }
  const std::map<std::string, std::map<std::map<int16_t, int16_t>, double>>& get_field5() const&;
  std::map<std::string, std::map<std::map<int16_t, int16_t>, double>> get_field5() &&;

  template <typename T_Struct0_field5_struct_setter>
  std::map<std::string, std::map<std::map<int16_t, int16_t>, double>>& set_field5(T_Struct0_field5_struct_setter&& field5_) {
    field5 = std::forward<T_Struct0_field5_struct_setter>(field5_);
    __isset.field5 = true;
    return field5;
  }
  const std::vector<double>& get_field6() const&;
  std::vector<double> get_field6() &&;

  template <typename T_Struct0_field6_struct_setter>
  std::vector<double>& set_field6(T_Struct0_field6_struct_setter&& field6_) {
    field6 = std::forward<T_Struct0_field6_struct_setter>(field6_);
    __isset.field6 = true;
    return field6;
  }

  int8_t get_field7() const {
    return field7;
  }

  int8_t& set_field7(int8_t field7_) {
    field7 = field7_;
    __isset.field7 = true;
    return field7;
  }

  bool get_field8() const {
    return field8;
  }

  bool& set_field8(bool field8_) {
    field8 = field8_;
    __isset.field8 = true;
    return field8;
  }

  bool get_field9() const {
    return field9;
  }

  bool& set_field9(bool field9_) {
    field9 = field9_;
    __isset.field9 = true;
    return field9;
  }

  template <class Protocol_>
  uint32_t read(Protocol_* iprot);
  template <class Protocol_>
  uint32_t serializedSize(Protocol_ const* prot_) const;
  template <class Protocol_>
  uint32_t serializedSizeZC(Protocol_ const* prot_) const;
  template <class Protocol_>
  uint32_t write(Protocol_* prot_) const;

 private:
  static void translateFieldName(FOLLY_MAYBE_UNUSED folly::StringPiece _fname, FOLLY_MAYBE_UNUSED int16_t& fid, FOLLY_MAYBE_UNUSED apache::thrift::protocol::TType& _ftype);
};

void swap(Struct0& a, Struct0& b);
extern template uint32_t Struct0::read<>(apache::thrift::BinaryProtocolReader*);
extern template uint32_t Struct0::write<>(apache::thrift::BinaryProtocolWriter*) const;
extern template uint32_t Struct0::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const;
extern template uint32_t Struct0::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const;
extern template uint32_t Struct0::read<>(apache::thrift::CompactProtocolReader*);
extern template uint32_t Struct0::write<>(apache::thrift::CompactProtocolWriter*) const;
extern template uint32_t Struct0::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const;
extern template uint32_t Struct0::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const;

} // cpp2
namespace apache { namespace thrift {

template <> inline void Cpp2Ops< ::cpp2::Struct0>::clear( ::cpp2::Struct0* obj) {
  return obj->__clear();
}

template <> inline constexpr apache::thrift::protocol::TType Cpp2Ops< ::cpp2::Struct0>::thriftType() {
  return apache::thrift::protocol::T_STRUCT;
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct0>::write(Protocol* proto,  ::cpp2::Struct0 const* obj) {
  return obj->write(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct0>::read(Protocol* proto,  ::cpp2::Struct0* obj) {
  return obj->read(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct0>::serializedSize(Protocol const* proto,  ::cpp2::Struct0 const* obj) {
  return obj->serializedSize(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct0>::serializedSizeZC(Protocol const* proto,  ::cpp2::Struct0 const* obj) {
  return obj->serializedSizeZC(proto);
}

}} // apache::thrift
namespace cpp2 {
class Struct1 : private apache::thrift::detail::st::ComparisonOperators<Struct1> {
 public:

  Struct1() {}
  // FragileConstructor for use in initialization lists only

  Struct1(apache::thrift::FragileConstructor, std::string field1__arg) :
      field1(std::move(field1__arg)) {
    __isset.field1 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct1(::apache::thrift::detail::argument_wrapper<1, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct1(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field1 = arg.move();
    __isset.field1 = true;
  }

  Struct1(Struct1&&) = default;

  Struct1(const Struct1&) = default;

  Struct1& operator=(Struct1&&) = default;

  Struct1& operator=(const Struct1&) = default;
  void __clear();

  virtual ~Struct1() {}

  std::string field1;

  struct __isset {
    void __clear() {
      field1 = false;
    }

    bool field1 = false;
  } __isset;
  bool operator==(const Struct1& rhs) const;

  bool operator < (const Struct1& rhs) const {
    if (!(field1 == rhs.field1)) {
      return field1 < rhs.field1;
    }
    (void)rhs;
    return false;
  }

  const std::string& get_field1() const& {
    return field1;
  }

  std::string get_field1() && {
    return std::move(field1);
  }

  template <typename T_Struct1_field1_struct_setter>
  std::string& set_field1(T_Struct1_field1_struct_setter&& field1_) {
    field1 = std::forward<T_Struct1_field1_struct_setter>(field1_);
    __isset.field1 = true;
    return field1;
  }

  template <class Protocol_>
  uint32_t read(Protocol_* iprot);
  template <class Protocol_>
  uint32_t serializedSize(Protocol_ const* prot_) const;
  template <class Protocol_>
  uint32_t serializedSizeZC(Protocol_ const* prot_) const;
  template <class Protocol_>
  uint32_t write(Protocol_* prot_) const;

 private:
  static void translateFieldName(FOLLY_MAYBE_UNUSED folly::StringPiece _fname, FOLLY_MAYBE_UNUSED int16_t& fid, FOLLY_MAYBE_UNUSED apache::thrift::protocol::TType& _ftype);
};

void swap(Struct1& a, Struct1& b);
extern template uint32_t Struct1::read<>(apache::thrift::BinaryProtocolReader*);
extern template uint32_t Struct1::write<>(apache::thrift::BinaryProtocolWriter*) const;
extern template uint32_t Struct1::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const;
extern template uint32_t Struct1::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const;
extern template uint32_t Struct1::read<>(apache::thrift::CompactProtocolReader*);
extern template uint32_t Struct1::write<>(apache::thrift::CompactProtocolWriter*) const;
extern template uint32_t Struct1::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const;
extern template uint32_t Struct1::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const;

} // cpp2
namespace apache { namespace thrift {

template <> inline void Cpp2Ops< ::cpp2::Struct1>::clear( ::cpp2::Struct1* obj) {
  return obj->__clear();
}

template <> inline constexpr apache::thrift::protocol::TType Cpp2Ops< ::cpp2::Struct1>::thriftType() {
  return apache::thrift::protocol::T_STRUCT;
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct1>::write(Protocol* proto,  ::cpp2::Struct1 const* obj) {
  return obj->write(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct1>::read(Protocol* proto,  ::cpp2::Struct1* obj) {
  return obj->read(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct1>::serializedSize(Protocol const* proto,  ::cpp2::Struct1 const* obj) {
  return obj->serializedSize(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct1>::serializedSizeZC(Protocol const* proto,  ::cpp2::Struct1 const* obj) {
  return obj->serializedSizeZC(proto);
}

}} // apache::thrift
namespace cpp2 {
class Struct2 : private apache::thrift::detail::st::ComparisonOperators<Struct2> {
 public:

  Struct2() :
      field1(0),
      field2(0),
      field3(0),
      field6(0),
      field8(0),
      field15(0),
      field19(0),
      field21(0) {}
  // FragileConstructor for use in initialization lists only

  Struct2(apache::thrift::FragileConstructor, int32_t field1__arg, int32_t field2__arg, float field3__arg, std::map<std::map<std::set<bool>, int8_t>, std::string> field4__arg, std::string field5__arg, int8_t field6__arg, std::string field7__arg, int8_t field8__arg, std::string field9__arg, std::string field10__arg, std::map<int16_t, double> field11__arg, std::vector<int8_t> field12__arg, std::string field13__arg,  ::cpp2::Struct0 field14__arg, int64_t field15__arg, std::map<std::string, int8_t> field16__arg, std::vector<double> field17__arg, std::set<std::string> field18__arg, double field19__arg, std::map<int8_t, std::string> field20__arg, int32_t field21__arg,  ::cpp2::Struct1 field22__arg,  ::cpp2::Struct0 field23__arg) :
      field1(std::move(field1__arg)),
      field2(std::move(field2__arg)),
      field3(std::move(field3__arg)),
      field4(std::move(field4__arg)),
      field5(std::move(field5__arg)),
      field6(std::move(field6__arg)),
      field7(std::move(field7__arg)),
      field8(std::move(field8__arg)),
      field9(std::move(field9__arg)),
      field10(std::move(field10__arg)),
      field11(std::move(field11__arg)),
      field12(std::move(field12__arg)),
      field13(std::move(field13__arg)),
      field14(std::move(field14__arg)),
      field15(std::move(field15__arg)),
      field16(std::move(field16__arg)),
      field17(std::move(field17__arg)),
      field18(std::move(field18__arg)),
      field19(std::move(field19__arg)),
      field20(std::move(field20__arg)),
      field21(std::move(field21__arg)),
      field22(std::move(field22__arg)),
      field23(std::move(field23__arg)) {
    __isset.field1 = true;
    __isset.field2 = true;
    __isset.field3 = true;
    __isset.field4 = true;
    __isset.field5 = true;
    __isset.field6 = true;
    __isset.field7 = true;
    __isset.field8 = true;
    __isset.field9 = true;
    __isset.field10 = true;
    __isset.field11 = true;
    __isset.field12 = true;
    __isset.field13 = true;
    __isset.field14 = true;
    __isset.field15 = true;
    __isset.field16 = true;
    __isset.field17 = true;
    __isset.field18 = true;
    __isset.field19 = true;
    __isset.field20 = true;
    __isset.field21 = true;
    __isset.field22 = true;
    __isset.field23 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct2(::apache::thrift::detail::argument_wrapper<1, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct2(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field1 = arg.move();
    __isset.field1 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct2(::apache::thrift::detail::argument_wrapper<2, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct2(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field2 = arg.move();
    __isset.field2 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct2(::apache::thrift::detail::argument_wrapper<3, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct2(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field3 = arg.move();
    __isset.field3 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct2(::apache::thrift::detail::argument_wrapper<4, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct2(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field4 = arg.move();
    __isset.field4 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct2(::apache::thrift::detail::argument_wrapper<5, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct2(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field5 = arg.move();
    __isset.field5 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct2(::apache::thrift::detail::argument_wrapper<6, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct2(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field6 = arg.move();
    __isset.field6 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct2(::apache::thrift::detail::argument_wrapper<7, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct2(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field7 = arg.move();
    __isset.field7 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct2(::apache::thrift::detail::argument_wrapper<8, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct2(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field8 = arg.move();
    __isset.field8 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct2(::apache::thrift::detail::argument_wrapper<9, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct2(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field9 = arg.move();
    __isset.field9 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct2(::apache::thrift::detail::argument_wrapper<10, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct2(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field10 = arg.move();
    __isset.field10 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct2(::apache::thrift::detail::argument_wrapper<11, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct2(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field11 = arg.move();
    __isset.field11 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct2(::apache::thrift::detail::argument_wrapper<12, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct2(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field12 = arg.move();
    __isset.field12 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct2(::apache::thrift::detail::argument_wrapper<13, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct2(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field13 = arg.move();
    __isset.field13 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct2(::apache::thrift::detail::argument_wrapper<14, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct2(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field14 = arg.move();
    __isset.field14 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct2(::apache::thrift::detail::argument_wrapper<15, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct2(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field15 = arg.move();
    __isset.field15 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct2(::apache::thrift::detail::argument_wrapper<16, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct2(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field16 = arg.move();
    __isset.field16 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct2(::apache::thrift::detail::argument_wrapper<17, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct2(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field17 = arg.move();
    __isset.field17 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct2(::apache::thrift::detail::argument_wrapper<18, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct2(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field18 = arg.move();
    __isset.field18 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct2(::apache::thrift::detail::argument_wrapper<19, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct2(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field19 = arg.move();
    __isset.field19 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct2(::apache::thrift::detail::argument_wrapper<20, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct2(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field20 = arg.move();
    __isset.field20 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct2(::apache::thrift::detail::argument_wrapper<21, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct2(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field21 = arg.move();
    __isset.field21 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct2(::apache::thrift::detail::argument_wrapper<22, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct2(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field22 = arg.move();
    __isset.field22 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct2(::apache::thrift::detail::argument_wrapper<23, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct2(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field23 = arg.move();
    __isset.field23 = true;
  }

  Struct2(Struct2&&) = default;

  Struct2(const Struct2&) = default;

  Struct2& operator=(Struct2&&) = default;

  Struct2& operator=(const Struct2&) = default;
  void __clear();

  virtual ~Struct2() {}

  int32_t field1;
  int32_t field2;
  float field3;
  std::map<std::map<std::set<bool>, int8_t>, std::string> field4;
  std::string field5;
  int8_t field6;
  std::string field7;
  int8_t field8;
  std::string field9;
  std::string field10;
  std::map<int16_t, double> field11;
  std::vector<int8_t> field12;
  std::string field13;
   ::cpp2::Struct0 field14;
  int64_t field15;
  std::map<std::string, int8_t> field16;
  std::vector<double> field17;
  std::set<std::string> field18;
  double field19;
  std::map<int8_t, std::string> field20;
  int32_t field21;
   ::cpp2::Struct1 field22;
   ::cpp2::Struct0 field23;

  struct __isset {
    void __clear() {
      field1 = false;
      field2 = false;
      field3 = false;
      field4 = false;
      field5 = false;
      field6 = false;
      field7 = false;
      field8 = false;
      field9 = false;
      field10 = false;
      field11 = false;
      field12 = false;
      field13 = false;
      field14 = false;
      field15 = false;
      field16 = false;
      field17 = false;
      field18 = false;
      field19 = false;
      field20 = false;
      field21 = false;
      field22 = false;
      field23 = false;
    }

    bool field1 = false;
    bool field2 = false;
    bool field3 = false;
    bool field4 = false;
    bool field5 = false;
    bool field6 = false;
    bool field7 = false;
    bool field8 = false;
    bool field9 = false;
    bool field10 = false;
    bool field11 = false;
    bool field12 = false;
    bool field13 = false;
    bool field14 = false;
    bool field15 = false;
    bool field16 = false;
    bool field17 = false;
    bool field18 = false;
    bool field19 = false;
    bool field20 = false;
    bool field21 = false;
    bool field22 = false;
    bool field23 = false;
  } __isset;
  bool operator==(const Struct2& rhs) const;

  bool operator < (const Struct2& rhs) const {
    if (!(field1 == rhs.field1)) {
      return field1 < rhs.field1;
    }
    if (!(field2 == rhs.field2)) {
      return field2 < rhs.field2;
    }
    if (!(field3 == rhs.field3)) {
      return field3 < rhs.field3;
    }
    if (!(field4 == rhs.field4)) {
      return field4 < rhs.field4;
    }
    if (!(field5 == rhs.field5)) {
      return field5 < rhs.field5;
    }
    if (!(field6 == rhs.field6)) {
      return field6 < rhs.field6;
    }
    if (!(field7 == rhs.field7)) {
      return field7 < rhs.field7;
    }
    if (!(field8 == rhs.field8)) {
      return field8 < rhs.field8;
    }
    if (!(field9 == rhs.field9)) {
      return field9 < rhs.field9;
    }
    if (!(field10 == rhs.field10)) {
      return field10 < rhs.field10;
    }
    if (!(field11 == rhs.field11)) {
      return field11 < rhs.field11;
    }
    if (!(field12 == rhs.field12)) {
      return field12 < rhs.field12;
    }
    if (!(field13 == rhs.field13)) {
      return field13 < rhs.field13;
    }
    if (!(field14 == rhs.field14)) {
      return field14 < rhs.field14;
    }
    if (!(field15 == rhs.field15)) {
      return field15 < rhs.field15;
    }
    if (!(field16 == rhs.field16)) {
      return field16 < rhs.field16;
    }
    if (!(field17 == rhs.field17)) {
      return field17 < rhs.field17;
    }
    if (!(field18 == rhs.field18)) {
      return field18 < rhs.field18;
    }
    if (!(field19 == rhs.field19)) {
      return field19 < rhs.field19;
    }
    if (!(field20 == rhs.field20)) {
      return field20 < rhs.field20;
    }
    if (!(field21 == rhs.field21)) {
      return field21 < rhs.field21;
    }
    if (!(field22 == rhs.field22)) {
      return field22 < rhs.field22;
    }
    if (!(field23 == rhs.field23)) {
      return field23 < rhs.field23;
    }
    (void)rhs;
    return false;
  }

  int32_t get_field1() const {
    return field1;
  }

  int32_t& set_field1(int32_t field1_) {
    field1 = field1_;
    __isset.field1 = true;
    return field1;
  }

  int32_t get_field2() const {
    return field2;
  }

  int32_t& set_field2(int32_t field2_) {
    field2 = field2_;
    __isset.field2 = true;
    return field2;
  }

  float get_field3() const {
    return field3;
  }

  float& set_field3(float field3_) {
    field3 = field3_;
    __isset.field3 = true;
    return field3;
  }
  const std::map<std::map<std::set<bool>, int8_t>, std::string>& get_field4() const&;
  std::map<std::map<std::set<bool>, int8_t>, std::string> get_field4() &&;

  template <typename T_Struct2_field4_struct_setter>
  std::map<std::map<std::set<bool>, int8_t>, std::string>& set_field4(T_Struct2_field4_struct_setter&& field4_) {
    field4 = std::forward<T_Struct2_field4_struct_setter>(field4_);
    __isset.field4 = true;
    return field4;
  }

  const std::string& get_field5() const& {
    return field5;
  }

  std::string get_field5() && {
    return std::move(field5);
  }

  template <typename T_Struct2_field5_struct_setter>
  std::string& set_field5(T_Struct2_field5_struct_setter&& field5_) {
    field5 = std::forward<T_Struct2_field5_struct_setter>(field5_);
    __isset.field5 = true;
    return field5;
  }

  int8_t get_field6() const {
    return field6;
  }

  int8_t& set_field6(int8_t field6_) {
    field6 = field6_;
    __isset.field6 = true;
    return field6;
  }

  const std::string& get_field7() const& {
    return field7;
  }

  std::string get_field7() && {
    return std::move(field7);
  }

  template <typename T_Struct2_field7_struct_setter>
  std::string& set_field7(T_Struct2_field7_struct_setter&& field7_) {
    field7 = std::forward<T_Struct2_field7_struct_setter>(field7_);
    __isset.field7 = true;
    return field7;
  }

  int8_t get_field8() const {
    return field8;
  }

  int8_t& set_field8(int8_t field8_) {
    field8 = field8_;
    __isset.field8 = true;
    return field8;
  }

  const std::string& get_field9() const& {
    return field9;
  }

  std::string get_field9() && {
    return std::move(field9);
  }

  template <typename T_Struct2_field9_struct_setter>
  std::string& set_field9(T_Struct2_field9_struct_setter&& field9_) {
    field9 = std::forward<T_Struct2_field9_struct_setter>(field9_);
    __isset.field9 = true;
    return field9;
  }

  const std::string& get_field10() const& {
    return field10;
  }

  std::string get_field10() && {
    return std::move(field10);
  }

  template <typename T_Struct2_field10_struct_setter>
  std::string& set_field10(T_Struct2_field10_struct_setter&& field10_) {
    field10 = std::forward<T_Struct2_field10_struct_setter>(field10_);
    __isset.field10 = true;
    return field10;
  }
  const std::map<int16_t, double>& get_field11() const&;
  std::map<int16_t, double> get_field11() &&;

  template <typename T_Struct2_field11_struct_setter>
  std::map<int16_t, double>& set_field11(T_Struct2_field11_struct_setter&& field11_) {
    field11 = std::forward<T_Struct2_field11_struct_setter>(field11_);
    __isset.field11 = true;
    return field11;
  }
  const std::vector<int8_t>& get_field12() const&;
  std::vector<int8_t> get_field12() &&;

  template <typename T_Struct2_field12_struct_setter>
  std::vector<int8_t>& set_field12(T_Struct2_field12_struct_setter&& field12_) {
    field12 = std::forward<T_Struct2_field12_struct_setter>(field12_);
    __isset.field12 = true;
    return field12;
  }

  const std::string& get_field13() const& {
    return field13;
  }

  std::string get_field13() && {
    return std::move(field13);
  }

  template <typename T_Struct2_field13_struct_setter>
  std::string& set_field13(T_Struct2_field13_struct_setter&& field13_) {
    field13 = std::forward<T_Struct2_field13_struct_setter>(field13_);
    __isset.field13 = true;
    return field13;
  }
  const  ::cpp2::Struct0& get_field14() const&;
   ::cpp2::Struct0 get_field14() &&;

  template <typename T_Struct2_field14_struct_setter>
   ::cpp2::Struct0& set_field14(T_Struct2_field14_struct_setter&& field14_) {
    field14 = std::forward<T_Struct2_field14_struct_setter>(field14_);
    __isset.field14 = true;
    return field14;
  }

  int64_t get_field15() const {
    return field15;
  }

  int64_t& set_field15(int64_t field15_) {
    field15 = field15_;
    __isset.field15 = true;
    return field15;
  }
  const std::map<std::string, int8_t>& get_field16() const&;
  std::map<std::string, int8_t> get_field16() &&;

  template <typename T_Struct2_field16_struct_setter>
  std::map<std::string, int8_t>& set_field16(T_Struct2_field16_struct_setter&& field16_) {
    field16 = std::forward<T_Struct2_field16_struct_setter>(field16_);
    __isset.field16 = true;
    return field16;
  }
  const std::vector<double>& get_field17() const&;
  std::vector<double> get_field17() &&;

  template <typename T_Struct2_field17_struct_setter>
  std::vector<double>& set_field17(T_Struct2_field17_struct_setter&& field17_) {
    field17 = std::forward<T_Struct2_field17_struct_setter>(field17_);
    __isset.field17 = true;
    return field17;
  }
  const std::set<std::string>& get_field18() const&;
  std::set<std::string> get_field18() &&;

  template <typename T_Struct2_field18_struct_setter>
  std::set<std::string>& set_field18(T_Struct2_field18_struct_setter&& field18_) {
    field18 = std::forward<T_Struct2_field18_struct_setter>(field18_);
    __isset.field18 = true;
    return field18;
  }

  double get_field19() const {
    return field19;
  }

  double& set_field19(double field19_) {
    field19 = field19_;
    __isset.field19 = true;
    return field19;
  }
  const std::map<int8_t, std::string>& get_field20() const&;
  std::map<int8_t, std::string> get_field20() &&;

  template <typename T_Struct2_field20_struct_setter>
  std::map<int8_t, std::string>& set_field20(T_Struct2_field20_struct_setter&& field20_) {
    field20 = std::forward<T_Struct2_field20_struct_setter>(field20_);
    __isset.field20 = true;
    return field20;
  }

  int32_t get_field21() const {
    return field21;
  }

  int32_t& set_field21(int32_t field21_) {
    field21 = field21_;
    __isset.field21 = true;
    return field21;
  }
  const  ::cpp2::Struct1& get_field22() const&;
   ::cpp2::Struct1 get_field22() &&;

  template <typename T_Struct2_field22_struct_setter>
   ::cpp2::Struct1& set_field22(T_Struct2_field22_struct_setter&& field22_) {
    field22 = std::forward<T_Struct2_field22_struct_setter>(field22_);
    __isset.field22 = true;
    return field22;
  }
  const  ::cpp2::Struct0& get_field23() const&;
   ::cpp2::Struct0 get_field23() &&;

  template <typename T_Struct2_field23_struct_setter>
   ::cpp2::Struct0& set_field23(T_Struct2_field23_struct_setter&& field23_) {
    field23 = std::forward<T_Struct2_field23_struct_setter>(field23_);
    __isset.field23 = true;
    return field23;
  }

  template <class Protocol_>
  uint32_t read(Protocol_* iprot);
  template <class Protocol_>
  uint32_t serializedSize(Protocol_ const* prot_) const;
  template <class Protocol_>
  uint32_t serializedSizeZC(Protocol_ const* prot_) const;
  template <class Protocol_>
  uint32_t write(Protocol_* prot_) const;

 private:
  static void translateFieldName(FOLLY_MAYBE_UNUSED folly::StringPiece _fname, FOLLY_MAYBE_UNUSED int16_t& fid, FOLLY_MAYBE_UNUSED apache::thrift::protocol::TType& _ftype);
};

void swap(Struct2& a, Struct2& b);
extern template uint32_t Struct2::read<>(apache::thrift::BinaryProtocolReader*);
extern template uint32_t Struct2::write<>(apache::thrift::BinaryProtocolWriter*) const;
extern template uint32_t Struct2::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const;
extern template uint32_t Struct2::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const;
extern template uint32_t Struct2::read<>(apache::thrift::CompactProtocolReader*);
extern template uint32_t Struct2::write<>(apache::thrift::CompactProtocolWriter*) const;
extern template uint32_t Struct2::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const;
extern template uint32_t Struct2::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const;

} // cpp2
namespace apache { namespace thrift {

template <> inline void Cpp2Ops< ::cpp2::Struct2>::clear( ::cpp2::Struct2* obj) {
  return obj->__clear();
}

template <> inline constexpr apache::thrift::protocol::TType Cpp2Ops< ::cpp2::Struct2>::thriftType() {
  return apache::thrift::protocol::T_STRUCT;
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct2>::write(Protocol* proto,  ::cpp2::Struct2 const* obj) {
  return obj->write(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct2>::read(Protocol* proto,  ::cpp2::Struct2* obj) {
  return obj->read(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct2>::serializedSize(Protocol const* proto,  ::cpp2::Struct2 const* obj) {
  return obj->serializedSize(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct2>::serializedSizeZC(Protocol const* proto,  ::cpp2::Struct2 const* obj) {
  return obj->serializedSizeZC(proto);
}

}} // apache::thrift
namespace cpp2 {
class Struct3 : private apache::thrift::detail::st::ComparisonOperators<Struct3> {
 public:

  Struct3() :
      field1(0),
      field2(0) {}
  // FragileConstructor for use in initialization lists only

  Struct3(apache::thrift::FragileConstructor, int8_t field1__arg, double field2__arg, std::map<float,  ::cpp2::Struct1> field3__arg,  ::cpp2::Struct1 field4__arg, std::map< ::cpp2::Struct2, int64_t> field5__arg, std::map<int32_t, std::string> field6__arg, std::string field7__arg) :
      field1(std::move(field1__arg)),
      field2(std::move(field2__arg)),
      field3(std::move(field3__arg)),
      field4(std::move(field4__arg)),
      field5(std::move(field5__arg)),
      field6(std::move(field6__arg)),
      field7(std::move(field7__arg)) {
    __isset.field1 = true;
    __isset.field2 = true;
    __isset.field3 = true;
    __isset.field4 = true;
    __isset.field5 = true;
    __isset.field6 = true;
    __isset.field7 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct3(::apache::thrift::detail::argument_wrapper<1, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct3(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field1 = arg.move();
    __isset.field1 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct3(::apache::thrift::detail::argument_wrapper<2, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct3(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field2 = arg.move();
    __isset.field2 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct3(::apache::thrift::detail::argument_wrapper<3, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct3(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field3 = arg.move();
    __isset.field3 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct3(::apache::thrift::detail::argument_wrapper<4, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct3(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field4 = arg.move();
    __isset.field4 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct3(::apache::thrift::detail::argument_wrapper<5, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct3(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field5 = arg.move();
    __isset.field5 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct3(::apache::thrift::detail::argument_wrapper<6, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct3(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field6 = arg.move();
    __isset.field6 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct3(::apache::thrift::detail::argument_wrapper<7, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct3(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field7 = arg.move();
    __isset.field7 = true;
  }

  Struct3(Struct3&&) = default;

  Struct3(const Struct3&) = default;

  Struct3& operator=(Struct3&&) = default;

  Struct3& operator=(const Struct3&) = default;
  void __clear();

  virtual ~Struct3() {}

  int8_t field1;
  double field2;
  std::map<float,  ::cpp2::Struct1> field3;
   ::cpp2::Struct1 field4;
  std::map< ::cpp2::Struct2, int64_t> field5;
  std::map<int32_t, std::string> field6;
  std::string field7;

  struct __isset {
    void __clear() {
      field1 = false;
      field2 = false;
      field3 = false;
      field4 = false;
      field5 = false;
      field6 = false;
      field7 = false;
    }

    bool field1 = false;
    bool field2 = false;
    bool field3 = false;
    bool field4 = false;
    bool field5 = false;
    bool field6 = false;
    bool field7 = false;
  } __isset;
  bool operator==(const Struct3& rhs) const;

  bool operator < (const Struct3& rhs) const {
    if (!(field1 == rhs.field1)) {
      return field1 < rhs.field1;
    }
    if (!(field2 == rhs.field2)) {
      return field2 < rhs.field2;
    }
    if (!(field3 == rhs.field3)) {
      return field3 < rhs.field3;
    }
    if (!(field4 == rhs.field4)) {
      return field4 < rhs.field4;
    }
    if (!(field5 == rhs.field5)) {
      return field5 < rhs.field5;
    }
    if (!(field6 == rhs.field6)) {
      return field6 < rhs.field6;
    }
    if (!(field7 == rhs.field7)) {
      return field7 < rhs.field7;
    }
    (void)rhs;
    return false;
  }

  int8_t get_field1() const {
    return field1;
  }

  int8_t& set_field1(int8_t field1_) {
    field1 = field1_;
    __isset.field1 = true;
    return field1;
  }

  double get_field2() const {
    return field2;
  }

  double& set_field2(double field2_) {
    field2 = field2_;
    __isset.field2 = true;
    return field2;
  }
  const std::map<float,  ::cpp2::Struct1>& get_field3() const&;
  std::map<float,  ::cpp2::Struct1> get_field3() &&;

  template <typename T_Struct3_field3_struct_setter>
  std::map<float,  ::cpp2::Struct1>& set_field3(T_Struct3_field3_struct_setter&& field3_) {
    field3 = std::forward<T_Struct3_field3_struct_setter>(field3_);
    __isset.field3 = true;
    return field3;
  }
  const  ::cpp2::Struct1& get_field4() const&;
   ::cpp2::Struct1 get_field4() &&;

  template <typename T_Struct3_field4_struct_setter>
   ::cpp2::Struct1& set_field4(T_Struct3_field4_struct_setter&& field4_) {
    field4 = std::forward<T_Struct3_field4_struct_setter>(field4_);
    __isset.field4 = true;
    return field4;
  }
  const std::map< ::cpp2::Struct2, int64_t>& get_field5() const&;
  std::map< ::cpp2::Struct2, int64_t> get_field5() &&;

  template <typename T_Struct3_field5_struct_setter>
  std::map< ::cpp2::Struct2, int64_t>& set_field5(T_Struct3_field5_struct_setter&& field5_) {
    field5 = std::forward<T_Struct3_field5_struct_setter>(field5_);
    __isset.field5 = true;
    return field5;
  }
  const std::map<int32_t, std::string>& get_field6() const&;
  std::map<int32_t, std::string> get_field6() &&;

  template <typename T_Struct3_field6_struct_setter>
  std::map<int32_t, std::string>& set_field6(T_Struct3_field6_struct_setter&& field6_) {
    field6 = std::forward<T_Struct3_field6_struct_setter>(field6_);
    __isset.field6 = true;
    return field6;
  }

  const std::string& get_field7() const& {
    return field7;
  }

  std::string get_field7() && {
    return std::move(field7);
  }

  template <typename T_Struct3_field7_struct_setter>
  std::string& set_field7(T_Struct3_field7_struct_setter&& field7_) {
    field7 = std::forward<T_Struct3_field7_struct_setter>(field7_);
    __isset.field7 = true;
    return field7;
  }

  template <class Protocol_>
  uint32_t read(Protocol_* iprot);
  template <class Protocol_>
  uint32_t serializedSize(Protocol_ const* prot_) const;
  template <class Protocol_>
  uint32_t serializedSizeZC(Protocol_ const* prot_) const;
  template <class Protocol_>
  uint32_t write(Protocol_* prot_) const;

 private:
  static void translateFieldName(FOLLY_MAYBE_UNUSED folly::StringPiece _fname, FOLLY_MAYBE_UNUSED int16_t& fid, FOLLY_MAYBE_UNUSED apache::thrift::protocol::TType& _ftype);
};

void swap(Struct3& a, Struct3& b);
extern template uint32_t Struct3::read<>(apache::thrift::BinaryProtocolReader*);
extern template uint32_t Struct3::write<>(apache::thrift::BinaryProtocolWriter*) const;
extern template uint32_t Struct3::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const;
extern template uint32_t Struct3::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const;
extern template uint32_t Struct3::read<>(apache::thrift::CompactProtocolReader*);
extern template uint32_t Struct3::write<>(apache::thrift::CompactProtocolWriter*) const;
extern template uint32_t Struct3::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const;
extern template uint32_t Struct3::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const;

} // cpp2
namespace apache { namespace thrift {

template <> inline void Cpp2Ops< ::cpp2::Struct3>::clear( ::cpp2::Struct3* obj) {
  return obj->__clear();
}

template <> inline constexpr apache::thrift::protocol::TType Cpp2Ops< ::cpp2::Struct3>::thriftType() {
  return apache::thrift::protocol::T_STRUCT;
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct3>::write(Protocol* proto,  ::cpp2::Struct3 const* obj) {
  return obj->write(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct3>::read(Protocol* proto,  ::cpp2::Struct3* obj) {
  return obj->read(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct3>::serializedSize(Protocol const* proto,  ::cpp2::Struct3 const* obj) {
  return obj->serializedSize(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct3>::serializedSizeZC(Protocol const* proto,  ::cpp2::Struct3 const* obj) {
  return obj->serializedSizeZC(proto);
}

}} // apache::thrift
namespace cpp2 {
class Struct4 : private apache::thrift::detail::st::ComparisonOperators<Struct4> {
 public:

  Struct4() :
      field2(0),
      field3(0),
      field7(0) {}
  // FragileConstructor for use in initialization lists only

  Struct4(apache::thrift::FragileConstructor, std::set<std::string> field1__arg, float field2__arg, float field3__arg, std::set< ::cpp2::Struct0> field4__arg,  ::cpp2::Struct2 field5__arg, std::map<int32_t, int32_t> field6__arg, int16_t field7__arg) :
      field1(std::move(field1__arg)),
      field2(std::move(field2__arg)),
      field3(std::move(field3__arg)),
      field4(std::move(field4__arg)),
      field5(std::move(field5__arg)),
      field6(std::move(field6__arg)),
      field7(std::move(field7__arg)) {
    __isset.field1 = true;
    __isset.field2 = true;
    __isset.field3 = true;
    __isset.field4 = true;
    __isset.field5 = true;
    __isset.field6 = true;
    __isset.field7 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct4(::apache::thrift::detail::argument_wrapper<1, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct4(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field1 = arg.move();
    __isset.field1 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct4(::apache::thrift::detail::argument_wrapper<2, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct4(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field2 = arg.move();
    __isset.field2 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct4(::apache::thrift::detail::argument_wrapper<3, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct4(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field3 = arg.move();
    __isset.field3 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct4(::apache::thrift::detail::argument_wrapper<4, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct4(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field4 = arg.move();
    __isset.field4 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct4(::apache::thrift::detail::argument_wrapper<5, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct4(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field5 = arg.move();
    __isset.field5 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct4(::apache::thrift::detail::argument_wrapper<6, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct4(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field6 = arg.move();
    __isset.field6 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct4(::apache::thrift::detail::argument_wrapper<7, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct4(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field7 = arg.move();
    __isset.field7 = true;
  }

  Struct4(Struct4&&) = default;

  Struct4(const Struct4&) = default;

  Struct4& operator=(Struct4&&) = default;

  Struct4& operator=(const Struct4&) = default;
  void __clear();

  virtual ~Struct4() {}

  std::set<std::string> field1;
  float field2;
  float field3;
  std::set< ::cpp2::Struct0> field4;
   ::cpp2::Struct2 field5;
  std::map<int32_t, int32_t> field6;
  int16_t field7;

  struct __isset {
    void __clear() {
      field1 = false;
      field2 = false;
      field3 = false;
      field4 = false;
      field5 = false;
      field6 = false;
      field7 = false;
    }

    bool field1 = false;
    bool field2 = false;
    bool field3 = false;
    bool field4 = false;
    bool field5 = false;
    bool field6 = false;
    bool field7 = false;
  } __isset;
  bool operator==(const Struct4& rhs) const;

  bool operator < (const Struct4& rhs) const {
    if (!(field1 == rhs.field1)) {
      return field1 < rhs.field1;
    }
    if (!(field2 == rhs.field2)) {
      return field2 < rhs.field2;
    }
    if (!(field3 == rhs.field3)) {
      return field3 < rhs.field3;
    }
    if (!(field4 == rhs.field4)) {
      return field4 < rhs.field4;
    }
    if (!(field5 == rhs.field5)) {
      return field5 < rhs.field5;
    }
    if (!(field6 == rhs.field6)) {
      return field6 < rhs.field6;
    }
    if (!(field7 == rhs.field7)) {
      return field7 < rhs.field7;
    }
    (void)rhs;
    return false;
  }
  const std::set<std::string>& get_field1() const&;
  std::set<std::string> get_field1() &&;

  template <typename T_Struct4_field1_struct_setter>
  std::set<std::string>& set_field1(T_Struct4_field1_struct_setter&& field1_) {
    field1 = std::forward<T_Struct4_field1_struct_setter>(field1_);
    __isset.field1 = true;
    return field1;
  }

  float get_field2() const {
    return field2;
  }

  float& set_field2(float field2_) {
    field2 = field2_;
    __isset.field2 = true;
    return field2;
  }

  float get_field3() const {
    return field3;
  }

  float& set_field3(float field3_) {
    field3 = field3_;
    __isset.field3 = true;
    return field3;
  }
  const std::set< ::cpp2::Struct0>& get_field4() const&;
  std::set< ::cpp2::Struct0> get_field4() &&;

  template <typename T_Struct4_field4_struct_setter>
  std::set< ::cpp2::Struct0>& set_field4(T_Struct4_field4_struct_setter&& field4_) {
    field4 = std::forward<T_Struct4_field4_struct_setter>(field4_);
    __isset.field4 = true;
    return field4;
  }
  const  ::cpp2::Struct2& get_field5() const&;
   ::cpp2::Struct2 get_field5() &&;

  template <typename T_Struct4_field5_struct_setter>
   ::cpp2::Struct2& set_field5(T_Struct4_field5_struct_setter&& field5_) {
    field5 = std::forward<T_Struct4_field5_struct_setter>(field5_);
    __isset.field5 = true;
    return field5;
  }
  const std::map<int32_t, int32_t>& get_field6() const&;
  std::map<int32_t, int32_t> get_field6() &&;

  template <typename T_Struct4_field6_struct_setter>
  std::map<int32_t, int32_t>& set_field6(T_Struct4_field6_struct_setter&& field6_) {
    field6 = std::forward<T_Struct4_field6_struct_setter>(field6_);
    __isset.field6 = true;
    return field6;
  }

  int16_t get_field7() const {
    return field7;
  }

  int16_t& set_field7(int16_t field7_) {
    field7 = field7_;
    __isset.field7 = true;
    return field7;
  }

  template <class Protocol_>
  uint32_t read(Protocol_* iprot);
  template <class Protocol_>
  uint32_t serializedSize(Protocol_ const* prot_) const;
  template <class Protocol_>
  uint32_t serializedSizeZC(Protocol_ const* prot_) const;
  template <class Protocol_>
  uint32_t write(Protocol_* prot_) const;

 private:
  static void translateFieldName(FOLLY_MAYBE_UNUSED folly::StringPiece _fname, FOLLY_MAYBE_UNUSED int16_t& fid, FOLLY_MAYBE_UNUSED apache::thrift::protocol::TType& _ftype);
};

void swap(Struct4& a, Struct4& b);
extern template uint32_t Struct4::read<>(apache::thrift::BinaryProtocolReader*);
extern template uint32_t Struct4::write<>(apache::thrift::BinaryProtocolWriter*) const;
extern template uint32_t Struct4::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const;
extern template uint32_t Struct4::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const;
extern template uint32_t Struct4::read<>(apache::thrift::CompactProtocolReader*);
extern template uint32_t Struct4::write<>(apache::thrift::CompactProtocolWriter*) const;
extern template uint32_t Struct4::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const;
extern template uint32_t Struct4::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const;

} // cpp2
namespace apache { namespace thrift {

template <> inline void Cpp2Ops< ::cpp2::Struct4>::clear( ::cpp2::Struct4* obj) {
  return obj->__clear();
}

template <> inline constexpr apache::thrift::protocol::TType Cpp2Ops< ::cpp2::Struct4>::thriftType() {
  return apache::thrift::protocol::T_STRUCT;
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct4>::write(Protocol* proto,  ::cpp2::Struct4 const* obj) {
  return obj->write(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct4>::read(Protocol* proto,  ::cpp2::Struct4* obj) {
  return obj->read(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct4>::serializedSize(Protocol const* proto,  ::cpp2::Struct4 const* obj) {
  return obj->serializedSize(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct4>::serializedSizeZC(Protocol const* proto,  ::cpp2::Struct4 const* obj) {
  return obj->serializedSizeZC(proto);
}

}} // apache::thrift
namespace cpp2 {
class Struct5 : private apache::thrift::detail::st::ComparisonOperators<Struct5> {
 public:

  Struct5() :
      field1(0),
      field4(0),
      field5(0),
      field7(0) {}
  // FragileConstructor for use in initialization lists only

  Struct5(apache::thrift::FragileConstructor, int32_t field1__arg, std::map<std::set<bool>, int32_t> field2__arg, std::map< ::cpp2::Struct1, bool> field3__arg, int32_t field4__arg, int64_t field5__arg, std::map<std::vector<double>, int16_t> field6__arg, int8_t field7__arg) :
      field1(std::move(field1__arg)),
      field2(std::move(field2__arg)),
      field3(std::move(field3__arg)),
      field4(std::move(field4__arg)),
      field5(std::move(field5__arg)),
      field6(std::move(field6__arg)),
      field7(std::move(field7__arg)) {
    __isset.field1 = true;
    __isset.field2 = true;
    __isset.field3 = true;
    __isset.field4 = true;
    __isset.field5 = true;
    __isset.field6 = true;
    __isset.field7 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct5(::apache::thrift::detail::argument_wrapper<1, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct5(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field1 = arg.move();
    __isset.field1 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct5(::apache::thrift::detail::argument_wrapper<2, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct5(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field2 = arg.move();
    __isset.field2 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct5(::apache::thrift::detail::argument_wrapper<3, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct5(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field3 = arg.move();
    __isset.field3 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct5(::apache::thrift::detail::argument_wrapper<4, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct5(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field4 = arg.move();
    __isset.field4 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct5(::apache::thrift::detail::argument_wrapper<5, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct5(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field5 = arg.move();
    __isset.field5 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct5(::apache::thrift::detail::argument_wrapper<6, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct5(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field6 = arg.move();
    __isset.field6 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct5(::apache::thrift::detail::argument_wrapper<7, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct5(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field7 = arg.move();
    __isset.field7 = true;
  }

  Struct5(Struct5&&) = default;

  Struct5(const Struct5&) = default;

  Struct5& operator=(Struct5&&) = default;

  Struct5& operator=(const Struct5&) = default;
  void __clear();

  virtual ~Struct5() {}

  int32_t field1;
  std::map<std::set<bool>, int32_t> field2;
  std::map< ::cpp2::Struct1, bool> field3;
  int32_t field4;
  int64_t field5;
  std::map<std::vector<double>, int16_t> field6;
  int8_t field7;

  struct __isset {
    void __clear() {
      field1 = false;
      field2 = false;
      field3 = false;
      field4 = false;
      field5 = false;
      field6 = false;
      field7 = false;
    }

    bool field1 = false;
    bool field2 = false;
    bool field3 = false;
    bool field4 = false;
    bool field5 = false;
    bool field6 = false;
    bool field7 = false;
  } __isset;
  bool operator==(const Struct5& rhs) const;

  bool operator < (const Struct5& rhs) const {
    if (!(field1 == rhs.field1)) {
      return field1 < rhs.field1;
    }
    if (!(field2 == rhs.field2)) {
      return field2 < rhs.field2;
    }
    if (!(field3 == rhs.field3)) {
      return field3 < rhs.field3;
    }
    if (!(field4 == rhs.field4)) {
      return field4 < rhs.field4;
    }
    if (!(field5 == rhs.field5)) {
      return field5 < rhs.field5;
    }
    if (!(field6 == rhs.field6)) {
      return field6 < rhs.field6;
    }
    if (!(field7 == rhs.field7)) {
      return field7 < rhs.field7;
    }
    (void)rhs;
    return false;
  }

  int32_t get_field1() const {
    return field1;
  }

  int32_t& set_field1(int32_t field1_) {
    field1 = field1_;
    __isset.field1 = true;
    return field1;
  }
  const std::map<std::set<bool>, int32_t>& get_field2() const&;
  std::map<std::set<bool>, int32_t> get_field2() &&;

  template <typename T_Struct5_field2_struct_setter>
  std::map<std::set<bool>, int32_t>& set_field2(T_Struct5_field2_struct_setter&& field2_) {
    field2 = std::forward<T_Struct5_field2_struct_setter>(field2_);
    __isset.field2 = true;
    return field2;
  }
  const std::map< ::cpp2::Struct1, bool>& get_field3() const&;
  std::map< ::cpp2::Struct1, bool> get_field3() &&;

  template <typename T_Struct5_field3_struct_setter>
  std::map< ::cpp2::Struct1, bool>& set_field3(T_Struct5_field3_struct_setter&& field3_) {
    field3 = std::forward<T_Struct5_field3_struct_setter>(field3_);
    __isset.field3 = true;
    return field3;
  }

  int32_t get_field4() const {
    return field4;
  }

  int32_t& set_field4(int32_t field4_) {
    field4 = field4_;
    __isset.field4 = true;
    return field4;
  }

  int64_t get_field5() const {
    return field5;
  }

  int64_t& set_field5(int64_t field5_) {
    field5 = field5_;
    __isset.field5 = true;
    return field5;
  }
  const std::map<std::vector<double>, int16_t>& get_field6() const&;
  std::map<std::vector<double>, int16_t> get_field6() &&;

  template <typename T_Struct5_field6_struct_setter>
  std::map<std::vector<double>, int16_t>& set_field6(T_Struct5_field6_struct_setter&& field6_) {
    field6 = std::forward<T_Struct5_field6_struct_setter>(field6_);
    __isset.field6 = true;
    return field6;
  }

  int8_t get_field7() const {
    return field7;
  }

  int8_t& set_field7(int8_t field7_) {
    field7 = field7_;
    __isset.field7 = true;
    return field7;
  }

  template <class Protocol_>
  uint32_t read(Protocol_* iprot);
  template <class Protocol_>
  uint32_t serializedSize(Protocol_ const* prot_) const;
  template <class Protocol_>
  uint32_t serializedSizeZC(Protocol_ const* prot_) const;
  template <class Protocol_>
  uint32_t write(Protocol_* prot_) const;

 private:
  static void translateFieldName(FOLLY_MAYBE_UNUSED folly::StringPiece _fname, FOLLY_MAYBE_UNUSED int16_t& fid, FOLLY_MAYBE_UNUSED apache::thrift::protocol::TType& _ftype);
};

void swap(Struct5& a, Struct5& b);
extern template uint32_t Struct5::read<>(apache::thrift::BinaryProtocolReader*);
extern template uint32_t Struct5::write<>(apache::thrift::BinaryProtocolWriter*) const;
extern template uint32_t Struct5::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const;
extern template uint32_t Struct5::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const;
extern template uint32_t Struct5::read<>(apache::thrift::CompactProtocolReader*);
extern template uint32_t Struct5::write<>(apache::thrift::CompactProtocolWriter*) const;
extern template uint32_t Struct5::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const;
extern template uint32_t Struct5::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const;

} // cpp2
namespace apache { namespace thrift {

template <> inline void Cpp2Ops< ::cpp2::Struct5>::clear( ::cpp2::Struct5* obj) {
  return obj->__clear();
}

template <> inline constexpr apache::thrift::protocol::TType Cpp2Ops< ::cpp2::Struct5>::thriftType() {
  return apache::thrift::protocol::T_STRUCT;
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct5>::write(Protocol* proto,  ::cpp2::Struct5 const* obj) {
  return obj->write(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct5>::read(Protocol* proto,  ::cpp2::Struct5* obj) {
  return obj->read(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct5>::serializedSize(Protocol const* proto,  ::cpp2::Struct5 const* obj) {
  return obj->serializedSize(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct5>::serializedSizeZC(Protocol const* proto,  ::cpp2::Struct5 const* obj) {
  return obj->serializedSizeZC(proto);
}

}} // apache::thrift
namespace cpp2 {
class Struct6 : private apache::thrift::detail::st::ComparisonOperators<Struct6> {
 public:

  Struct6() :
      field1(0),
      field2(0),
      field3(0),
      field7(0),
      field8(0),
      field9(0) {}
  // FragileConstructor for use in initialization lists only

  Struct6(apache::thrift::FragileConstructor, int64_t field1__arg, int16_t field2__arg, double field3__arg,  ::cpp2::Struct0 field4__arg, std::string field5__arg,  ::cpp2::Struct1 field6__arg, bool field7__arg, int8_t field8__arg, int16_t field9__arg, std::string field10__arg, std::string field11__arg, std::map<std::set<std::vector<int32_t>>, double> field12__arg, std::string field13__arg, std::vector<int64_t> field14__arg) :
      field1(std::move(field1__arg)),
      field2(std::move(field2__arg)),
      field3(std::move(field3__arg)),
      field4(std::move(field4__arg)),
      field5(std::move(field5__arg)),
      field6(std::move(field6__arg)),
      field7(std::move(field7__arg)),
      field8(std::move(field8__arg)),
      field9(std::move(field9__arg)),
      field10(std::move(field10__arg)),
      field11(std::move(field11__arg)),
      field12(std::move(field12__arg)),
      field13(std::move(field13__arg)),
      field14(std::move(field14__arg)) {
    __isset.field1 = true;
    __isset.field2 = true;
    __isset.field3 = true;
    __isset.field4 = true;
    __isset.field5 = true;
    __isset.field6 = true;
    __isset.field7 = true;
    __isset.field8 = true;
    __isset.field9 = true;
    __isset.field10 = true;
    __isset.field11 = true;
    __isset.field12 = true;
    __isset.field13 = true;
    __isset.field14 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct6(::apache::thrift::detail::argument_wrapper<1, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct6(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field1 = arg.move();
    __isset.field1 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct6(::apache::thrift::detail::argument_wrapper<2, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct6(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field2 = arg.move();
    __isset.field2 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct6(::apache::thrift::detail::argument_wrapper<3, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct6(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field3 = arg.move();
    __isset.field3 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct6(::apache::thrift::detail::argument_wrapper<4, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct6(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field4 = arg.move();
    __isset.field4 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct6(::apache::thrift::detail::argument_wrapper<5, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct6(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field5 = arg.move();
    __isset.field5 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct6(::apache::thrift::detail::argument_wrapper<6, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct6(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field6 = arg.move();
    __isset.field6 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct6(::apache::thrift::detail::argument_wrapper<7, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct6(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field7 = arg.move();
    __isset.field7 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct6(::apache::thrift::detail::argument_wrapper<8, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct6(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field8 = arg.move();
    __isset.field8 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct6(::apache::thrift::detail::argument_wrapper<9, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct6(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field9 = arg.move();
    __isset.field9 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct6(::apache::thrift::detail::argument_wrapper<10, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct6(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field10 = arg.move();
    __isset.field10 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct6(::apache::thrift::detail::argument_wrapper<11, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct6(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field11 = arg.move();
    __isset.field11 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct6(::apache::thrift::detail::argument_wrapper<12, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct6(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field12 = arg.move();
    __isset.field12 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct6(::apache::thrift::detail::argument_wrapper<13, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct6(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field13 = arg.move();
    __isset.field13 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct6(::apache::thrift::detail::argument_wrapper<14, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct6(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field14 = arg.move();
    __isset.field14 = true;
  }

  Struct6(Struct6&&) = default;

  Struct6(const Struct6&) = default;

  Struct6& operator=(Struct6&&) = default;

  Struct6& operator=(const Struct6&) = default;
  void __clear();

  virtual ~Struct6() {}

  int64_t field1;
  int16_t field2;
  double field3;
   ::cpp2::Struct0 field4;
  std::string field5;
   ::cpp2::Struct1 field6;
  bool field7;
  int8_t field8;
  int16_t field9;
  std::string field10;
  std::string field11;
  std::map<std::set<std::vector<int32_t>>, double> field12;
  std::string field13;
  std::vector<int64_t> field14;

  struct __isset {
    void __clear() {
      field1 = false;
      field2 = false;
      field3 = false;
      field4 = false;
      field5 = false;
      field6 = false;
      field7 = false;
      field8 = false;
      field9 = false;
      field10 = false;
      field11 = false;
      field12 = false;
      field13 = false;
      field14 = false;
    }

    bool field1 = false;
    bool field2 = false;
    bool field3 = false;
    bool field4 = false;
    bool field5 = false;
    bool field6 = false;
    bool field7 = false;
    bool field8 = false;
    bool field9 = false;
    bool field10 = false;
    bool field11 = false;
    bool field12 = false;
    bool field13 = false;
    bool field14 = false;
  } __isset;
  bool operator==(const Struct6& rhs) const;

  bool operator < (const Struct6& rhs) const {
    if (!(field1 == rhs.field1)) {
      return field1 < rhs.field1;
    }
    if (!(field2 == rhs.field2)) {
      return field2 < rhs.field2;
    }
    if (!(field3 == rhs.field3)) {
      return field3 < rhs.field3;
    }
    if (!(field4 == rhs.field4)) {
      return field4 < rhs.field4;
    }
    if (!(field5 == rhs.field5)) {
      return field5 < rhs.field5;
    }
    if (!(field6 == rhs.field6)) {
      return field6 < rhs.field6;
    }
    if (!(field7 == rhs.field7)) {
      return field7 < rhs.field7;
    }
    if (!(field8 == rhs.field8)) {
      return field8 < rhs.field8;
    }
    if (!(field9 == rhs.field9)) {
      return field9 < rhs.field9;
    }
    if (!(field10 == rhs.field10)) {
      return field10 < rhs.field10;
    }
    if (!(field11 == rhs.field11)) {
      return field11 < rhs.field11;
    }
    if (!(field12 == rhs.field12)) {
      return field12 < rhs.field12;
    }
    if (!(field13 == rhs.field13)) {
      return field13 < rhs.field13;
    }
    if (!(field14 == rhs.field14)) {
      return field14 < rhs.field14;
    }
    (void)rhs;
    return false;
  }

  int64_t get_field1() const {
    return field1;
  }

  int64_t& set_field1(int64_t field1_) {
    field1 = field1_;
    __isset.field1 = true;
    return field1;
  }

  int16_t get_field2() const {
    return field2;
  }

  int16_t& set_field2(int16_t field2_) {
    field2 = field2_;
    __isset.field2 = true;
    return field2;
  }

  double get_field3() const {
    return field3;
  }

  double& set_field3(double field3_) {
    field3 = field3_;
    __isset.field3 = true;
    return field3;
  }
  const  ::cpp2::Struct0& get_field4() const&;
   ::cpp2::Struct0 get_field4() &&;

  template <typename T_Struct6_field4_struct_setter>
   ::cpp2::Struct0& set_field4(T_Struct6_field4_struct_setter&& field4_) {
    field4 = std::forward<T_Struct6_field4_struct_setter>(field4_);
    __isset.field4 = true;
    return field4;
  }

  const std::string& get_field5() const& {
    return field5;
  }

  std::string get_field5() && {
    return std::move(field5);
  }

  template <typename T_Struct6_field5_struct_setter>
  std::string& set_field5(T_Struct6_field5_struct_setter&& field5_) {
    field5 = std::forward<T_Struct6_field5_struct_setter>(field5_);
    __isset.field5 = true;
    return field5;
  }
  const  ::cpp2::Struct1& get_field6() const&;
   ::cpp2::Struct1 get_field6() &&;

  template <typename T_Struct6_field6_struct_setter>
   ::cpp2::Struct1& set_field6(T_Struct6_field6_struct_setter&& field6_) {
    field6 = std::forward<T_Struct6_field6_struct_setter>(field6_);
    __isset.field6 = true;
    return field6;
  }

  bool get_field7() const {
    return field7;
  }

  bool& set_field7(bool field7_) {
    field7 = field7_;
    __isset.field7 = true;
    return field7;
  }

  int8_t get_field8() const {
    return field8;
  }

  int8_t& set_field8(int8_t field8_) {
    field8 = field8_;
    __isset.field8 = true;
    return field8;
  }

  int16_t get_field9() const {
    return field9;
  }

  int16_t& set_field9(int16_t field9_) {
    field9 = field9_;
    __isset.field9 = true;
    return field9;
  }

  const std::string& get_field10() const& {
    return field10;
  }

  std::string get_field10() && {
    return std::move(field10);
  }

  template <typename T_Struct6_field10_struct_setter>
  std::string& set_field10(T_Struct6_field10_struct_setter&& field10_) {
    field10 = std::forward<T_Struct6_field10_struct_setter>(field10_);
    __isset.field10 = true;
    return field10;
  }

  const std::string& get_field11() const& {
    return field11;
  }

  std::string get_field11() && {
    return std::move(field11);
  }

  template <typename T_Struct6_field11_struct_setter>
  std::string& set_field11(T_Struct6_field11_struct_setter&& field11_) {
    field11 = std::forward<T_Struct6_field11_struct_setter>(field11_);
    __isset.field11 = true;
    return field11;
  }
  const std::map<std::set<std::vector<int32_t>>, double>& get_field12() const&;
  std::map<std::set<std::vector<int32_t>>, double> get_field12() &&;

  template <typename T_Struct6_field12_struct_setter>
  std::map<std::set<std::vector<int32_t>>, double>& set_field12(T_Struct6_field12_struct_setter&& field12_) {
    field12 = std::forward<T_Struct6_field12_struct_setter>(field12_);
    __isset.field12 = true;
    return field12;
  }

  const std::string& get_field13() const& {
    return field13;
  }

  std::string get_field13() && {
    return std::move(field13);
  }

  template <typename T_Struct6_field13_struct_setter>
  std::string& set_field13(T_Struct6_field13_struct_setter&& field13_) {
    field13 = std::forward<T_Struct6_field13_struct_setter>(field13_);
    __isset.field13 = true;
    return field13;
  }
  const std::vector<int64_t>& get_field14() const&;
  std::vector<int64_t> get_field14() &&;

  template <typename T_Struct6_field14_struct_setter>
  std::vector<int64_t>& set_field14(T_Struct6_field14_struct_setter&& field14_) {
    field14 = std::forward<T_Struct6_field14_struct_setter>(field14_);
    __isset.field14 = true;
    return field14;
  }

  template <class Protocol_>
  uint32_t read(Protocol_* iprot);
  template <class Protocol_>
  uint32_t serializedSize(Protocol_ const* prot_) const;
  template <class Protocol_>
  uint32_t serializedSizeZC(Protocol_ const* prot_) const;
  template <class Protocol_>
  uint32_t write(Protocol_* prot_) const;

 private:
  static void translateFieldName(FOLLY_MAYBE_UNUSED folly::StringPiece _fname, FOLLY_MAYBE_UNUSED int16_t& fid, FOLLY_MAYBE_UNUSED apache::thrift::protocol::TType& _ftype);
};

void swap(Struct6& a, Struct6& b);
extern template uint32_t Struct6::read<>(apache::thrift::BinaryProtocolReader*);
extern template uint32_t Struct6::write<>(apache::thrift::BinaryProtocolWriter*) const;
extern template uint32_t Struct6::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const;
extern template uint32_t Struct6::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const;
extern template uint32_t Struct6::read<>(apache::thrift::CompactProtocolReader*);
extern template uint32_t Struct6::write<>(apache::thrift::CompactProtocolWriter*) const;
extern template uint32_t Struct6::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const;
extern template uint32_t Struct6::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const;

} // cpp2
namespace apache { namespace thrift {

template <> inline void Cpp2Ops< ::cpp2::Struct6>::clear( ::cpp2::Struct6* obj) {
  return obj->__clear();
}

template <> inline constexpr apache::thrift::protocol::TType Cpp2Ops< ::cpp2::Struct6>::thriftType() {
  return apache::thrift::protocol::T_STRUCT;
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct6>::write(Protocol* proto,  ::cpp2::Struct6 const* obj) {
  return obj->write(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct6>::read(Protocol* proto,  ::cpp2::Struct6* obj) {
  return obj->read(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct6>::serializedSize(Protocol const* proto,  ::cpp2::Struct6 const* obj) {
  return obj->serializedSize(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct6>::serializedSizeZC(Protocol const* proto,  ::cpp2::Struct6 const* obj) {
  return obj->serializedSizeZC(proto);
}

}} // apache::thrift
namespace cpp2 {
class Struct7 : private apache::thrift::detail::st::ComparisonOperators<Struct7> {
 public:

  Struct7() {}
  // FragileConstructor for use in initialization lists only

  Struct7(apache::thrift::FragileConstructor) {}

  Struct7(Struct7&&) = default;

  Struct7(const Struct7&) = default;

  Struct7& operator=(Struct7&&) = default;

  Struct7& operator=(const Struct7&) = default;
  void __clear();

  virtual ~Struct7() {}

  bool operator==(const Struct7& /* rhs */) const;

  bool operator < (const Struct7& rhs) const {
    (void)rhs;
    return false;
  }

  template <class Protocol_>
  uint32_t read(Protocol_* iprot);
  template <class Protocol_>
  uint32_t serializedSize(Protocol_ const* prot_) const;
  template <class Protocol_>
  uint32_t serializedSizeZC(Protocol_ const* prot_) const;
  template <class Protocol_>
  uint32_t write(Protocol_* prot_) const;

 private:
  static void translateFieldName(FOLLY_MAYBE_UNUSED folly::StringPiece _fname, FOLLY_MAYBE_UNUSED int16_t& fid, FOLLY_MAYBE_UNUSED apache::thrift::protocol::TType& _ftype);
};

void swap(Struct7& a, Struct7& b);
extern template uint32_t Struct7::read<>(apache::thrift::BinaryProtocolReader*);
extern template uint32_t Struct7::write<>(apache::thrift::BinaryProtocolWriter*) const;
extern template uint32_t Struct7::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const;
extern template uint32_t Struct7::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const;
extern template uint32_t Struct7::read<>(apache::thrift::CompactProtocolReader*);
extern template uint32_t Struct7::write<>(apache::thrift::CompactProtocolWriter*) const;
extern template uint32_t Struct7::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const;
extern template uint32_t Struct7::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const;

} // cpp2
namespace apache { namespace thrift {

template <> inline void Cpp2Ops< ::cpp2::Struct7>::clear( ::cpp2::Struct7* obj) {
  return obj->__clear();
}

template <> inline constexpr apache::thrift::protocol::TType Cpp2Ops< ::cpp2::Struct7>::thriftType() {
  return apache::thrift::protocol::T_STRUCT;
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct7>::write(Protocol* proto,  ::cpp2::Struct7 const* obj) {
  return obj->write(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct7>::read(Protocol* proto,  ::cpp2::Struct7* obj) {
  return obj->read(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct7>::serializedSize(Protocol const* proto,  ::cpp2::Struct7 const* obj) {
  return obj->serializedSize(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct7>::serializedSizeZC(Protocol const* proto,  ::cpp2::Struct7 const* obj) {
  return obj->serializedSizeZC(proto);
}

}} // apache::thrift
namespace cpp2 {
class Struct8 : private apache::thrift::detail::st::ComparisonOperators<Struct8> {
 public:

  Struct8() {}
  // FragileConstructor for use in initialization lists only

  Struct8(apache::thrift::FragileConstructor) {}

  Struct8(Struct8&&) = default;

  Struct8(const Struct8&) = default;

  Struct8& operator=(Struct8&&) = default;

  Struct8& operator=(const Struct8&) = default;
  void __clear();

  virtual ~Struct8() {}

  bool operator==(const Struct8& /* rhs */) const;

  bool operator < (const Struct8& rhs) const {
    (void)rhs;
    return false;
  }

  template <class Protocol_>
  uint32_t read(Protocol_* iprot);
  template <class Protocol_>
  uint32_t serializedSize(Protocol_ const* prot_) const;
  template <class Protocol_>
  uint32_t serializedSizeZC(Protocol_ const* prot_) const;
  template <class Protocol_>
  uint32_t write(Protocol_* prot_) const;

 private:
  static void translateFieldName(FOLLY_MAYBE_UNUSED folly::StringPiece _fname, FOLLY_MAYBE_UNUSED int16_t& fid, FOLLY_MAYBE_UNUSED apache::thrift::protocol::TType& _ftype);
};

void swap(Struct8& a, Struct8& b);
extern template uint32_t Struct8::read<>(apache::thrift::BinaryProtocolReader*);
extern template uint32_t Struct8::write<>(apache::thrift::BinaryProtocolWriter*) const;
extern template uint32_t Struct8::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const;
extern template uint32_t Struct8::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const;
extern template uint32_t Struct8::read<>(apache::thrift::CompactProtocolReader*);
extern template uint32_t Struct8::write<>(apache::thrift::CompactProtocolWriter*) const;
extern template uint32_t Struct8::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const;
extern template uint32_t Struct8::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const;

} // cpp2
namespace apache { namespace thrift {

template <> inline void Cpp2Ops< ::cpp2::Struct8>::clear( ::cpp2::Struct8* obj) {
  return obj->__clear();
}

template <> inline constexpr apache::thrift::protocol::TType Cpp2Ops< ::cpp2::Struct8>::thriftType() {
  return apache::thrift::protocol::T_STRUCT;
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct8>::write(Protocol* proto,  ::cpp2::Struct8 const* obj) {
  return obj->write(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct8>::read(Protocol* proto,  ::cpp2::Struct8* obj) {
  return obj->read(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct8>::serializedSize(Protocol const* proto,  ::cpp2::Struct8 const* obj) {
  return obj->serializedSize(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct8>::serializedSizeZC(Protocol const* proto,  ::cpp2::Struct8 const* obj) {
  return obj->serializedSizeZC(proto);
}

}} // apache::thrift
namespace cpp2 {
class Struct9 : private apache::thrift::detail::st::ComparisonOperators<Struct9> {
 public:

  Struct9() {}
  // FragileConstructor for use in initialization lists only

  Struct9(apache::thrift::FragileConstructor) {}

  Struct9(Struct9&&) = default;

  Struct9(const Struct9&) = default;

  Struct9& operator=(Struct9&&) = default;

  Struct9& operator=(const Struct9&) = default;
  void __clear();

  virtual ~Struct9() {}

  bool operator==(const Struct9& /* rhs */) const;

  bool operator < (const Struct9& rhs) const {
    (void)rhs;
    return false;
  }

  template <class Protocol_>
  uint32_t read(Protocol_* iprot);
  template <class Protocol_>
  uint32_t serializedSize(Protocol_ const* prot_) const;
  template <class Protocol_>
  uint32_t serializedSizeZC(Protocol_ const* prot_) const;
  template <class Protocol_>
  uint32_t write(Protocol_* prot_) const;

 private:
  static void translateFieldName(FOLLY_MAYBE_UNUSED folly::StringPiece _fname, FOLLY_MAYBE_UNUSED int16_t& fid, FOLLY_MAYBE_UNUSED apache::thrift::protocol::TType& _ftype);
};

void swap(Struct9& a, Struct9& b);
extern template uint32_t Struct9::read<>(apache::thrift::BinaryProtocolReader*);
extern template uint32_t Struct9::write<>(apache::thrift::BinaryProtocolWriter*) const;
extern template uint32_t Struct9::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const;
extern template uint32_t Struct9::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const;
extern template uint32_t Struct9::read<>(apache::thrift::CompactProtocolReader*);
extern template uint32_t Struct9::write<>(apache::thrift::CompactProtocolWriter*) const;
extern template uint32_t Struct9::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const;
extern template uint32_t Struct9::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const;

} // cpp2
namespace apache { namespace thrift {

template <> inline void Cpp2Ops< ::cpp2::Struct9>::clear( ::cpp2::Struct9* obj) {
  return obj->__clear();
}

template <> inline constexpr apache::thrift::protocol::TType Cpp2Ops< ::cpp2::Struct9>::thriftType() {
  return apache::thrift::protocol::T_STRUCT;
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct9>::write(Protocol* proto,  ::cpp2::Struct9 const* obj) {
  return obj->write(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct9>::read(Protocol* proto,  ::cpp2::Struct9* obj) {
  return obj->read(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct9>::serializedSize(Protocol const* proto,  ::cpp2::Struct9 const* obj) {
  return obj->serializedSize(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct9>::serializedSizeZC(Protocol const* proto,  ::cpp2::Struct9 const* obj) {
  return obj->serializedSizeZC(proto);
}

}} // apache::thrift
namespace cpp2 {
class Struct10 : private apache::thrift::detail::st::ComparisonOperators<Struct10> {
 public:

  Struct10() :
      field1(0) {}
  // FragileConstructor for use in initialization lists only

  Struct10(apache::thrift::FragileConstructor, double field1__arg, std::map<int8_t, int64_t> field2__arg) :
      field1(std::move(field1__arg)),
      field2(std::move(field2__arg)) {
    __isset.field1 = true;
    __isset.field2 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct10(::apache::thrift::detail::argument_wrapper<1, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct10(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field1 = arg.move();
    __isset.field1 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct10(::apache::thrift::detail::argument_wrapper<2, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct10(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field2 = arg.move();
    __isset.field2 = true;
  }

  Struct10(Struct10&&) = default;

  Struct10(const Struct10&) = default;

  Struct10& operator=(Struct10&&) = default;

  Struct10& operator=(const Struct10&) = default;
  void __clear();

  virtual ~Struct10() {}

  double field1;
  std::map<int8_t, int64_t> field2;

  struct __isset {
    void __clear() {
      field1 = false;
      field2 = false;
    }

    bool field1 = false;
    bool field2 = false;
  } __isset;
  bool operator==(const Struct10& rhs) const;

  bool operator < (const Struct10& rhs) const {
    if (!(field1 == rhs.field1)) {
      return field1 < rhs.field1;
    }
    if (!(field2 == rhs.field2)) {
      return field2 < rhs.field2;
    }
    (void)rhs;
    return false;
  }

  double get_field1() const {
    return field1;
  }

  double& set_field1(double field1_) {
    field1 = field1_;
    __isset.field1 = true;
    return field1;
  }
  const std::map<int8_t, int64_t>& get_field2() const&;
  std::map<int8_t, int64_t> get_field2() &&;

  template <typename T_Struct10_field2_struct_setter>
  std::map<int8_t, int64_t>& set_field2(T_Struct10_field2_struct_setter&& field2_) {
    field2 = std::forward<T_Struct10_field2_struct_setter>(field2_);
    __isset.field2 = true;
    return field2;
  }

  template <class Protocol_>
  uint32_t read(Protocol_* iprot);
  template <class Protocol_>
  uint32_t serializedSize(Protocol_ const* prot_) const;
  template <class Protocol_>
  uint32_t serializedSizeZC(Protocol_ const* prot_) const;
  template <class Protocol_>
  uint32_t write(Protocol_* prot_) const;

 private:
  static void translateFieldName(FOLLY_MAYBE_UNUSED folly::StringPiece _fname, FOLLY_MAYBE_UNUSED int16_t& fid, FOLLY_MAYBE_UNUSED apache::thrift::protocol::TType& _ftype);
};

void swap(Struct10& a, Struct10& b);
extern template uint32_t Struct10::read<>(apache::thrift::BinaryProtocolReader*);
extern template uint32_t Struct10::write<>(apache::thrift::BinaryProtocolWriter*) const;
extern template uint32_t Struct10::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const;
extern template uint32_t Struct10::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const;
extern template uint32_t Struct10::read<>(apache::thrift::CompactProtocolReader*);
extern template uint32_t Struct10::write<>(apache::thrift::CompactProtocolWriter*) const;
extern template uint32_t Struct10::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const;
extern template uint32_t Struct10::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const;

} // cpp2
namespace apache { namespace thrift {

template <> inline void Cpp2Ops< ::cpp2::Struct10>::clear( ::cpp2::Struct10* obj) {
  return obj->__clear();
}

template <> inline constexpr apache::thrift::protocol::TType Cpp2Ops< ::cpp2::Struct10>::thriftType() {
  return apache::thrift::protocol::T_STRUCT;
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct10>::write(Protocol* proto,  ::cpp2::Struct10 const* obj) {
  return obj->write(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct10>::read(Protocol* proto,  ::cpp2::Struct10* obj) {
  return obj->read(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct10>::serializedSize(Protocol const* proto,  ::cpp2::Struct10 const* obj) {
  return obj->serializedSize(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct10>::serializedSizeZC(Protocol const* proto,  ::cpp2::Struct10 const* obj) {
  return obj->serializedSizeZC(proto);
}

}} // apache::thrift
namespace cpp2 {
class Struct11 : private apache::thrift::detail::st::ComparisonOperators<Struct11> {
 public:

  Struct11() :
      field1(0),
      field4(0) {}
  // FragileConstructor for use in initialization lists only

  Struct11(apache::thrift::FragileConstructor, double field1__arg, std::vector<double> field2__arg, std::string field3__arg, float field4__arg, std::string field5__arg) :
      field1(std::move(field1__arg)),
      field2(std::move(field2__arg)),
      field3(std::move(field3__arg)),
      field4(std::move(field4__arg)),
      field5(std::move(field5__arg)) {
    __isset.field1 = true;
    __isset.field2 = true;
    __isset.field3 = true;
    __isset.field4 = true;
    __isset.field5 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct11(::apache::thrift::detail::argument_wrapper<1, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct11(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field1 = arg.move();
    __isset.field1 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct11(::apache::thrift::detail::argument_wrapper<2, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct11(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field2 = arg.move();
    __isset.field2 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct11(::apache::thrift::detail::argument_wrapper<3, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct11(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field3 = arg.move();
    __isset.field3 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct11(::apache::thrift::detail::argument_wrapper<4, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct11(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field4 = arg.move();
    __isset.field4 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct11(::apache::thrift::detail::argument_wrapper<5, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct11(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field5 = arg.move();
    __isset.field5 = true;
  }

  Struct11(Struct11&&) = default;

  Struct11(const Struct11&) = default;

  Struct11& operator=(Struct11&&) = default;

  Struct11& operator=(const Struct11&) = default;
  void __clear();

  virtual ~Struct11() {}

  double field1;
  std::vector<double> field2;
  std::string field3;
  float field4;
  std::string field5;

  struct __isset {
    void __clear() {
      field1 = false;
      field2 = false;
      field3 = false;
      field4 = false;
      field5 = false;
    }

    bool field1 = false;
    bool field2 = false;
    bool field3 = false;
    bool field4 = false;
    bool field5 = false;
  } __isset;
  bool operator==(const Struct11& rhs) const;

  bool operator < (const Struct11& rhs) const {
    if (!(field1 == rhs.field1)) {
      return field1 < rhs.field1;
    }
    if (!(field2 == rhs.field2)) {
      return field2 < rhs.field2;
    }
    if (!(field3 == rhs.field3)) {
      return field3 < rhs.field3;
    }
    if (!(field4 == rhs.field4)) {
      return field4 < rhs.field4;
    }
    if (!(field5 == rhs.field5)) {
      return field5 < rhs.field5;
    }
    (void)rhs;
    return false;
  }

  double get_field1() const {
    return field1;
  }

  double& set_field1(double field1_) {
    field1 = field1_;
    __isset.field1 = true;
    return field1;
  }
  const std::vector<double>& get_field2() const&;
  std::vector<double> get_field2() &&;

  template <typename T_Struct11_field2_struct_setter>
  std::vector<double>& set_field2(T_Struct11_field2_struct_setter&& field2_) {
    field2 = std::forward<T_Struct11_field2_struct_setter>(field2_);
    __isset.field2 = true;
    return field2;
  }

  const std::string& get_field3() const& {
    return field3;
  }

  std::string get_field3() && {
    return std::move(field3);
  }

  template <typename T_Struct11_field3_struct_setter>
  std::string& set_field3(T_Struct11_field3_struct_setter&& field3_) {
    field3 = std::forward<T_Struct11_field3_struct_setter>(field3_);
    __isset.field3 = true;
    return field3;
  }

  float get_field4() const {
    return field4;
  }

  float& set_field4(float field4_) {
    field4 = field4_;
    __isset.field4 = true;
    return field4;
  }

  const std::string& get_field5() const& {
    return field5;
  }

  std::string get_field5() && {
    return std::move(field5);
  }

  template <typename T_Struct11_field5_struct_setter>
  std::string& set_field5(T_Struct11_field5_struct_setter&& field5_) {
    field5 = std::forward<T_Struct11_field5_struct_setter>(field5_);
    __isset.field5 = true;
    return field5;
  }

  template <class Protocol_>
  uint32_t read(Protocol_* iprot);
  template <class Protocol_>
  uint32_t serializedSize(Protocol_ const* prot_) const;
  template <class Protocol_>
  uint32_t serializedSizeZC(Protocol_ const* prot_) const;
  template <class Protocol_>
  uint32_t write(Protocol_* prot_) const;

 private:
  static void translateFieldName(FOLLY_MAYBE_UNUSED folly::StringPiece _fname, FOLLY_MAYBE_UNUSED int16_t& fid, FOLLY_MAYBE_UNUSED apache::thrift::protocol::TType& _ftype);
};

void swap(Struct11& a, Struct11& b);
extern template uint32_t Struct11::read<>(apache::thrift::BinaryProtocolReader*);
extern template uint32_t Struct11::write<>(apache::thrift::BinaryProtocolWriter*) const;
extern template uint32_t Struct11::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const;
extern template uint32_t Struct11::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const;
extern template uint32_t Struct11::read<>(apache::thrift::CompactProtocolReader*);
extern template uint32_t Struct11::write<>(apache::thrift::CompactProtocolWriter*) const;
extern template uint32_t Struct11::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const;
extern template uint32_t Struct11::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const;

} // cpp2
namespace apache { namespace thrift {

template <> inline void Cpp2Ops< ::cpp2::Struct11>::clear( ::cpp2::Struct11* obj) {
  return obj->__clear();
}

template <> inline constexpr apache::thrift::protocol::TType Cpp2Ops< ::cpp2::Struct11>::thriftType() {
  return apache::thrift::protocol::T_STRUCT;
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct11>::write(Protocol* proto,  ::cpp2::Struct11 const* obj) {
  return obj->write(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct11>::read(Protocol* proto,  ::cpp2::Struct11* obj) {
  return obj->read(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct11>::serializedSize(Protocol const* proto,  ::cpp2::Struct11 const* obj) {
  return obj->serializedSize(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct11>::serializedSizeZC(Protocol const* proto,  ::cpp2::Struct11 const* obj) {
  return obj->serializedSizeZC(proto);
}

}} // apache::thrift
namespace cpp2 {
class Struct12 : private apache::thrift::detail::st::ComparisonOperators<Struct12> {
 public:

  Struct12() :
      field1(0),
      field2(0),
      field5(0),
      field6(0),
      field7(0),
      field8(0),
      field9(0),
      field10(0) {}
  // FragileConstructor for use in initialization lists only

  Struct12(apache::thrift::FragileConstructor, int8_t field1__arg, int64_t field2__arg,  ::cpp2::Struct1 field3__arg, std::set<float> field4__arg, double field5__arg, int16_t field6__arg, bool field7__arg, int64_t field8__arg, double field9__arg, int8_t field10__arg,  ::cpp2::Struct4 field11__arg) :
      field1(std::move(field1__arg)),
      field2(std::move(field2__arg)),
      field3(std::move(field3__arg)),
      field4(std::move(field4__arg)),
      field5(std::move(field5__arg)),
      field6(std::move(field6__arg)),
      field7(std::move(field7__arg)),
      field8(std::move(field8__arg)),
      field9(std::move(field9__arg)),
      field10(std::move(field10__arg)),
      field11(std::move(field11__arg)) {
    __isset.field1 = true;
    __isset.field2 = true;
    __isset.field3 = true;
    __isset.field4 = true;
    __isset.field5 = true;
    __isset.field6 = true;
    __isset.field7 = true;
    __isset.field8 = true;
    __isset.field9 = true;
    __isset.field10 = true;
    __isset.field11 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct12(::apache::thrift::detail::argument_wrapper<1, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct12(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field1 = arg.move();
    __isset.field1 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct12(::apache::thrift::detail::argument_wrapper<2, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct12(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field2 = arg.move();
    __isset.field2 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct12(::apache::thrift::detail::argument_wrapper<3, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct12(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field3 = arg.move();
    __isset.field3 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct12(::apache::thrift::detail::argument_wrapper<4, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct12(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field4 = arg.move();
    __isset.field4 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct12(::apache::thrift::detail::argument_wrapper<5, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct12(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field5 = arg.move();
    __isset.field5 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct12(::apache::thrift::detail::argument_wrapper<6, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct12(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field6 = arg.move();
    __isset.field6 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct12(::apache::thrift::detail::argument_wrapper<7, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct12(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field7 = arg.move();
    __isset.field7 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct12(::apache::thrift::detail::argument_wrapper<8, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct12(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field8 = arg.move();
    __isset.field8 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct12(::apache::thrift::detail::argument_wrapper<9, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct12(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field9 = arg.move();
    __isset.field9 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct12(::apache::thrift::detail::argument_wrapper<10, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct12(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field10 = arg.move();
    __isset.field10 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct12(::apache::thrift::detail::argument_wrapper<11, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct12(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field11 = arg.move();
    __isset.field11 = true;
  }

  Struct12(Struct12&&) = default;

  Struct12(const Struct12&) = default;

  Struct12& operator=(Struct12&&) = default;

  Struct12& operator=(const Struct12&) = default;
  void __clear();

  virtual ~Struct12() {}

  int8_t field1;
  int64_t field2;
   ::cpp2::Struct1 field3;
  std::set<float> field4;
  double field5;
  int16_t field6;
  bool field7;
  int64_t field8;
  double field9;
  int8_t field10;
   ::cpp2::Struct4 field11;

  struct __isset {
    void __clear() {
      field1 = false;
      field2 = false;
      field3 = false;
      field4 = false;
      field5 = false;
      field6 = false;
      field7 = false;
      field8 = false;
      field9 = false;
      field10 = false;
      field11 = false;
    }

    bool field1 = false;
    bool field2 = false;
    bool field3 = false;
    bool field4 = false;
    bool field5 = false;
    bool field6 = false;
    bool field7 = false;
    bool field8 = false;
    bool field9 = false;
    bool field10 = false;
    bool field11 = false;
  } __isset;
  bool operator==(const Struct12& rhs) const;

  bool operator < (const Struct12& rhs) const {
    if (!(field1 == rhs.field1)) {
      return field1 < rhs.field1;
    }
    if (!(field2 == rhs.field2)) {
      return field2 < rhs.field2;
    }
    if (!(field3 == rhs.field3)) {
      return field3 < rhs.field3;
    }
    if (!(field4 == rhs.field4)) {
      return field4 < rhs.field4;
    }
    if (!(field5 == rhs.field5)) {
      return field5 < rhs.field5;
    }
    if (!(field6 == rhs.field6)) {
      return field6 < rhs.field6;
    }
    if (!(field7 == rhs.field7)) {
      return field7 < rhs.field7;
    }
    if (!(field8 == rhs.field8)) {
      return field8 < rhs.field8;
    }
    if (!(field9 == rhs.field9)) {
      return field9 < rhs.field9;
    }
    if (!(field10 == rhs.field10)) {
      return field10 < rhs.field10;
    }
    if (!(field11 == rhs.field11)) {
      return field11 < rhs.field11;
    }
    (void)rhs;
    return false;
  }

  int8_t get_field1() const {
    return field1;
  }

  int8_t& set_field1(int8_t field1_) {
    field1 = field1_;
    __isset.field1 = true;
    return field1;
  }

  int64_t get_field2() const {
    return field2;
  }

  int64_t& set_field2(int64_t field2_) {
    field2 = field2_;
    __isset.field2 = true;
    return field2;
  }
  const  ::cpp2::Struct1& get_field3() const&;
   ::cpp2::Struct1 get_field3() &&;

  template <typename T_Struct12_field3_struct_setter>
   ::cpp2::Struct1& set_field3(T_Struct12_field3_struct_setter&& field3_) {
    field3 = std::forward<T_Struct12_field3_struct_setter>(field3_);
    __isset.field3 = true;
    return field3;
  }
  const std::set<float>& get_field4() const&;
  std::set<float> get_field4() &&;

  template <typename T_Struct12_field4_struct_setter>
  std::set<float>& set_field4(T_Struct12_field4_struct_setter&& field4_) {
    field4 = std::forward<T_Struct12_field4_struct_setter>(field4_);
    __isset.field4 = true;
    return field4;
  }

  double get_field5() const {
    return field5;
  }

  double& set_field5(double field5_) {
    field5 = field5_;
    __isset.field5 = true;
    return field5;
  }

  int16_t get_field6() const {
    return field6;
  }

  int16_t& set_field6(int16_t field6_) {
    field6 = field6_;
    __isset.field6 = true;
    return field6;
  }

  bool get_field7() const {
    return field7;
  }

  bool& set_field7(bool field7_) {
    field7 = field7_;
    __isset.field7 = true;
    return field7;
  }

  int64_t get_field8() const {
    return field8;
  }

  int64_t& set_field8(int64_t field8_) {
    field8 = field8_;
    __isset.field8 = true;
    return field8;
  }

  double get_field9() const {
    return field9;
  }

  double& set_field9(double field9_) {
    field9 = field9_;
    __isset.field9 = true;
    return field9;
  }

  int8_t get_field10() const {
    return field10;
  }

  int8_t& set_field10(int8_t field10_) {
    field10 = field10_;
    __isset.field10 = true;
    return field10;
  }
  const  ::cpp2::Struct4& get_field11() const&;
   ::cpp2::Struct4 get_field11() &&;

  template <typename T_Struct12_field11_struct_setter>
   ::cpp2::Struct4& set_field11(T_Struct12_field11_struct_setter&& field11_) {
    field11 = std::forward<T_Struct12_field11_struct_setter>(field11_);
    __isset.field11 = true;
    return field11;
  }

  template <class Protocol_>
  uint32_t read(Protocol_* iprot);
  template <class Protocol_>
  uint32_t serializedSize(Protocol_ const* prot_) const;
  template <class Protocol_>
  uint32_t serializedSizeZC(Protocol_ const* prot_) const;
  template <class Protocol_>
  uint32_t write(Protocol_* prot_) const;

 private:
  static void translateFieldName(FOLLY_MAYBE_UNUSED folly::StringPiece _fname, FOLLY_MAYBE_UNUSED int16_t& fid, FOLLY_MAYBE_UNUSED apache::thrift::protocol::TType& _ftype);
};

void swap(Struct12& a, Struct12& b);
extern template uint32_t Struct12::read<>(apache::thrift::BinaryProtocolReader*);
extern template uint32_t Struct12::write<>(apache::thrift::BinaryProtocolWriter*) const;
extern template uint32_t Struct12::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const;
extern template uint32_t Struct12::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const;
extern template uint32_t Struct12::read<>(apache::thrift::CompactProtocolReader*);
extern template uint32_t Struct12::write<>(apache::thrift::CompactProtocolWriter*) const;
extern template uint32_t Struct12::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const;
extern template uint32_t Struct12::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const;

} // cpp2
namespace apache { namespace thrift {

template <> inline void Cpp2Ops< ::cpp2::Struct12>::clear( ::cpp2::Struct12* obj) {
  return obj->__clear();
}

template <> inline constexpr apache::thrift::protocol::TType Cpp2Ops< ::cpp2::Struct12>::thriftType() {
  return apache::thrift::protocol::T_STRUCT;
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct12>::write(Protocol* proto,  ::cpp2::Struct12 const* obj) {
  return obj->write(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct12>::read(Protocol* proto,  ::cpp2::Struct12* obj) {
  return obj->read(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct12>::serializedSize(Protocol const* proto,  ::cpp2::Struct12 const* obj) {
  return obj->serializedSize(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct12>::serializedSizeZC(Protocol const* proto,  ::cpp2::Struct12 const* obj) {
  return obj->serializedSizeZC(proto);
}

}} // apache::thrift
namespace cpp2 {
class Struct13 : private apache::thrift::detail::st::ComparisonOperators<Struct13> {
 public:

  Struct13() {}
  // FragileConstructor for use in initialization lists only

  Struct13(apache::thrift::FragileConstructor,  ::cpp2::Struct0 field1__arg) :
      field1(std::move(field1__arg)) {
    __isset.field1 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct13(::apache::thrift::detail::argument_wrapper<1, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct13(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field1 = arg.move();
    __isset.field1 = true;
  }

  Struct13(Struct13&&) = default;

  Struct13(const Struct13&) = default;

  Struct13& operator=(Struct13&&) = default;

  Struct13& operator=(const Struct13&) = default;
  void __clear();

  virtual ~Struct13() {}

   ::cpp2::Struct0 field1;

  struct __isset {
    void __clear() {
      field1 = false;
    }

    bool field1 = false;
  } __isset;
  bool operator==(const Struct13& rhs) const;

  bool operator < (const Struct13& rhs) const {
    if (!(field1 == rhs.field1)) {
      return field1 < rhs.field1;
    }
    (void)rhs;
    return false;
  }
  const  ::cpp2::Struct0& get_field1() const&;
   ::cpp2::Struct0 get_field1() &&;

  template <typename T_Struct13_field1_struct_setter>
   ::cpp2::Struct0& set_field1(T_Struct13_field1_struct_setter&& field1_) {
    field1 = std::forward<T_Struct13_field1_struct_setter>(field1_);
    __isset.field1 = true;
    return field1;
  }

  template <class Protocol_>
  uint32_t read(Protocol_* iprot);
  template <class Protocol_>
  uint32_t serializedSize(Protocol_ const* prot_) const;
  template <class Protocol_>
  uint32_t serializedSizeZC(Protocol_ const* prot_) const;
  template <class Protocol_>
  uint32_t write(Protocol_* prot_) const;

 private:
  static void translateFieldName(FOLLY_MAYBE_UNUSED folly::StringPiece _fname, FOLLY_MAYBE_UNUSED int16_t& fid, FOLLY_MAYBE_UNUSED apache::thrift::protocol::TType& _ftype);
};

void swap(Struct13& a, Struct13& b);
extern template uint32_t Struct13::read<>(apache::thrift::BinaryProtocolReader*);
extern template uint32_t Struct13::write<>(apache::thrift::BinaryProtocolWriter*) const;
extern template uint32_t Struct13::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const;
extern template uint32_t Struct13::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const;
extern template uint32_t Struct13::read<>(apache::thrift::CompactProtocolReader*);
extern template uint32_t Struct13::write<>(apache::thrift::CompactProtocolWriter*) const;
extern template uint32_t Struct13::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const;
extern template uint32_t Struct13::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const;

} // cpp2
namespace apache { namespace thrift {

template <> inline void Cpp2Ops< ::cpp2::Struct13>::clear( ::cpp2::Struct13* obj) {
  return obj->__clear();
}

template <> inline constexpr apache::thrift::protocol::TType Cpp2Ops< ::cpp2::Struct13>::thriftType() {
  return apache::thrift::protocol::T_STRUCT;
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct13>::write(Protocol* proto,  ::cpp2::Struct13 const* obj) {
  return obj->write(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct13>::read(Protocol* proto,  ::cpp2::Struct13* obj) {
  return obj->read(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct13>::serializedSize(Protocol const* proto,  ::cpp2::Struct13 const* obj) {
  return obj->serializedSize(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct13>::serializedSizeZC(Protocol const* proto,  ::cpp2::Struct13 const* obj) {
  return obj->serializedSizeZC(proto);
}

}} // apache::thrift
namespace cpp2 {
class Struct14 : private apache::thrift::detail::st::ComparisonOperators<Struct14> {
 public:

  Struct14() {}
  // FragileConstructor for use in initialization lists only

  Struct14(apache::thrift::FragileConstructor, std::string field1__arg, std::set<int16_t> field2__arg, std::vector< ::cpp2::Struct8> field3__arg, std::set<int64_t> field4__arg, std::string field5__arg,  ::cpp2::Struct7 field6__arg) :
      field1(std::move(field1__arg)),
      field2(std::move(field2__arg)),
      field3(std::move(field3__arg)),
      field4(std::move(field4__arg)),
      field5(std::move(field5__arg)),
      field6(std::move(field6__arg)) {
    __isset.field1 = true;
    __isset.field2 = true;
    __isset.field3 = true;
    __isset.field4 = true;
    __isset.field5 = true;
    __isset.field6 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct14(::apache::thrift::detail::argument_wrapper<1, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct14(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field1 = arg.move();
    __isset.field1 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct14(::apache::thrift::detail::argument_wrapper<2, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct14(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field2 = arg.move();
    __isset.field2 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct14(::apache::thrift::detail::argument_wrapper<3, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct14(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field3 = arg.move();
    __isset.field3 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct14(::apache::thrift::detail::argument_wrapper<4, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct14(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field4 = arg.move();
    __isset.field4 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct14(::apache::thrift::detail::argument_wrapper<5, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct14(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field5 = arg.move();
    __isset.field5 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct14(::apache::thrift::detail::argument_wrapper<6, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct14(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field6 = arg.move();
    __isset.field6 = true;
  }

  Struct14(Struct14&&) = default;

  Struct14(const Struct14&) = default;

  Struct14& operator=(Struct14&&) = default;

  Struct14& operator=(const Struct14&) = default;
  void __clear();

  virtual ~Struct14() {}

  std::string field1;
  std::set<int16_t> field2;
  std::vector< ::cpp2::Struct8> field3;
  std::set<int64_t> field4;
  std::string field5;
   ::cpp2::Struct7 field6;

  struct __isset {
    void __clear() {
      field1 = false;
      field2 = false;
      field3 = false;
      field4 = false;
      field5 = false;
      field6 = false;
    }

    bool field1 = false;
    bool field2 = false;
    bool field3 = false;
    bool field4 = false;
    bool field5 = false;
    bool field6 = false;
  } __isset;
  bool operator==(const Struct14& rhs) const;

  bool operator < (const Struct14& rhs) const {
    if (!(field1 == rhs.field1)) {
      return field1 < rhs.field1;
    }
    if (!(field2 == rhs.field2)) {
      return field2 < rhs.field2;
    }
    if (!(field3 == rhs.field3)) {
      return field3 < rhs.field3;
    }
    if (!(field4 == rhs.field4)) {
      return field4 < rhs.field4;
    }
    if (!(field5 == rhs.field5)) {
      return field5 < rhs.field5;
    }
    if (!(field6 == rhs.field6)) {
      return field6 < rhs.field6;
    }
    (void)rhs;
    return false;
  }

  const std::string& get_field1() const& {
    return field1;
  }

  std::string get_field1() && {
    return std::move(field1);
  }

  template <typename T_Struct14_field1_struct_setter>
  std::string& set_field1(T_Struct14_field1_struct_setter&& field1_) {
    field1 = std::forward<T_Struct14_field1_struct_setter>(field1_);
    __isset.field1 = true;
    return field1;
  }
  const std::set<int16_t>& get_field2() const&;
  std::set<int16_t> get_field2() &&;

  template <typename T_Struct14_field2_struct_setter>
  std::set<int16_t>& set_field2(T_Struct14_field2_struct_setter&& field2_) {
    field2 = std::forward<T_Struct14_field2_struct_setter>(field2_);
    __isset.field2 = true;
    return field2;
  }
  const std::vector< ::cpp2::Struct8>& get_field3() const&;
  std::vector< ::cpp2::Struct8> get_field3() &&;

  template <typename T_Struct14_field3_struct_setter>
  std::vector< ::cpp2::Struct8>& set_field3(T_Struct14_field3_struct_setter&& field3_) {
    field3 = std::forward<T_Struct14_field3_struct_setter>(field3_);
    __isset.field3 = true;
    return field3;
  }
  const std::set<int64_t>& get_field4() const&;
  std::set<int64_t> get_field4() &&;

  template <typename T_Struct14_field4_struct_setter>
  std::set<int64_t>& set_field4(T_Struct14_field4_struct_setter&& field4_) {
    field4 = std::forward<T_Struct14_field4_struct_setter>(field4_);
    __isset.field4 = true;
    return field4;
  }

  const std::string& get_field5() const& {
    return field5;
  }

  std::string get_field5() && {
    return std::move(field5);
  }

  template <typename T_Struct14_field5_struct_setter>
  std::string& set_field5(T_Struct14_field5_struct_setter&& field5_) {
    field5 = std::forward<T_Struct14_field5_struct_setter>(field5_);
    __isset.field5 = true;
    return field5;
  }
  const  ::cpp2::Struct7& get_field6() const&;
   ::cpp2::Struct7 get_field6() &&;

  template <typename T_Struct14_field6_struct_setter>
   ::cpp2::Struct7& set_field6(T_Struct14_field6_struct_setter&& field6_) {
    field6 = std::forward<T_Struct14_field6_struct_setter>(field6_);
    __isset.field6 = true;
    return field6;
  }

  template <class Protocol_>
  uint32_t read(Protocol_* iprot);
  template <class Protocol_>
  uint32_t serializedSize(Protocol_ const* prot_) const;
  template <class Protocol_>
  uint32_t serializedSizeZC(Protocol_ const* prot_) const;
  template <class Protocol_>
  uint32_t write(Protocol_* prot_) const;

 private:
  static void translateFieldName(FOLLY_MAYBE_UNUSED folly::StringPiece _fname, FOLLY_MAYBE_UNUSED int16_t& fid, FOLLY_MAYBE_UNUSED apache::thrift::protocol::TType& _ftype);
};

void swap(Struct14& a, Struct14& b);
extern template uint32_t Struct14::read<>(apache::thrift::BinaryProtocolReader*);
extern template uint32_t Struct14::write<>(apache::thrift::BinaryProtocolWriter*) const;
extern template uint32_t Struct14::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const;
extern template uint32_t Struct14::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const;
extern template uint32_t Struct14::read<>(apache::thrift::CompactProtocolReader*);
extern template uint32_t Struct14::write<>(apache::thrift::CompactProtocolWriter*) const;
extern template uint32_t Struct14::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const;
extern template uint32_t Struct14::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const;

} // cpp2
namespace apache { namespace thrift {

template <> inline void Cpp2Ops< ::cpp2::Struct14>::clear( ::cpp2::Struct14* obj) {
  return obj->__clear();
}

template <> inline constexpr apache::thrift::protocol::TType Cpp2Ops< ::cpp2::Struct14>::thriftType() {
  return apache::thrift::protocol::T_STRUCT;
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct14>::write(Protocol* proto,  ::cpp2::Struct14 const* obj) {
  return obj->write(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct14>::read(Protocol* proto,  ::cpp2::Struct14* obj) {
  return obj->read(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct14>::serializedSize(Protocol const* proto,  ::cpp2::Struct14 const* obj) {
  return obj->serializedSize(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct14>::serializedSizeZC(Protocol const* proto,  ::cpp2::Struct14 const* obj) {
  return obj->serializedSizeZC(proto);
}

}} // apache::thrift
namespace cpp2 {
class Struct15 : private apache::thrift::detail::st::ComparisonOperators<Struct15> {
 public:

  Struct15() {}
  // FragileConstructor for use in initialization lists only

  Struct15(apache::thrift::FragileConstructor) {}

  Struct15(Struct15&&) = default;

  Struct15(const Struct15&) = default;

  Struct15& operator=(Struct15&&) = default;

  Struct15& operator=(const Struct15&) = default;
  void __clear();

  virtual ~Struct15() {}

  bool operator==(const Struct15& /* rhs */) const;

  bool operator < (const Struct15& rhs) const {
    (void)rhs;
    return false;
  }

  template <class Protocol_>
  uint32_t read(Protocol_* iprot);
  template <class Protocol_>
  uint32_t serializedSize(Protocol_ const* prot_) const;
  template <class Protocol_>
  uint32_t serializedSizeZC(Protocol_ const* prot_) const;
  template <class Protocol_>
  uint32_t write(Protocol_* prot_) const;

 private:
  static void translateFieldName(FOLLY_MAYBE_UNUSED folly::StringPiece _fname, FOLLY_MAYBE_UNUSED int16_t& fid, FOLLY_MAYBE_UNUSED apache::thrift::protocol::TType& _ftype);
};

void swap(Struct15& a, Struct15& b);
extern template uint32_t Struct15::read<>(apache::thrift::BinaryProtocolReader*);
extern template uint32_t Struct15::write<>(apache::thrift::BinaryProtocolWriter*) const;
extern template uint32_t Struct15::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const;
extern template uint32_t Struct15::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const;
extern template uint32_t Struct15::read<>(apache::thrift::CompactProtocolReader*);
extern template uint32_t Struct15::write<>(apache::thrift::CompactProtocolWriter*) const;
extern template uint32_t Struct15::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const;
extern template uint32_t Struct15::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const;

} // cpp2
namespace apache { namespace thrift {

template <> inline void Cpp2Ops< ::cpp2::Struct15>::clear( ::cpp2::Struct15* obj) {
  return obj->__clear();
}

template <> inline constexpr apache::thrift::protocol::TType Cpp2Ops< ::cpp2::Struct15>::thriftType() {
  return apache::thrift::protocol::T_STRUCT;
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct15>::write(Protocol* proto,  ::cpp2::Struct15 const* obj) {
  return obj->write(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct15>::read(Protocol* proto,  ::cpp2::Struct15* obj) {
  return obj->read(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct15>::serializedSize(Protocol const* proto,  ::cpp2::Struct15 const* obj) {
  return obj->serializedSize(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct15>::serializedSizeZC(Protocol const* proto,  ::cpp2::Struct15 const* obj) {
  return obj->serializedSizeZC(proto);
}

}} // apache::thrift
namespace cpp2 {
class Struct16 : private apache::thrift::detail::st::ComparisonOperators<Struct16> {
 public:

  Struct16() :
      field1(0) {}
  // FragileConstructor for use in initialization lists only

  Struct16(apache::thrift::FragileConstructor, float field1__arg) :
      field1(std::move(field1__arg)) {
    __isset.field1 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct16(::apache::thrift::detail::argument_wrapper<1, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct16(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field1 = arg.move();
    __isset.field1 = true;
  }

  Struct16(Struct16&&) = default;

  Struct16(const Struct16&) = default;

  Struct16& operator=(Struct16&&) = default;

  Struct16& operator=(const Struct16&) = default;
  void __clear();

  virtual ~Struct16() {}

  float field1;

  struct __isset {
    void __clear() {
      field1 = false;
    }

    bool field1 = false;
  } __isset;
  bool operator==(const Struct16& rhs) const;

  bool operator < (const Struct16& rhs) const {
    if (!(field1 == rhs.field1)) {
      return field1 < rhs.field1;
    }
    (void)rhs;
    return false;
  }

  float get_field1() const {
    return field1;
  }

  float& set_field1(float field1_) {
    field1 = field1_;
    __isset.field1 = true;
    return field1;
  }

  template <class Protocol_>
  uint32_t read(Protocol_* iprot);
  template <class Protocol_>
  uint32_t serializedSize(Protocol_ const* prot_) const;
  template <class Protocol_>
  uint32_t serializedSizeZC(Protocol_ const* prot_) const;
  template <class Protocol_>
  uint32_t write(Protocol_* prot_) const;

 private:
  static void translateFieldName(FOLLY_MAYBE_UNUSED folly::StringPiece _fname, FOLLY_MAYBE_UNUSED int16_t& fid, FOLLY_MAYBE_UNUSED apache::thrift::protocol::TType& _ftype);
};

void swap(Struct16& a, Struct16& b);
extern template uint32_t Struct16::read<>(apache::thrift::BinaryProtocolReader*);
extern template uint32_t Struct16::write<>(apache::thrift::BinaryProtocolWriter*) const;
extern template uint32_t Struct16::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const;
extern template uint32_t Struct16::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const;
extern template uint32_t Struct16::read<>(apache::thrift::CompactProtocolReader*);
extern template uint32_t Struct16::write<>(apache::thrift::CompactProtocolWriter*) const;
extern template uint32_t Struct16::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const;
extern template uint32_t Struct16::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const;

} // cpp2
namespace apache { namespace thrift {

template <> inline void Cpp2Ops< ::cpp2::Struct16>::clear( ::cpp2::Struct16* obj) {
  return obj->__clear();
}

template <> inline constexpr apache::thrift::protocol::TType Cpp2Ops< ::cpp2::Struct16>::thriftType() {
  return apache::thrift::protocol::T_STRUCT;
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct16>::write(Protocol* proto,  ::cpp2::Struct16 const* obj) {
  return obj->write(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct16>::read(Protocol* proto,  ::cpp2::Struct16* obj) {
  return obj->read(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct16>::serializedSize(Protocol const* proto,  ::cpp2::Struct16 const* obj) {
  return obj->serializedSize(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct16>::serializedSizeZC(Protocol const* proto,  ::cpp2::Struct16 const* obj) {
  return obj->serializedSizeZC(proto);
}

}} // apache::thrift
namespace cpp2 {
class Struct17 : private apache::thrift::detail::st::ComparisonOperators<Struct17> {
 public:

  Struct17() :
      field2(0),
      field3(0) {}
  // FragileConstructor for use in initialization lists only

  Struct17(apache::thrift::FragileConstructor, std::map<int8_t, float> field1__arg, int64_t field2__arg, int16_t field3__arg) :
      field1(std::move(field1__arg)),
      field2(std::move(field2__arg)),
      field3(std::move(field3__arg)) {
    __isset.field1 = true;
    __isset.field2 = true;
    __isset.field3 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct17(::apache::thrift::detail::argument_wrapper<1, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct17(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field1 = arg.move();
    __isset.field1 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct17(::apache::thrift::detail::argument_wrapper<2, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct17(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field2 = arg.move();
    __isset.field2 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct17(::apache::thrift::detail::argument_wrapper<3, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct17(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field3 = arg.move();
    __isset.field3 = true;
  }

  Struct17(Struct17&&) = default;

  Struct17(const Struct17&) = default;

  Struct17& operator=(Struct17&&) = default;

  Struct17& operator=(const Struct17&) = default;
  void __clear();

  virtual ~Struct17() {}

  std::map<int8_t, float> field1;
  int64_t field2;
  int16_t field3;

  struct __isset {
    void __clear() {
      field1 = false;
      field2 = false;
      field3 = false;
    }

    bool field1 = false;
    bool field2 = false;
    bool field3 = false;
  } __isset;
  bool operator==(const Struct17& rhs) const;

  bool operator < (const Struct17& rhs) const {
    if (!(field1 == rhs.field1)) {
      return field1 < rhs.field1;
    }
    if (!(field2 == rhs.field2)) {
      return field2 < rhs.field2;
    }
    if (!(field3 == rhs.field3)) {
      return field3 < rhs.field3;
    }
    (void)rhs;
    return false;
  }
  const std::map<int8_t, float>& get_field1() const&;
  std::map<int8_t, float> get_field1() &&;

  template <typename T_Struct17_field1_struct_setter>
  std::map<int8_t, float>& set_field1(T_Struct17_field1_struct_setter&& field1_) {
    field1 = std::forward<T_Struct17_field1_struct_setter>(field1_);
    __isset.field1 = true;
    return field1;
  }

  int64_t get_field2() const {
    return field2;
  }

  int64_t& set_field2(int64_t field2_) {
    field2 = field2_;
    __isset.field2 = true;
    return field2;
  }

  int16_t get_field3() const {
    return field3;
  }

  int16_t& set_field3(int16_t field3_) {
    field3 = field3_;
    __isset.field3 = true;
    return field3;
  }

  template <class Protocol_>
  uint32_t read(Protocol_* iprot);
  template <class Protocol_>
  uint32_t serializedSize(Protocol_ const* prot_) const;
  template <class Protocol_>
  uint32_t serializedSizeZC(Protocol_ const* prot_) const;
  template <class Protocol_>
  uint32_t write(Protocol_* prot_) const;

 private:
  static void translateFieldName(FOLLY_MAYBE_UNUSED folly::StringPiece _fname, FOLLY_MAYBE_UNUSED int16_t& fid, FOLLY_MAYBE_UNUSED apache::thrift::protocol::TType& _ftype);
};

void swap(Struct17& a, Struct17& b);
extern template uint32_t Struct17::read<>(apache::thrift::BinaryProtocolReader*);
extern template uint32_t Struct17::write<>(apache::thrift::BinaryProtocolWriter*) const;
extern template uint32_t Struct17::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const;
extern template uint32_t Struct17::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const;
extern template uint32_t Struct17::read<>(apache::thrift::CompactProtocolReader*);
extern template uint32_t Struct17::write<>(apache::thrift::CompactProtocolWriter*) const;
extern template uint32_t Struct17::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const;
extern template uint32_t Struct17::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const;

} // cpp2
namespace apache { namespace thrift {

template <> inline void Cpp2Ops< ::cpp2::Struct17>::clear( ::cpp2::Struct17* obj) {
  return obj->__clear();
}

template <> inline constexpr apache::thrift::protocol::TType Cpp2Ops< ::cpp2::Struct17>::thriftType() {
  return apache::thrift::protocol::T_STRUCT;
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct17>::write(Protocol* proto,  ::cpp2::Struct17 const* obj) {
  return obj->write(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct17>::read(Protocol* proto,  ::cpp2::Struct17* obj) {
  return obj->read(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct17>::serializedSize(Protocol const* proto,  ::cpp2::Struct17 const* obj) {
  return obj->serializedSize(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct17>::serializedSizeZC(Protocol const* proto,  ::cpp2::Struct17 const* obj) {
  return obj->serializedSizeZC(proto);
}

}} // apache::thrift
namespace cpp2 {
class Struct18 : private apache::thrift::detail::st::ComparisonOperators<Struct18> {
 public:

  Struct18() {}
  // FragileConstructor for use in initialization lists only

  Struct18(apache::thrift::FragileConstructor,  ::cpp2::Struct9 field1__arg) :
      field1(std::move(field1__arg)) {
    __isset.field1 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct18(::apache::thrift::detail::argument_wrapper<1, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct18(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field1 = arg.move();
    __isset.field1 = true;
  }

  Struct18(Struct18&&) = default;

  Struct18(const Struct18&) = default;

  Struct18& operator=(Struct18&&) = default;

  Struct18& operator=(const Struct18&) = default;
  void __clear();

  virtual ~Struct18() {}

   ::cpp2::Struct9 field1;

  struct __isset {
    void __clear() {
      field1 = false;
    }

    bool field1 = false;
  } __isset;
  bool operator==(const Struct18& rhs) const;

  bool operator < (const Struct18& rhs) const {
    if (!(field1 == rhs.field1)) {
      return field1 < rhs.field1;
    }
    (void)rhs;
    return false;
  }
  const  ::cpp2::Struct9& get_field1() const&;
   ::cpp2::Struct9 get_field1() &&;

  template <typename T_Struct18_field1_struct_setter>
   ::cpp2::Struct9& set_field1(T_Struct18_field1_struct_setter&& field1_) {
    field1 = std::forward<T_Struct18_field1_struct_setter>(field1_);
    __isset.field1 = true;
    return field1;
  }

  template <class Protocol_>
  uint32_t read(Protocol_* iprot);
  template <class Protocol_>
  uint32_t serializedSize(Protocol_ const* prot_) const;
  template <class Protocol_>
  uint32_t serializedSizeZC(Protocol_ const* prot_) const;
  template <class Protocol_>
  uint32_t write(Protocol_* prot_) const;

 private:
  static void translateFieldName(FOLLY_MAYBE_UNUSED folly::StringPiece _fname, FOLLY_MAYBE_UNUSED int16_t& fid, FOLLY_MAYBE_UNUSED apache::thrift::protocol::TType& _ftype);
};

void swap(Struct18& a, Struct18& b);
extern template uint32_t Struct18::read<>(apache::thrift::BinaryProtocolReader*);
extern template uint32_t Struct18::write<>(apache::thrift::BinaryProtocolWriter*) const;
extern template uint32_t Struct18::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const;
extern template uint32_t Struct18::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const;
extern template uint32_t Struct18::read<>(apache::thrift::CompactProtocolReader*);
extern template uint32_t Struct18::write<>(apache::thrift::CompactProtocolWriter*) const;
extern template uint32_t Struct18::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const;
extern template uint32_t Struct18::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const;

} // cpp2
namespace apache { namespace thrift {

template <> inline void Cpp2Ops< ::cpp2::Struct18>::clear( ::cpp2::Struct18* obj) {
  return obj->__clear();
}

template <> inline constexpr apache::thrift::protocol::TType Cpp2Ops< ::cpp2::Struct18>::thriftType() {
  return apache::thrift::protocol::T_STRUCT;
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct18>::write(Protocol* proto,  ::cpp2::Struct18 const* obj) {
  return obj->write(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct18>::read(Protocol* proto,  ::cpp2::Struct18* obj) {
  return obj->read(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct18>::serializedSize(Protocol const* proto,  ::cpp2::Struct18 const* obj) {
  return obj->serializedSize(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct18>::serializedSizeZC(Protocol const* proto,  ::cpp2::Struct18 const* obj) {
  return obj->serializedSizeZC(proto);
}

}} // apache::thrift
namespace cpp2 {
class Struct19 : private apache::thrift::detail::st::ComparisonOperators<Struct19> {
 public:

  Struct19() {}
  // FragileConstructor for use in initialization lists only

  Struct19(apache::thrift::FragileConstructor,  ::cpp2::Struct3 field1__arg) :
      field1(std::move(field1__arg)) {
    __isset.field1 = true;
  }
  template <typename T__ThriftWrappedArgument__Ctor, typename... Args__ThriftWrappedArgument__Ctor>
  Struct19(::apache::thrift::detail::argument_wrapper<1, T__ThriftWrappedArgument__Ctor> arg, Args__ThriftWrappedArgument__Ctor&&... args):
    Struct19(std::forward<Args__ThriftWrappedArgument__Ctor>(args)...)
  {
    field1 = arg.move();
    __isset.field1 = true;
  }

  Struct19(Struct19&&) = default;

  Struct19(const Struct19&) = default;

  Struct19& operator=(Struct19&&) = default;

  Struct19& operator=(const Struct19&) = default;
  void __clear();

  virtual ~Struct19() {}

   ::cpp2::Struct3 field1;

  struct __isset {
    void __clear() {
      field1 = false;
    }

    bool field1 = false;
  } __isset;
  bool operator==(const Struct19& rhs) const;

  bool operator < (const Struct19& rhs) const {
    if (!(field1 == rhs.field1)) {
      return field1 < rhs.field1;
    }
    (void)rhs;
    return false;
  }
  const  ::cpp2::Struct3& get_field1() const&;
   ::cpp2::Struct3 get_field1() &&;

  template <typename T_Struct19_field1_struct_setter>
   ::cpp2::Struct3& set_field1(T_Struct19_field1_struct_setter&& field1_) {
    field1 = std::forward<T_Struct19_field1_struct_setter>(field1_);
    __isset.field1 = true;
    return field1;
  }

  template <class Protocol_>
  uint32_t read(Protocol_* iprot);
  template <class Protocol_>
  uint32_t serializedSize(Protocol_ const* prot_) const;
  template <class Protocol_>
  uint32_t serializedSizeZC(Protocol_ const* prot_) const;
  template <class Protocol_>
  uint32_t write(Protocol_* prot_) const;

 private:
  static void translateFieldName(FOLLY_MAYBE_UNUSED folly::StringPiece _fname, FOLLY_MAYBE_UNUSED int16_t& fid, FOLLY_MAYBE_UNUSED apache::thrift::protocol::TType& _ftype);
};

void swap(Struct19& a, Struct19& b);
extern template uint32_t Struct19::read<>(apache::thrift::BinaryProtocolReader*);
extern template uint32_t Struct19::write<>(apache::thrift::BinaryProtocolWriter*) const;
extern template uint32_t Struct19::serializedSize<>(apache::thrift::BinaryProtocolWriter const*) const;
extern template uint32_t Struct19::serializedSizeZC<>(apache::thrift::BinaryProtocolWriter const*) const;
extern template uint32_t Struct19::read<>(apache::thrift::CompactProtocolReader*);
extern template uint32_t Struct19::write<>(apache::thrift::CompactProtocolWriter*) const;
extern template uint32_t Struct19::serializedSize<>(apache::thrift::CompactProtocolWriter const*) const;
extern template uint32_t Struct19::serializedSizeZC<>(apache::thrift::CompactProtocolWriter const*) const;

} // cpp2
namespace apache { namespace thrift {

template <> inline void Cpp2Ops< ::cpp2::Struct19>::clear( ::cpp2::Struct19* obj) {
  return obj->__clear();
}

template <> inline constexpr apache::thrift::protocol::TType Cpp2Ops< ::cpp2::Struct19>::thriftType() {
  return apache::thrift::protocol::T_STRUCT;
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct19>::write(Protocol* proto,  ::cpp2::Struct19 const* obj) {
  return obj->write(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct19>::read(Protocol* proto,  ::cpp2::Struct19* obj) {
  return obj->read(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct19>::serializedSize(Protocol const* proto,  ::cpp2::Struct19 const* obj) {
  return obj->serializedSize(proto);
}

template <> template <class Protocol> uint32_t Cpp2Ops< ::cpp2::Struct19>::serializedSizeZC(Protocol const* proto,  ::cpp2::Struct19 const* obj) {
  return obj->serializedSizeZC(proto);
}

}} // apache::thrift

redpajama_set_name: RedPajamaGithub