text: /**
   * Autogenerated by Thrift for src/module.thrift
   *
   * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
   *  @generated
   */
  
  #include "thrift/compiler/test/fixtures/params/gen-cpp2/NestedContainersAsyncClient.h"
  
  #include <thrift/lib/cpp2/gen/client_cpp.h>
  
  namespace cpp2 {
  typedef apache::thrift::ThriftPresult<false, apache::thrift::FieldData<1, ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::list<::apache::thrift::type_class::integral>>, ::std::map<::std::int32_t, ::std::vector<::std::int32_t>>*>> NestedContainers_mapList_pargs;
  typedef apache::thrift::ThriftPresult<true> NestedContainers_mapList_presult;
  typedef apache::thrift::ThriftPresult<false, apache::thrift::FieldData<1, ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::set<::apache::thrift::type_class::integral>>, ::std::map<::std::int32_t, ::std::set<::std::int32_t>>*>> NestedContainers_mapSet_pargs;
  typedef apache::thrift::ThriftPresult<true> NestedContainers_mapSet_presult;
  typedef apache::thrift::ThriftPresult<false, apache::thrift::FieldData<1, ::apache::thrift::type_class::list<::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::integral>>, ::std::vector<::std::map<::std::int32_t, ::std::int32_t>>*>> NestedContainers_listMap_pargs;
  typedef apache::thrift::ThriftPresult<true> NestedContainers_listMap_presult;
  typedef apache::thrift::ThriftPresult<false, apache::thrift::FieldData<1, ::apache::thrift::type_class::list<::apache::thrift::type_class::set<::apache::thrift::type_class::integral>>, ::std::vector<::std::set<::std::int32_t>>*>> NestedContainers_listSet_pargs;
  typedef apache::thrift::ThriftPresult<true> NestedContainers_listSet_presult;
  typedef apache::thrift::ThriftPresult<false, apache::thrift::FieldData<1, ::apache::thrift::type_class::list<::apache::thrift::type_class::list<::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::map<::apache::thrift::type_class::integral, ::apache::thrift::type_class::set<::apache::thrift::type_class::integral>>>>>, ::std::vector<::std::vector<::std::map<::std::int32_t, ::std::map<::std::int32_t, ::std::set<::std::int32_t>>>>>*>> NestedContainers_turtles_pargs;
  typedef apache::thrift::ThriftPresult<true> NestedContainers_turtles_presult;
  
  template <typename Protocol_>
  void NestedContainersAsyncClient::mapListT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback, const ::std::map<::std::int32_t, ::std::vector<::std::int32_t>>& p_foo) {
  
    NestedContainers_mapList_pargs args;
    args.get<0>().value = const_cast<::std::map<::std::int32_t, ::std::vector<::std::int32_t>>*>(&p_foo);
    auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); };
    auto writer = [&](Protocol_* p) { args.write(p); };
  
    static ::apache::thrift::MethodMetadata::Data* methodMetadata = 
          new ::apache::thrift::MethodMetadata::Data(
                  "mapList",
                  ::apache::thrift::FunctionQualifier::None);
    
    apache::thrift::clientSendT<apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, Protocol_>(prot, std::move(rpcOptions), std::move(callback), contextStack, std::move(header), channel_.get(), ::apache::thrift::MethodMetadata::from_static(methodMetadata), writer, sizer);  
  
  }
  
  template <typename Protocol_>
  void NestedContainersAsyncClient::mapSetT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback, const ::std::map<::std::int32_t, ::std::set<::std::int32_t>>& p_foo) {
  
    NestedContainers_mapSet_pargs args;
    args.get<0>().value = const_cast<::std::map<::std::int32_t, ::std::set<::std::int32_t>>*>(&p_foo);
    auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); };
    auto writer = [&](Protocol_* p) { args.write(p); };
  
    static ::apache::thrift::MethodMetadata::Data* methodMetadata = 
          new ::apache::thrift::MethodMetadata::Data(
                  "mapSet",
                  ::apache::thrift::FunctionQualifier::None);
    
    apache::thrift::clientSendT<apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, Protocol_>(prot, std::move(rpcOptions), std::move(callback), contextStack, std::move(header), channel_.get(), ::apache::thrift::MethodMetadata::from_static(methodMetadata), writer, sizer);  
  
  }
  
  template <typename Protocol_>
  void NestedContainersAsyncClient::listMapT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback, const ::std::vector<::std::map<::std::int32_t, ::std::int32_t>>& p_foo) {
  
    NestedContainers_listMap_pargs args;
    args.get<0>().value = const_cast<::std::vector<::std::map<::std::int32_t, ::std::int32_t>>*>(&p_foo);
    auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); };
    auto writer = [&](Protocol_* p) { args.write(p); };
  
    static ::apache::thrift::MethodMetadata::Data* methodMetadata = 
          new ::apache::thrift::MethodMetadata::Data(
                  "listMap",
                  ::apache::thrift::FunctionQualifier::None);
    
    apache::thrift::clientSendT<apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, Protocol_>(prot, std::move(rpcOptions), std::move(callback), contextStack, std::move(header), channel_.get(), ::apache::thrift::MethodMetadata::from_static(methodMetadata), writer, sizer);  
  
  }
  
  template <typename Protocol_>
  void NestedContainersAsyncClient::listSetT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback, const ::std::vector<::std::set<::std::int32_t>>& p_foo) {
  
    NestedContainers_listSet_pargs args;
    args.get<0>().value = const_cast<::std::vector<::std::set<::std::int32_t>>*>(&p_foo);
    auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); };
    auto writer = [&](Protocol_* p) { args.write(p); };
  
    static ::apache::thrift::MethodMetadata::Data* methodMetadata = 
          new ::apache::thrift::MethodMetadata::Data(
                  "listSet",
                  ::apache::thrift::FunctionQualifier::None);
    
    apache::thrift::clientSendT<apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, Protocol_>(prot, std::move(rpcOptions), std::move(callback), contextStack, std::move(header), channel_.get(), ::apache::thrift::MethodMetadata::from_static(methodMetadata), writer, sizer);  
  
  }
  
  template <typename Protocol_>
  void NestedContainersAsyncClient::turtlesT(Protocol_* prot, apache::thrift::RpcOptions rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback, const ::std::vector<::std::vector<::std::map<::std::int32_t, ::std::map<::std::int32_t, ::std::set<::std::int32_t>>>>>& p_foo) {
  
    NestedContainers_turtles_pargs args;
    args.get<0>().value = const_cast<::std::vector<::std::vector<::std::map<::std::int32_t, ::std::map<::std::int32_t, ::std::set<::std::int32_t>>>>>*>(&p_foo);
    auto sizer = [&](Protocol_* p) { return args.serializedSizeZC(p); };
    auto writer = [&](Protocol_* p) { args.write(p); };
  
    static ::apache::thrift::MethodMetadata::Data* methodMetadata = 
          new ::apache::thrift::MethodMetadata::Data(
                  "turtles",
                  ::apache::thrift::FunctionQualifier::None);
    
    apache::thrift::clientSendT<apache::thrift::RpcKind::SINGLE_REQUEST_SINGLE_RESPONSE, Protocol_>(prot, std::move(rpcOptions), std::move(callback), contextStack, std::move(header), channel_.get(), ::apache::thrift::MethodMetadata::from_static(methodMetadata), writer, sizer);  
  
  }
  
  
  
  void NestedContainersAsyncClient::mapList(std::unique_ptr<apache::thrift::RequestCallback> callback, const ::std::map<::std::int32_t, ::std::vector<::std::int32_t>>& p_foo) {
    ::apache::thrift::RpcOptions rpcOptions;
    mapList(rpcOptions, std::move(callback), p_foo);
  }
  
  void NestedContainersAsyncClient::mapList(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr<apache::thrift::RequestCallback> callback, const ::std::map<::std::int32_t, ::std::vector<::std::int32_t>>& p_foo) {
    auto [ctx, header] = mapListCtx(&rpcOptions);
    apache::thrift::RequestCallback::Context callbackContext;
    callbackContext.protocolId =
        apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId();
    auto* contextStack = ctx.get();
    if (callback) {
      callbackContext.ctx = std::move(ctx);
    }
    auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext));
    mapListImpl(rpcOptions, std::move(header), contextStack, std::move(wrappedCallback), p_foo);
  }
  
  void NestedContainersAsyncClient::mapListImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback, const ::std::map<::std::int32_t, ::std::vector<::std::int32_t>>& p_foo) {
    switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) {
      case apache::thrift::protocol::T_BINARY_PROTOCOL:
      {
        apache::thrift::BinaryProtocolWriter writer;
        mapListT(&writer, rpcOptions, std::move(header), contextStack, std::move(callback), p_foo);
        break;
      }
      case apache::thrift::protocol::T_COMPACT_PROTOCOL:
      {
        apache::thrift::CompactProtocolWriter writer;
        mapListT(&writer, rpcOptions, std::move(header), contextStack, std::move(callback), p_foo);
        break;
      }
      default:
      {
        apache::thrift::detail::ac::throw_app_exn("Could not find Protocol");
      }
    }
  }
  
  std::pair<std::unique_ptr<::apache::thrift::ContextStack>, std::shared_ptr<::apache::thrift::transport::THeader>> NestedContainersAsyncClient::mapListCtx(apache::thrift::RpcOptions* rpcOptions) {
    auto header = std::make_shared<apache::thrift::transport::THeader>(
        apache::thrift::transport::THeader::ALLOW_BIG_FRAMES);
    header->setProtocolId(channel_->getProtocolId());
    if (rpcOptions) {
      header->setHeaders(rpcOptions->releaseWriteHeaders());
    }
  
    auto ctx = apache::thrift::ContextStack::createWithClientContext(
        handlers_,
        getServiceName(),
        "NestedContainers.mapList",
        *header);
  
    return {std::move(ctx), std::move(header)};
  }
  
  void NestedContainersAsyncClient::sync_mapList(const ::std::map<::std::int32_t, ::std::vector<::std::int32_t>>& p_foo) {
    ::apache::thrift::RpcOptions rpcOptions;
    sync_mapList(rpcOptions, p_foo);
  }
  
  void NestedContainersAsyncClient::sync_mapList(apache::thrift::RpcOptions& rpcOptions, const ::std::map<::std::int32_t, ::std::vector<::std::int32_t>>& p_foo) {
    apache::thrift::ClientReceiveState returnState;
    apache::thrift::ClientSyncCallback<false> callback(&returnState);
    auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId();
    auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase();
    auto [ctx, header] = mapListCtx(&rpcOptions);
    auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback);
    mapListImpl(rpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback), p_foo);
    callback.waitUntilDone(evb);
  
    if (returnState.isException()) {
      returnState.exception().throw_exception();
    }
    returnState.resetProtocolId(protocolId);
    returnState.resetCtx(std::move(ctx));
    SCOPE_EXIT {
      if (returnState.header() && !returnState.header()->getHeaders().empty()) {
        rpcOptions.setReadHeaders(returnState.header()->releaseHeaders());
      }
    };
    return folly::fibers::runInMainContext([&] {
        recv_mapList(returnState);
    });
  }
  
  
  folly::Future<folly::Unit> NestedContainersAsyncClient::future_mapList(const ::std::map<::std::int32_t, ::std::vector<::std::int32_t>>& p_foo) {
    ::apache::thrift::RpcOptions rpcOptions;
    return future_mapList(rpcOptions, p_foo);
  }
  
  folly::SemiFuture<folly::Unit> NestedContainersAsyncClient::semifuture_mapList(const ::std::map<::std::int32_t, ::std::vector<::std::int32_t>>& p_foo) {
    ::apache::thrift::RpcOptions rpcOptions;
    return semifuture_mapList(rpcOptions, p_foo);
  }
  
  folly::Future<folly::Unit> NestedContainersAsyncClient::future_mapList(apache::thrift::RpcOptions& rpcOptions, const ::std::map<::std::int32_t, ::std::vector<::std::int32_t>>& p_foo) {
    folly::Promise<folly::Unit> promise;
    auto future = promise.getFuture();
    auto callback = std::make_unique<apache::thrift::FutureCallback<folly::Unit>>(std::move(promise), recv_wrapped_mapList, channel_);
    mapList(rpcOptions, std::move(callback), p_foo);
    return future;
  }
  
  folly::SemiFuture<folly::Unit> NestedContainersAsyncClient::semifuture_mapList(apache::thrift::RpcOptions& rpcOptions, const ::std::map<::std::int32_t, ::std::vector<::std::int32_t>>& p_foo) {
    auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_mapList, channel_);
    auto callback = std::move(callbackAndFuture.first);
    mapList(rpcOptions, std::move(callback), p_foo);
    return std::move(callbackAndFuture.second);
  }
  
  folly::Future<std::pair<folly::Unit, std::unique_ptr<apache::thrift::transport::THeader>>> NestedContainersAsyncClient::header_future_mapList(apache::thrift::RpcOptions& rpcOptions, const ::std::map<::std::int32_t, ::std::vector<::std::int32_t>>& p_foo) {
    folly::Promise<std::pair<folly::Unit, std::unique_ptr<apache::thrift::transport::THeader>>> promise;
    auto future = promise.getFuture();
    auto callback = std::make_unique<apache::thrift::HeaderFutureCallback<folly::Unit>>(std::move(promise), recv_wrapped_mapList, channel_);
    mapList(rpcOptions, std::move(callback), p_foo);
    return future;
  }
  
  folly::SemiFuture<std::pair<folly::Unit, std::unique_ptr<apache::thrift::transport::THeader>>> NestedContainersAsyncClient::header_semifuture_mapList(apache::thrift::RpcOptions& rpcOptions, const ::std::map<::std::int32_t, ::std::vector<::std::int32_t>>& p_foo) {
    auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_mapList, channel_);
    auto callback = std::move(callbackAndFuture.first);
    mapList(rpcOptions, std::move(callback), p_foo);
    return std::move(callbackAndFuture.second);
  }
  
  void NestedContainersAsyncClient::mapList(folly::Function<void (::apache::thrift::ClientReceiveState&&)> callback, const ::std::map<::std::int32_t, ::std::vector<::std::int32_t>>& p_foo) {
    mapList(std::make_unique<apache::thrift::FunctionReplyCallback>(std::move(callback)), p_foo);
  }
  
  #if FOLLY_HAS_COROUTINES
  #endif // FOLLY_HAS_COROUTINES
  folly::exception_wrapper NestedContainersAsyncClient::recv_wrapped_mapList(::apache::thrift::ClientReceiveState& state) {
    if (state.isException()) {
      return std::move(state.exception());
    }
    if (!state.hasResponseBuffer()) {
      return folly::make_exception_wrapper<apache::thrift::TApplicationException>("recv_ called without result");
    }
  
    using result = NestedContainers_mapList_presult;
    switch (state.protocolId()) {
      case apache::thrift::protocol::T_BINARY_PROTOCOL:
      {
        apache::thrift::BinaryProtocolReader reader;
        return apache::thrift::detail::ac::recv_wrapped<result>(
            &reader, state);
      }
      case apache::thrift::protocol::T_COMPACT_PROTOCOL:
      {
        apache::thrift::CompactProtocolReader reader;
        return apache::thrift::detail::ac::recv_wrapped<result>(
            &reader, state);
      }
      default:
      {
      }
    }
    return folly::make_exception_wrapper<apache::thrift::TApplicationException>("Could not find Protocol");
  }
  
  void NestedContainersAsyncClient::recv_mapList(::apache::thrift::ClientReceiveState& state) {
    auto ew = recv_wrapped_mapList(state);
    if (ew) {
      ew.throw_exception();
    }
  }
  
  void NestedContainersAsyncClient::recv_instance_mapList(::apache::thrift::ClientReceiveState& state) {
    recv_mapList(state);
  }
  
  folly::exception_wrapper NestedContainersAsyncClient::recv_instance_wrapped_mapList(::apache::thrift::ClientReceiveState& state) {
    return recv_wrapped_mapList(state);
  }
  
  void NestedContainersAsyncClient::mapSet(std::unique_ptr<apache::thrift::RequestCallback> callback, const ::std::map<::std::int32_t, ::std::set<::std::int32_t>>& p_foo) {
    ::apache::thrift::RpcOptions rpcOptions;
    mapSet(rpcOptions, std::move(callback), p_foo);
  }
  
  void NestedContainersAsyncClient::mapSet(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr<apache::thrift::RequestCallback> callback, const ::std::map<::std::int32_t, ::std::set<::std::int32_t>>& p_foo) {
    auto [ctx, header] = mapSetCtx(&rpcOptions);
    apache::thrift::RequestCallback::Context callbackContext;
    callbackContext.protocolId =
        apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId();
    auto* contextStack = ctx.get();
    if (callback) {
      callbackContext.ctx = std::move(ctx);
    }
    auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext));
    mapSetImpl(rpcOptions, std::move(header), contextStack, std::move(wrappedCallback), p_foo);
  }
  
  void NestedContainersAsyncClient::mapSetImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback, const ::std::map<::std::int32_t, ::std::set<::std::int32_t>>& p_foo) {
    switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) {
      case apache::thrift::protocol::T_BINARY_PROTOCOL:
      {
        apache::thrift::BinaryProtocolWriter writer;
        mapSetT(&writer, rpcOptions, std::move(header), contextStack, std::move(callback), p_foo);
        break;
      }
      case apache::thrift::protocol::T_COMPACT_PROTOCOL:
      {
        apache::thrift::CompactProtocolWriter writer;
        mapSetT(&writer, rpcOptions, std::move(header), contextStack, std::move(callback), p_foo);
        break;
      }
      default:
      {
        apache::thrift::detail::ac::throw_app_exn("Could not find Protocol");
      }
    }
  }
  
  std::pair<std::unique_ptr<::apache::thrift::ContextStack>, std::shared_ptr<::apache::thrift::transport::THeader>> NestedContainersAsyncClient::mapSetCtx(apache::thrift::RpcOptions* rpcOptions) {
    auto header = std::make_shared<apache::thrift::transport::THeader>(
        apache::thrift::transport::THeader::ALLOW_BIG_FRAMES);
    header->setProtocolId(channel_->getProtocolId());
    if (rpcOptions) {
      header->setHeaders(rpcOptions->releaseWriteHeaders());
    }
  
    auto ctx = apache::thrift::ContextStack::createWithClientContext(
        handlers_,
        getServiceName(),
        "NestedContainers.mapSet",
        *header);
  
    return {std::move(ctx), std::move(header)};
  }
  
  void NestedContainersAsyncClient::sync_mapSet(const ::std::map<::std::int32_t, ::std::set<::std::int32_t>>& p_foo) {
    ::apache::thrift::RpcOptions rpcOptions;
    sync_mapSet(rpcOptions, p_foo);
  }
  
  void NestedContainersAsyncClient::sync_mapSet(apache::thrift::RpcOptions& rpcOptions, const ::std::map<::std::int32_t, ::std::set<::std::int32_t>>& p_foo) {
    apache::thrift::ClientReceiveState returnState;
    apache::thrift::ClientSyncCallback<false> callback(&returnState);
    auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId();
    auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase();
    auto [ctx, header] = mapSetCtx(&rpcOptions);
    auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback);
    mapSetImpl(rpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback), p_foo);
    callback.waitUntilDone(evb);
  
    if (returnState.isException()) {
      returnState.exception().throw_exception();
    }
    returnState.resetProtocolId(protocolId);
    returnState.resetCtx(std::move(ctx));
    SCOPE_EXIT {
      if (returnState.header() && !returnState.header()->getHeaders().empty()) {
        rpcOptions.setReadHeaders(returnState.header()->releaseHeaders());
      }
    };
    return folly::fibers::runInMainContext([&] {
        recv_mapSet(returnState);
    });
  }
  
  
  folly::Future<folly::Unit> NestedContainersAsyncClient::future_mapSet(const ::std::map<::std::int32_t, ::std::set<::std::int32_t>>& p_foo) {
    ::apache::thrift::RpcOptions rpcOptions;
    return future_mapSet(rpcOptions, p_foo);
  }
  
  folly::SemiFuture<folly::Unit> NestedContainersAsyncClient::semifuture_mapSet(const ::std::map<::std::int32_t, ::std::set<::std::int32_t>>& p_foo) {
    ::apache::thrift::RpcOptions rpcOptions;
    return semifuture_mapSet(rpcOptions, p_foo);
  }
  
  folly::Future<folly::Unit> NestedContainersAsyncClient::future_mapSet(apache::thrift::RpcOptions& rpcOptions, const ::std::map<::std::int32_t, ::std::set<::std::int32_t>>& p_foo) {
    folly::Promise<folly::Unit> promise;
    auto future = promise.getFuture();
    auto callback = std::make_unique<apache::thrift::FutureCallback<folly::Unit>>(std::move(promise), recv_wrapped_mapSet, channel_);
    mapSet(rpcOptions, std::move(callback), p_foo);
    return future;
  }
  
  folly::SemiFuture<folly::Unit> NestedContainersAsyncClient::semifuture_mapSet(apache::thrift::RpcOptions& rpcOptions, const ::std::map<::std::int32_t, ::std::set<::std::int32_t>>& p_foo) {
    auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_mapSet, channel_);
    auto callback = std::move(callbackAndFuture.first);
    mapSet(rpcOptions, std::move(callback), p_foo);
    return std::move(callbackAndFuture.second);
  }
  
  folly::Future<std::pair<folly::Unit, std::unique_ptr<apache::thrift::transport::THeader>>> NestedContainersAsyncClient::header_future_mapSet(apache::thrift::RpcOptions& rpcOptions, const ::std::map<::std::int32_t, ::std::set<::std::int32_t>>& p_foo) {
    folly::Promise<std::pair<folly::Unit, std::unique_ptr<apache::thrift::transport::THeader>>> promise;
    auto future = promise.getFuture();
    auto callback = std::make_unique<apache::thrift::HeaderFutureCallback<folly::Unit>>(std::move(promise), recv_wrapped_mapSet, channel_);
    mapSet(rpcOptions, std::move(callback), p_foo);
    return future;
  }
  
  folly::SemiFuture<std::pair<folly::Unit, std::unique_ptr<apache::thrift::transport::THeader>>> NestedContainersAsyncClient::header_semifuture_mapSet(apache::thrift::RpcOptions& rpcOptions, const ::std::map<::std::int32_t, ::std::set<::std::int32_t>>& p_foo) {
    auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_mapSet, channel_);
    auto callback = std::move(callbackAndFuture.first);
    mapSet(rpcOptions, std::move(callback), p_foo);
    return std::move(callbackAndFuture.second);
  }
  
  void NestedContainersAsyncClient::mapSet(folly::Function<void (::apache::thrift::ClientReceiveState&&)> callback, const ::std::map<::std::int32_t, ::std::set<::std::int32_t>>& p_foo) {
    mapSet(std::make_unique<apache::thrift::FunctionReplyCallback>(std::move(callback)), p_foo);
  }
  
  #if FOLLY_HAS_COROUTINES
  #endif // FOLLY_HAS_COROUTINES
  folly::exception_wrapper NestedContainersAsyncClient::recv_wrapped_mapSet(::apache::thrift::ClientReceiveState& state) {
    if (state.isException()) {
      return std::move(state.exception());
    }
    if (!state.hasResponseBuffer()) {
      return folly::make_exception_wrapper<apache::thrift::TApplicationException>("recv_ called without result");
    }
  
    using result = NestedContainers_mapSet_presult;
    switch (state.protocolId()) {
      case apache::thrift::protocol::T_BINARY_PROTOCOL:
      {
        apache::thrift::BinaryProtocolReader reader;
        return apache::thrift::detail::ac::recv_wrapped<result>(
            &reader, state);
      }
      case apache::thrift::protocol::T_COMPACT_PROTOCOL:
      {
        apache::thrift::CompactProtocolReader reader;
        return apache::thrift::detail::ac::recv_wrapped<result>(
            &reader, state);
      }
      default:
      {
      }
    }
    return folly::make_exception_wrapper<apache::thrift::TApplicationException>("Could not find Protocol");
  }
  
  void NestedContainersAsyncClient::recv_mapSet(::apache::thrift::ClientReceiveState& state) {
    auto ew = recv_wrapped_mapSet(state);
    if (ew) {
      ew.throw_exception();
    }
  }
  
  void NestedContainersAsyncClient::recv_instance_mapSet(::apache::thrift::ClientReceiveState& state) {
    recv_mapSet(state);
  }
  
  folly::exception_wrapper NestedContainersAsyncClient::recv_instance_wrapped_mapSet(::apache::thrift::ClientReceiveState& state) {
    return recv_wrapped_mapSet(state);
  }
  
  void NestedContainersAsyncClient::listMap(std::unique_ptr<apache::thrift::RequestCallback> callback, const ::std::vector<::std::map<::std::int32_t, ::std::int32_t>>& p_foo) {
    ::apache::thrift::RpcOptions rpcOptions;
    listMap(rpcOptions, std::move(callback), p_foo);
  }
  
  void NestedContainersAsyncClient::listMap(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr<apache::thrift::RequestCallback> callback, const ::std::vector<::std::map<::std::int32_t, ::std::int32_t>>& p_foo) {
    auto [ctx, header] = listMapCtx(&rpcOptions);
    apache::thrift::RequestCallback::Context callbackContext;
    callbackContext.protocolId =
        apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId();
    auto* contextStack = ctx.get();
    if (callback) {
      callbackContext.ctx = std::move(ctx);
    }
    auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext));
    listMapImpl(rpcOptions, std::move(header), contextStack, std::move(wrappedCallback), p_foo);
  }
  
  void NestedContainersAsyncClient::listMapImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback, const ::std::vector<::std::map<::std::int32_t, ::std::int32_t>>& p_foo) {
    switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) {
      case apache::thrift::protocol::T_BINARY_PROTOCOL:
      {
        apache::thrift::BinaryProtocolWriter writer;
        listMapT(&writer, rpcOptions, std::move(header), contextStack, std::move(callback), p_foo);
        break;
      }
      case apache::thrift::protocol::T_COMPACT_PROTOCOL:
      {
        apache::thrift::CompactProtocolWriter writer;
        listMapT(&writer, rpcOptions, std::move(header), contextStack, std::move(callback), p_foo);
        break;
      }
      default:
      {
        apache::thrift::detail::ac::throw_app_exn("Could not find Protocol");
      }
    }
  }
  
  std::pair<std::unique_ptr<::apache::thrift::ContextStack>, std::shared_ptr<::apache::thrift::transport::THeader>> NestedContainersAsyncClient::listMapCtx(apache::thrift::RpcOptions* rpcOptions) {
    auto header = std::make_shared<apache::thrift::transport::THeader>(
        apache::thrift::transport::THeader::ALLOW_BIG_FRAMES);
    header->setProtocolId(channel_->getProtocolId());
    if (rpcOptions) {
      header->setHeaders(rpcOptions->releaseWriteHeaders());
    }
  
    auto ctx = apache::thrift::ContextStack::createWithClientContext(
        handlers_,
        getServiceName(),
        "NestedContainers.listMap",
        *header);
  
    return {std::move(ctx), std::move(header)};
  }
  
  void NestedContainersAsyncClient::sync_listMap(const ::std::vector<::std::map<::std::int32_t, ::std::int32_t>>& p_foo) {
    ::apache::thrift::RpcOptions rpcOptions;
    sync_listMap(rpcOptions, p_foo);
  }
  
  void NestedContainersAsyncClient::sync_listMap(apache::thrift::RpcOptions& rpcOptions, const ::std::vector<::std::map<::std::int32_t, ::std::int32_t>>& p_foo) {
    apache::thrift::ClientReceiveState returnState;
    apache::thrift::ClientSyncCallback<false> callback(&returnState);
    auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId();
    auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase();
    auto [ctx, header] = listMapCtx(&rpcOptions);
    auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback);
    listMapImpl(rpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback), p_foo);
    callback.waitUntilDone(evb);
  
    if (returnState.isException()) {
      returnState.exception().throw_exception();
    }
    returnState.resetProtocolId(protocolId);
    returnState.resetCtx(std::move(ctx));
    SCOPE_EXIT {
      if (returnState.header() && !returnState.header()->getHeaders().empty()) {
        rpcOptions.setReadHeaders(returnState.header()->releaseHeaders());
      }
    };
    return folly::fibers::runInMainContext([&] {
        recv_listMap(returnState);
    });
  }
  
  
  folly::Future<folly::Unit> NestedContainersAsyncClient::future_listMap(const ::std::vector<::std::map<::std::int32_t, ::std::int32_t>>& p_foo) {
    ::apache::thrift::RpcOptions rpcOptions;
    return future_listMap(rpcOptions, p_foo);
  }
  
  folly::SemiFuture<folly::Unit> NestedContainersAsyncClient::semifuture_listMap(const ::std::vector<::std::map<::std::int32_t, ::std::int32_t>>& p_foo) {
    ::apache::thrift::RpcOptions rpcOptions;
    return semifuture_listMap(rpcOptions, p_foo);
  }
  
  folly::Future<folly::Unit> NestedContainersAsyncClient::future_listMap(apache::thrift::RpcOptions& rpcOptions, const ::std::vector<::std::map<::std::int32_t, ::std::int32_t>>& p_foo) {
    folly::Promise<folly::Unit> promise;
    auto future = promise.getFuture();
    auto callback = std::make_unique<apache::thrift::FutureCallback<folly::Unit>>(std::move(promise), recv_wrapped_listMap, channel_);
    listMap(rpcOptions, std::move(callback), p_foo);
    return future;
  }
  
  folly::SemiFuture<folly::Unit> NestedContainersAsyncClient::semifuture_listMap(apache::thrift::RpcOptions& rpcOptions, const ::std::vector<::std::map<::std::int32_t, ::std::int32_t>>& p_foo) {
    auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_listMap, channel_);
    auto callback = std::move(callbackAndFuture.first);
    listMap(rpcOptions, std::move(callback), p_foo);
    return std::move(callbackAndFuture.second);
  }
  
  folly::Future<std::pair<folly::Unit, std::unique_ptr<apache::thrift::transport::THeader>>> NestedContainersAsyncClient::header_future_listMap(apache::thrift::RpcOptions& rpcOptions, const ::std::vector<::std::map<::std::int32_t, ::std::int32_t>>& p_foo) {
    folly::Promise<std::pair<folly::Unit, std::unique_ptr<apache::thrift::transport::THeader>>> promise;
    auto future = promise.getFuture();
    auto callback = std::make_unique<apache::thrift::HeaderFutureCallback<folly::Unit>>(std::move(promise), recv_wrapped_listMap, channel_);
    listMap(rpcOptions, std::move(callback), p_foo);
    return future;
  }
  
  folly::SemiFuture<std::pair<folly::Unit, std::unique_ptr<apache::thrift::transport::THeader>>> NestedContainersAsyncClient::header_semifuture_listMap(apache::thrift::RpcOptions& rpcOptions, const ::std::vector<::std::map<::std::int32_t, ::std::int32_t>>& p_foo) {
    auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_listMap, channel_);
    auto callback = std::move(callbackAndFuture.first);
    listMap(rpcOptions, std::move(callback), p_foo);
    return std::move(callbackAndFuture.second);
  }
  
  void NestedContainersAsyncClient::listMap(folly::Function<void (::apache::thrift::ClientReceiveState&&)> callback, const ::std::vector<::std::map<::std::int32_t, ::std::int32_t>>& p_foo) {
    listMap(std::make_unique<apache::thrift::FunctionReplyCallback>(std::move(callback)), p_foo);
  }
  
  #if FOLLY_HAS_COROUTINES
  #endif // FOLLY_HAS_COROUTINES
  folly::exception_wrapper NestedContainersAsyncClient::recv_wrapped_listMap(::apache::thrift::ClientReceiveState& state) {
    if (state.isException()) {
      return std::move(state.exception());
    }
    if (!state.hasResponseBuffer()) {
      return folly::make_exception_wrapper<apache::thrift::TApplicationException>("recv_ called without result");
    }
  
    using result = NestedContainers_listMap_presult;
    switch (state.protocolId()) {
      case apache::thrift::protocol::T_BINARY_PROTOCOL:
      {
        apache::thrift::BinaryProtocolReader reader;
        return apache::thrift::detail::ac::recv_wrapped<result>(
            &reader, state);
      }
      case apache::thrift::protocol::T_COMPACT_PROTOCOL:
      {
        apache::thrift::CompactProtocolReader reader;
        return apache::thrift::detail::ac::recv_wrapped<result>(
            &reader, state);
      }
      default:
      {
      }
    }
    return folly::make_exception_wrapper<apache::thrift::TApplicationException>("Could not find Protocol");
  }
  
  void NestedContainersAsyncClient::recv_listMap(::apache::thrift::ClientReceiveState& state) {
    auto ew = recv_wrapped_listMap(state);
    if (ew) {
      ew.throw_exception();
    }
  }
  
  void NestedContainersAsyncClient::recv_instance_listMap(::apache::thrift::ClientReceiveState& state) {
    recv_listMap(state);
  }
  
  folly::exception_wrapper NestedContainersAsyncClient::recv_instance_wrapped_listMap(::apache::thrift::ClientReceiveState& state) {
    return recv_wrapped_listMap(state);
  }
  
  void NestedContainersAsyncClient::listSet(std::unique_ptr<apache::thrift::RequestCallback> callback, const ::std::vector<::std::set<::std::int32_t>>& p_foo) {
    ::apache::thrift::RpcOptions rpcOptions;
    listSet(rpcOptions, std::move(callback), p_foo);
  }
  
  void NestedContainersAsyncClient::listSet(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr<apache::thrift::RequestCallback> callback, const ::std::vector<::std::set<::std::int32_t>>& p_foo) {
    auto [ctx, header] = listSetCtx(&rpcOptions);
    apache::thrift::RequestCallback::Context callbackContext;
    callbackContext.protocolId =
        apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId();
    auto* contextStack = ctx.get();
    if (callback) {
      callbackContext.ctx = std::move(ctx);
    }
    auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext));
    listSetImpl(rpcOptions, std::move(header), contextStack, std::move(wrappedCallback), p_foo);
  }
  
  void NestedContainersAsyncClient::listSetImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback, const ::std::vector<::std::set<::std::int32_t>>& p_foo) {
    switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) {
      case apache::thrift::protocol::T_BINARY_PROTOCOL:
      {
        apache::thrift::BinaryProtocolWriter writer;
        listSetT(&writer, rpcOptions, std::move(header), contextStack, std::move(callback), p_foo);
        break;
      }
      case apache::thrift::protocol::T_COMPACT_PROTOCOL:
      {
        apache::thrift::CompactProtocolWriter writer;
        listSetT(&writer, rpcOptions, std::move(header), contextStack, std::move(callback), p_foo);
        break;
      }
      default:
      {
        apache::thrift::detail::ac::throw_app_exn("Could not find Protocol");
      }
    }
  }
  
  std::pair<std::unique_ptr<::apache::thrift::ContextStack>, std::shared_ptr<::apache::thrift::transport::THeader>> NestedContainersAsyncClient::listSetCtx(apache::thrift::RpcOptions* rpcOptions) {
    auto header = std::make_shared<apache::thrift::transport::THeader>(
        apache::thrift::transport::THeader::ALLOW_BIG_FRAMES);
    header->setProtocolId(channel_->getProtocolId());
    if (rpcOptions) {
      header->setHeaders(rpcOptions->releaseWriteHeaders());
    }
  
    auto ctx = apache::thrift::ContextStack::createWithClientContext(
        handlers_,
        getServiceName(),
        "NestedContainers.listSet",
        *header);
  
    return {std::move(ctx), std::move(header)};
  }
  
  void NestedContainersAsyncClient::sync_listSet(const ::std::vector<::std::set<::std::int32_t>>& p_foo) {
    ::apache::thrift::RpcOptions rpcOptions;
    sync_listSet(rpcOptions, p_foo);
  }
  
  void NestedContainersAsyncClient::sync_listSet(apache::thrift::RpcOptions& rpcOptions, const ::std::vector<::std::set<::std::int32_t>>& p_foo) {
    apache::thrift::ClientReceiveState returnState;
    apache::thrift::ClientSyncCallback<false> callback(&returnState);
    auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId();
    auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase();
    auto [ctx, header] = listSetCtx(&rpcOptions);
    auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback);
    listSetImpl(rpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback), p_foo);
    callback.waitUntilDone(evb);
  
    if (returnState.isException()) {
      returnState.exception().throw_exception();
    }
    returnState.resetProtocolId(protocolId);
    returnState.resetCtx(std::move(ctx));
    SCOPE_EXIT {
      if (returnState.header() && !returnState.header()->getHeaders().empty()) {
        rpcOptions.setReadHeaders(returnState.header()->releaseHeaders());
      }
    };
    return folly::fibers::runInMainContext([&] {
        recv_listSet(returnState);
    });
  }
  
  
  folly::Future<folly::Unit> NestedContainersAsyncClient::future_listSet(const ::std::vector<::std::set<::std::int32_t>>& p_foo) {
    ::apache::thrift::RpcOptions rpcOptions;
    return future_listSet(rpcOptions, p_foo);
  }
  
  folly::SemiFuture<folly::Unit> NestedContainersAsyncClient::semifuture_listSet(const ::std::vector<::std::set<::std::int32_t>>& p_foo) {
    ::apache::thrift::RpcOptions rpcOptions;
    return semifuture_listSet(rpcOptions, p_foo);
  }
  
  folly::Future<folly::Unit> NestedContainersAsyncClient::future_listSet(apache::thrift::RpcOptions& rpcOptions, const ::std::vector<::std::set<::std::int32_t>>& p_foo) {
    folly::Promise<folly::Unit> promise;
    auto future = promise.getFuture();
    auto callback = std::make_unique<apache::thrift::FutureCallback<folly::Unit>>(std::move(promise), recv_wrapped_listSet, channel_);
    listSet(rpcOptions, std::move(callback), p_foo);
    return future;
  }
  
  folly::SemiFuture<folly::Unit> NestedContainersAsyncClient::semifuture_listSet(apache::thrift::RpcOptions& rpcOptions, const ::std::vector<::std::set<::std::int32_t>>& p_foo) {
    auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_listSet, channel_);
    auto callback = std::move(callbackAndFuture.first);
    listSet(rpcOptions, std::move(callback), p_foo);
    return std::move(callbackAndFuture.second);
  }
  
  folly::Future<std::pair<folly::Unit, std::unique_ptr<apache::thrift::transport::THeader>>> NestedContainersAsyncClient::header_future_listSet(apache::thrift::RpcOptions& rpcOptions, const ::std::vector<::std::set<::std::int32_t>>& p_foo) {
    folly::Promise<std::pair<folly::Unit, std::unique_ptr<apache::thrift::transport::THeader>>> promise;
    auto future = promise.getFuture();
    auto callback = std::make_unique<apache::thrift::HeaderFutureCallback<folly::Unit>>(std::move(promise), recv_wrapped_listSet, channel_);
    listSet(rpcOptions, std::move(callback), p_foo);
    return future;
  }
  
  folly::SemiFuture<std::pair<folly::Unit, std::unique_ptr<apache::thrift::transport::THeader>>> NestedContainersAsyncClient::header_semifuture_listSet(apache::thrift::RpcOptions& rpcOptions, const ::std::vector<::std::set<::std::int32_t>>& p_foo) {
    auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_listSet, channel_);
    auto callback = std::move(callbackAndFuture.first);
    listSet(rpcOptions, std::move(callback), p_foo);
    return std::move(callbackAndFuture.second);
  }
  
  void NestedContainersAsyncClient::listSet(folly::Function<void (::apache::thrift::ClientReceiveState&&)> callback, const ::std::vector<::std::set<::std::int32_t>>& p_foo) {
    listSet(std::make_unique<apache::thrift::FunctionReplyCallback>(std::move(callback)), p_foo);
  }
  
  #if FOLLY_HAS_COROUTINES
  #endif // FOLLY_HAS_COROUTINES
  folly::exception_wrapper NestedContainersAsyncClient::recv_wrapped_listSet(::apache::thrift::ClientReceiveState& state) {
    if (state.isException()) {
      return std::move(state.exception());
    }
    if (!state.hasResponseBuffer()) {
      return folly::make_exception_wrapper<apache::thrift::TApplicationException>("recv_ called without result");
    }
  
    using result = NestedContainers_listSet_presult;
    switch (state.protocolId()) {
      case apache::thrift::protocol::T_BINARY_PROTOCOL:
      {
        apache::thrift::BinaryProtocolReader reader;
        return apache::thrift::detail::ac::recv_wrapped<result>(
            &reader, state);
      }
      case apache::thrift::protocol::T_COMPACT_PROTOCOL:
      {
        apache::thrift::CompactProtocolReader reader;
        return apache::thrift::detail::ac::recv_wrapped<result>(
            &reader, state);
      }
      default:
      {
      }
    }
    return folly::make_exception_wrapper<apache::thrift::TApplicationException>("Could not find Protocol");
  }
  
  void NestedContainersAsyncClient::recv_listSet(::apache::thrift::ClientReceiveState& state) {
    auto ew = recv_wrapped_listSet(state);
    if (ew) {
      ew.throw_exception();
    }
  }
  
  void NestedContainersAsyncClient::recv_instance_listSet(::apache::thrift::ClientReceiveState& state) {
    recv_listSet(state);
  }
  
  folly::exception_wrapper NestedContainersAsyncClient::recv_instance_wrapped_listSet(::apache::thrift::ClientReceiveState& state) {
    return recv_wrapped_listSet(state);
  }
  
  void NestedContainersAsyncClient::turtles(std::unique_ptr<apache::thrift::RequestCallback> callback, const ::std::vector<::std::vector<::std::map<::std::int32_t, ::std::map<::std::int32_t, ::std::set<::std::int32_t>>>>>& p_foo) {
    ::apache::thrift::RpcOptions rpcOptions;
    turtles(rpcOptions, std::move(callback), p_foo);
  }
  
  void NestedContainersAsyncClient::turtles(apache::thrift::RpcOptions& rpcOptions, std::unique_ptr<apache::thrift::RequestCallback> callback, const ::std::vector<::std::vector<::std::map<::std::int32_t, ::std::map<::std::int32_t, ::std::set<::std::int32_t>>>>>& p_foo) {
    auto [ctx, header] = turtlesCtx(&rpcOptions);
    apache::thrift::RequestCallback::Context callbackContext;
    callbackContext.protocolId =
        apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId();
    auto* contextStack = ctx.get();
    if (callback) {
      callbackContext.ctx = std::move(ctx);
    }
    auto wrappedCallback = apache::thrift::toRequestClientCallbackPtr(std::move(callback), std::move(callbackContext));
    turtlesImpl(rpcOptions, std::move(header), contextStack, std::move(wrappedCallback), p_foo);
  }
  
  void NestedContainersAsyncClient::turtlesImpl(const apache::thrift::RpcOptions& rpcOptions, std::shared_ptr<apache::thrift::transport::THeader> header, apache::thrift::ContextStack* contextStack, apache::thrift::RequestClientCallback::Ptr callback, const ::std::vector<::std::vector<::std::map<::std::int32_t, ::std::map<::std::int32_t, ::std::set<::std::int32_t>>>>>& p_foo) {
    switch (apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId()) {
      case apache::thrift::protocol::T_BINARY_PROTOCOL:
      {
        apache::thrift::BinaryProtocolWriter writer;
        turtlesT(&writer, rpcOptions, std::move(header), contextStack, std::move(callback), p_foo);
        break;
      }
      case apache::thrift::protocol::T_COMPACT_PROTOCOL:
      {
        apache::thrift::CompactProtocolWriter writer;
        turtlesT(&writer, rpcOptions, std::move(header), contextStack, std::move(callback), p_foo);
        break;
      }
      default:
      {
        apache::thrift::detail::ac::throw_app_exn("Could not find Protocol");
      }
    }
  }
  
  std::pair<std::unique_ptr<::apache::thrift::ContextStack>, std::shared_ptr<::apache::thrift::transport::THeader>> NestedContainersAsyncClient::turtlesCtx(apache::thrift::RpcOptions* rpcOptions) {
    auto header = std::make_shared<apache::thrift::transport::THeader>(
        apache::thrift::transport::THeader::ALLOW_BIG_FRAMES);
    header->setProtocolId(channel_->getProtocolId());
    if (rpcOptions) {
      header->setHeaders(rpcOptions->releaseWriteHeaders());
    }
  
    auto ctx = apache::thrift::ContextStack::createWithClientContext(
        handlers_,
        getServiceName(),
        "NestedContainers.turtles",
        *header);
  
    return {std::move(ctx), std::move(header)};
  }
  
  void NestedContainersAsyncClient::sync_turtles(const ::std::vector<::std::vector<::std::map<::std::int32_t, ::std::map<::std::int32_t, ::std::set<::std::int32_t>>>>>& p_foo) {
    ::apache::thrift::RpcOptions rpcOptions;
    sync_turtles(rpcOptions, p_foo);
  }
  
  void NestedContainersAsyncClient::sync_turtles(apache::thrift::RpcOptions& rpcOptions, const ::std::vector<::std::vector<::std::map<::std::int32_t, ::std::map<::std::int32_t, ::std::set<::std::int32_t>>>>>& p_foo) {
    apache::thrift::ClientReceiveState returnState;
    apache::thrift::ClientSyncCallback<false> callback(&returnState);
    auto protocolId = apache::thrift::GeneratedAsyncClient::getChannel()->getProtocolId();
    auto evb = apache::thrift::GeneratedAsyncClient::getChannel()->getEventBase();
    auto [ctx, header] = turtlesCtx(&rpcOptions);
    auto wrappedCallback = apache::thrift::RequestClientCallback::Ptr(&callback);
    turtlesImpl(rpcOptions, std::move(header), ctx.get(), std::move(wrappedCallback), p_foo);
    callback.waitUntilDone(evb);
  
    if (returnState.isException()) {
      returnState.exception().throw_exception();
    }
    returnState.resetProtocolId(protocolId);
    returnState.resetCtx(std::move(ctx));
    SCOPE_EXIT {
      if (returnState.header() && !returnState.header()->getHeaders().empty()) {
        rpcOptions.setReadHeaders(returnState.header()->releaseHeaders());
      }
    };
    return folly::fibers::runInMainContext([&] {
        recv_turtles(returnState);
    });
  }
  
  
  folly::Future<folly::Unit> NestedContainersAsyncClient::future_turtles(const ::std::vector<::std::vector<::std::map<::std::int32_t, ::std::map<::std::int32_t, ::std::set<::std::int32_t>>>>>& p_foo) {
    ::apache::thrift::RpcOptions rpcOptions;
    return future_turtles(rpcOptions, p_foo);
  }
  
  folly::SemiFuture<folly::Unit> NestedContainersAsyncClient::semifuture_turtles(const ::std::vector<::std::vector<::std::map<::std::int32_t, ::std::map<::std::int32_t, ::std::set<::std::int32_t>>>>>& p_foo) {
    ::apache::thrift::RpcOptions rpcOptions;
    return semifuture_turtles(rpcOptions, p_foo);
  }
  
  folly::Future<folly::Unit> NestedContainersAsyncClient::future_turtles(apache::thrift::RpcOptions& rpcOptions, const ::std::vector<::std::vector<::std::map<::std::int32_t, ::std::map<::std::int32_t, ::std::set<::std::int32_t>>>>>& p_foo) {
    folly::Promise<folly::Unit> promise;
    auto future = promise.getFuture();
    auto callback = std::make_unique<apache::thrift::FutureCallback<folly::Unit>>(std::move(promise), recv_wrapped_turtles, channel_);
    turtles(rpcOptions, std::move(callback), p_foo);
    return future;
  }
  
  folly::SemiFuture<folly::Unit> NestedContainersAsyncClient::semifuture_turtles(apache::thrift::RpcOptions& rpcOptions, const ::std::vector<::std::vector<::std::map<::std::int32_t, ::std::map<::std::int32_t, ::std::set<::std::int32_t>>>>>& p_foo) {
    auto callbackAndFuture = makeSemiFutureCallback(recv_wrapped_turtles, channel_);
    auto callback = std::move(callbackAndFuture.first);
    turtles(rpcOptions, std::move(callback), p_foo);
    return std::move(callbackAndFuture.second);
  }
  
  folly::Future<std::pair<folly::Unit, std::unique_ptr<apache::thrift::transport::THeader>>> NestedContainersAsyncClient::header_future_turtles(apache::thrift::RpcOptions& rpcOptions, const ::std::vector<::std::vector<::std::map<::std::int32_t, ::std::map<::std::int32_t, ::std::set<::std::int32_t>>>>>& p_foo) {
    folly::Promise<std::pair<folly::Unit, std::unique_ptr<apache::thrift::transport::THeader>>> promise;
    auto future = promise.getFuture();
    auto callback = std::make_unique<apache::thrift::HeaderFutureCallback<folly::Unit>>(std::move(promise), recv_wrapped_turtles, channel_);
    turtles(rpcOptions, std::move(callback), p_foo);
    return future;
  }
  
  folly::SemiFuture<std::pair<folly::Unit, std::unique_ptr<apache::thrift::transport::THeader>>> NestedContainersAsyncClient::header_semifuture_turtles(apache::thrift::RpcOptions& rpcOptions, const ::std::vector<::std::vector<::std::map<::std::int32_t, ::std::map<::std::int32_t, ::std::set<::std::int32_t>>>>>& p_foo) {
    auto callbackAndFuture = makeHeaderSemiFutureCallback(recv_wrapped_turtles, channel_);
    auto callback = std::move(callbackAndFuture.first);
    turtles(rpcOptions, std::move(callback), p_foo);
    return std::move(callbackAndFuture.second);
  }
  
  void NestedContainersAsyncClient::turtles(folly::Function<void (::apache::thrift::ClientReceiveState&&)> callback, const ::std::vector<::std::vector<::std::map<::std::int32_t, ::std::map<::std::int32_t, ::std::set<::std::int32_t>>>>>& p_foo) {
    turtles(std::make_unique<apache::thrift::FunctionReplyCallback>(std::move(callback)), p_foo);
  }
  
  #if FOLLY_HAS_COROUTINES
  #endif // FOLLY_HAS_COROUTINES
  folly::exception_wrapper NestedContainersAsyncClient::recv_wrapped_turtles(::apache::thrift::ClientReceiveState& state) {
    if (state.isException()) {
      return std::move(state.exception());
    }
    if (!state.hasResponseBuffer()) {
      return folly::make_exception_wrapper<apache::thrift::TApplicationException>("recv_ called without result");
    }
  
    using result = NestedContainers_turtles_presult;
    switch (state.protocolId()) {
      case apache::thrift::protocol::T_BINARY_PROTOCOL:
      {
        apache::thrift::BinaryProtocolReader reader;
        return apache::thrift::detail::ac::recv_wrapped<result>(
            &reader, state);
      }
      case apache::thrift::protocol::T_COMPACT_PROTOCOL:
      {
        apache::thrift::CompactProtocolReader reader;
        return apache::thrift::detail::ac::recv_wrapped<result>(
            &reader, state);
      }
      default:
      {
      }
    }
    return folly::make_exception_wrapper<apache::thrift::TApplicationException>("Could not find Protocol");
  }
  
  void NestedContainersAsyncClient::recv_turtles(::apache::thrift::ClientReceiveState& state) {
    auto ew = recv_wrapped_turtles(state);
    if (ew) {
      ew.throw_exception();
    }
  }
  
  void NestedContainersAsyncClient::recv_instance_turtles(::apache::thrift::ClientReceiveState& state) {
    recv_turtles(state);
  }
  
  folly::exception_wrapper NestedContainersAsyncClient::recv_instance_wrapped_turtles(::apache::thrift::ClientReceiveState& state) {
    return recv_wrapped_turtles(state);
  }
  
  
  } // cpp2
  