/**
 * Autogenerated by Thrift for /opt/local/var/macports/build/_opt_PPCSnowLeopardPorts_devel_fbthrift/fbthrift/work/fbthrift-2025.01.13.00/thrift/lib/cpp2/test/ProtocolBenchData.thrift
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 *  @generated @nocommit
 */
#pragma once

#include <thrift/lib/cpp2/visitation/visit_by_thrift_field_metadata.h>
#include "thrift/lib/cpp2/test/gen-cpp2/ProtocolBenchData_metadata.h"

namespace apache {
namespace thrift {
namespace detail {

template <>
struct VisitByFieldId<::thrift::benchmark::Empty> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::Empty");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::SmallInt> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).smallint_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::SmallInt");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::BigInt> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).bigint_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::BigInt");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::SmallString> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).str_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::SmallString");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::BigString> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).str_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::BigString");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::BigBinary> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).bin_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::BigBinary");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::LargeBinary> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).bin_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::LargeBinary");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::Mixed> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).int32_ref());
    case 2:
      return f(1, static_cast<T&&>(t).int64_ref());
    case 3:
      return f(2, static_cast<T&&>(t).b_ref());
    case 4:
      return f(3, static_cast<T&&>(t).str_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::Mixed");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::SmallListInt> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).lst_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::SmallListInt");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::BigListInt> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).lst_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::BigListInt");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::BigListMixed> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).lst_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::BigListMixed");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::LargeListMixed> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).lst_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::LargeListMixed");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::LargeSetInt> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).s_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::LargeSetInt");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::UnorderedSetInt> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).s_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::UnorderedSetInt");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::SortedVecSetInt> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).s_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::SortedVecSetInt");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::LargeMapInt> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).m_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::LargeMapInt");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::LargeMapMixed> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).m_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::LargeMapMixed");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::LargeUnorderedMapMixed> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).m_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::LargeUnorderedMapMixed");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::LargeSortedVecMapMixed> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).m_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::LargeSortedVecMapMixed");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::NestedMapRaw> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).m_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::NestedMapRaw");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::NestedMap1> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).m_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::NestedMap1");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::NestedMap2> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).m_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::NestedMap2");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::NestedMap3> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).m_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::NestedMap3");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::NestedMap4> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).m_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::NestedMap4");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::NestedMap> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).m_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::NestedMap");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::SortedVecNestedMapRaw> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).m_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::SortedVecNestedMapRaw");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::SortedVecNestedMap1> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).m_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::SortedVecNestedMap1");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::SortedVecNestedMap2> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).m_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::SortedVecNestedMap2");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::SortedVecNestedMap3> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).m_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::SortedVecNestedMap3");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::SortedVecNestedMap4> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).m_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::SortedVecNestedMap4");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::SortedVecNestedMap> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).m_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::SortedVecNestedMap");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::UnorderedMapInt> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).m_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::UnorderedMapInt");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::LargeMixed> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).var1_ref());
    case 2:
      return f(1, static_cast<T&&>(t).var2_ref());
    case 3:
      return f(2, static_cast<T&&>(t).var3_ref());
    case 4:
      return f(3, static_cast<T&&>(t).var4_ref());
    case 5:
      return f(4, static_cast<T&&>(t).var5_ref());
    case 6:
      return f(5, static_cast<T&&>(t).var6_ref());
    case 7:
      return f(6, static_cast<T&&>(t).var7_ref());
    case 8:
      return f(7, static_cast<T&&>(t).var8_ref());
    case 9:
      return f(8, static_cast<T&&>(t).var9_ref());
    case 10:
      return f(9, static_cast<T&&>(t).var10_ref());
    case 11:
      return f(10, static_cast<T&&>(t).var11_ref());
    case 12:
      return f(11, static_cast<T&&>(t).var12_ref());
    case 13:
      return f(12, static_cast<T&&>(t).var13_ref());
    case 14:
      return f(13, static_cast<T&&>(t).var14_ref());
    case 15:
      return f(14, static_cast<T&&>(t).var15_ref());
    case 16:
      return f(15, static_cast<T&&>(t).var16_ref());
    case 17:
      return f(16, static_cast<T&&>(t).var17_ref());
    case 18:
      return f(17, static_cast<T&&>(t).var18_ref());
    case 19:
      return f(18, static_cast<T&&>(t).var19_ref());
    case 20:
      return f(19, static_cast<T&&>(t).var20_ref());
    case 21:
      return f(20, static_cast<T&&>(t).var21_ref());
    case 22:
      return f(21, static_cast<T&&>(t).var22_ref());
    case 23:
      return f(22, static_cast<T&&>(t).var23_ref());
    case 24:
      return f(23, static_cast<T&&>(t).var24_ref());
    case 25:
      return f(24, static_cast<T&&>(t).var25_ref());
    case 26:
      return f(25, static_cast<T&&>(t).var26_ref());
    case 27:
      return f(26, static_cast<T&&>(t).var27_ref());
    case 28:
      return f(27, static_cast<T&&>(t).var28_ref());
    case 29:
      return f(28, static_cast<T&&>(t).var29_ref());
    case 30:
      return f(29, static_cast<T&&>(t).var30_ref());
    case 31:
      return f(30, static_cast<T&&>(t).var31_ref());
    case 32:
      return f(31, static_cast<T&&>(t).var32_ref());
    case 33:
      return f(32, static_cast<T&&>(t).var33_ref());
    case 34:
      return f(33, static_cast<T&&>(t).var34_ref());
    case 35:
      return f(34, static_cast<T&&>(t).var35_ref());
    case 36:
      return f(35, static_cast<T&&>(t).var36_ref());
    case 37:
      return f(36, static_cast<T&&>(t).var37_ref());
    case 38:
      return f(37, static_cast<T&&>(t).var38_ref());
    case 39:
      return f(38, static_cast<T&&>(t).var39_ref());
    case 40:
      return f(39, static_cast<T&&>(t).var40_ref());
    case 41:
      return f(40, static_cast<T&&>(t).var41_ref());
    case 42:
      return f(41, static_cast<T&&>(t).var42_ref());
    case 43:
      return f(42, static_cast<T&&>(t).var43_ref());
    case 44:
      return f(43, static_cast<T&&>(t).var44_ref());
    case 45:
      return f(44, static_cast<T&&>(t).var45_ref());
    case 46:
      return f(45, static_cast<T&&>(t).var46_ref());
    case 47:
      return f(46, static_cast<T&&>(t).var47_ref());
    case 48:
      return f(47, static_cast<T&&>(t).var48_ref());
    case 49:
      return f(48, static_cast<T&&>(t).var49_ref());
    case 50:
      return f(49, static_cast<T&&>(t).var50_ref());
    case 51:
      return f(50, static_cast<T&&>(t).var51_ref());
    case 52:
      return f(51, static_cast<T&&>(t).var52_ref());
    case 53:
      return f(52, static_cast<T&&>(t).var53_ref());
    case 54:
      return f(53, static_cast<T&&>(t).var54_ref());
    case 55:
      return f(54, static_cast<T&&>(t).var55_ref());
    case 56:
      return f(55, static_cast<T&&>(t).var56_ref());
    case 57:
      return f(56, static_cast<T&&>(t).var57_ref());
    case 58:
      return f(57, static_cast<T&&>(t).var58_ref());
    case 59:
      return f(58, static_cast<T&&>(t).var59_ref());
    case 60:
      return f(59, static_cast<T&&>(t).var60_ref());
    case 61:
      return f(60, static_cast<T&&>(t).var61_ref());
    case 62:
      return f(61, static_cast<T&&>(t).var62_ref());
    case 63:
      return f(62, static_cast<T&&>(t).var63_ref());
    case 64:
      return f(63, static_cast<T&&>(t).var64_ref());
    case 65:
      return f(64, static_cast<T&&>(t).var65_ref());
    case 66:
      return f(65, static_cast<T&&>(t).var66_ref());
    case 67:
      return f(66, static_cast<T&&>(t).var67_ref());
    case 68:
      return f(67, static_cast<T&&>(t).var68_ref());
    case 69:
      return f(68, static_cast<T&&>(t).var69_ref());
    case 70:
      return f(69, static_cast<T&&>(t).var70_ref());
    case 71:
      return f(70, static_cast<T&&>(t).var71_ref());
    case 72:
      return f(71, static_cast<T&&>(t).var72_ref());
    case 73:
      return f(72, static_cast<T&&>(t).var73_ref());
    case 74:
      return f(73, static_cast<T&&>(t).var74_ref());
    case 75:
      return f(74, static_cast<T&&>(t).var75_ref());
    case 76:
      return f(75, static_cast<T&&>(t).var76_ref());
    case 77:
      return f(76, static_cast<T&&>(t).var77_ref());
    case 78:
      return f(77, static_cast<T&&>(t).var78_ref());
    case 79:
      return f(78, static_cast<T&&>(t).var79_ref());
    case 80:
      return f(79, static_cast<T&&>(t).var80_ref());
    case 81:
      return f(80, static_cast<T&&>(t).var81_ref());
    case 82:
      return f(81, static_cast<T&&>(t).var82_ref());
    case 83:
      return f(82, static_cast<T&&>(t).var83_ref());
    case 84:
      return f(83, static_cast<T&&>(t).var84_ref());
    case 85:
      return f(84, static_cast<T&&>(t).var85_ref());
    case 86:
      return f(85, static_cast<T&&>(t).var86_ref());
    case 87:
      return f(86, static_cast<T&&>(t).var87_ref());
    case 88:
      return f(87, static_cast<T&&>(t).var88_ref());
    case 89:
      return f(88, static_cast<T&&>(t).var89_ref());
    case 90:
      return f(89, static_cast<T&&>(t).var90_ref());
    case 91:
      return f(90, static_cast<T&&>(t).var91_ref());
    case 92:
      return f(91, static_cast<T&&>(t).var92_ref());
    case 93:
      return f(92, static_cast<T&&>(t).var93_ref());
    case 94:
      return f(93, static_cast<T&&>(t).var94_ref());
    case 95:
      return f(94, static_cast<T&&>(t).var95_ref());
    case 96:
      return f(95, static_cast<T&&>(t).var96_ref());
    case 97:
      return f(96, static_cast<T&&>(t).var97_ref());
    case 98:
      return f(97, static_cast<T&&>(t).var98_ref());
    case 99:
      return f(98, static_cast<T&&>(t).var99_ref());
    case 100:
      return f(99, static_cast<T&&>(t).var100_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::LargeMixed");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::MixedInt> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).var1_ref());
    case 2:
      return f(1, static_cast<T&&>(t).var2_ref());
    case 3:
      return f(2, static_cast<T&&>(t).var3_ref());
    case 4:
      return f(3, static_cast<T&&>(t).var4_ref());
    case 5:
      return f(4, static_cast<T&&>(t).var5_ref());
    case 6:
      return f(5, static_cast<T&&>(t).var6_ref());
    case 7:
      return f(6, static_cast<T&&>(t).var7_ref());
    case 8:
      return f(7, static_cast<T&&>(t).var8_ref());
    case 9:
      return f(8, static_cast<T&&>(t).var9_ref());
    case 10:
      return f(9, static_cast<T&&>(t).varx_ref());
    case 11:
      return f(10, static_cast<T&&>(t).vary_ref());
    case 12:
      return f(11, static_cast<T&&>(t).varz_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::MixedInt");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::BigListMixedInt> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).lst_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::BigListMixedInt");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::ComplexStruct> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).var1_ref());
    case 2:
      return f(1, static_cast<T&&>(t).var2_ref());
    case 4:
      return f(2, static_cast<T&&>(t).var3_ref());
    case 7:
      return f(3, static_cast<T&&>(t).var4_ref());
    case 11:
      return f(4, static_cast<T&&>(t).var5_ref());
    case 16:
      return f(5, static_cast<T&&>(t).var6_ref());
    case 22:
      return f(6, static_cast<T&&>(t).var7_ref());
    case 29:
      return f(7, static_cast<T&&>(t).var8_ref());
    case 37:
      return f(8, static_cast<T&&>(t).var9_ref());
    case 46:
      return f(9, static_cast<T&&>(t).var10_ref());
    case 56:
      return f(10, static_cast<T&&>(t).var11_ref());
    case 67:
      return f(11, static_cast<T&&>(t).var12_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::ComplexStruct");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::OpEmpty> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::OpEmpty");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::OpSmallInt> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).smallint_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::OpSmallInt");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::OpBigInt> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).bigint_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::OpBigInt");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::OpSmallString> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).str_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::OpSmallString");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::OpBigString> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).str_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::OpBigString");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::OpMixed> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).int32_ref());
    case 2:
      return f(1, static_cast<T&&>(t).int64_ref());
    case 3:
      return f(2, static_cast<T&&>(t).b_ref());
    case 4:
      return f(3, static_cast<T&&>(t).str_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::OpMixed");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::OpSmallListInt> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).lst_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::OpSmallListInt");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::OpBigListInt> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).lst_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::OpBigListInt");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::OpBigListMixed> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).lst_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::OpBigListMixed");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::OpLargeListMixed> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).lst_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::OpLargeListMixed");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::OpLargeSetInt> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).s_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::OpLargeSetInt");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::OpUnorderedSetInt> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).s_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::OpUnorderedSetInt");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::OpSortedVecSetInt> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).s_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::OpSortedVecSetInt");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::OpLargeMapInt> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).m_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::OpLargeMapInt");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::OpLargeMapMixed> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).m_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::OpLargeMapMixed");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::OpLargeUnorderedMapMixed> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).m_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::OpLargeUnorderedMapMixed");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::OpLargeSortedVecMapMixed> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).m_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::OpLargeSortedVecMapMixed");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::OpNestedMap1> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).m_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::OpNestedMap1");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::OpNestedMap2> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).m_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::OpNestedMap2");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::OpNestedMap3> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).m_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::OpNestedMap3");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::OpNestedMap4> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).m_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::OpNestedMap4");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::OpNestedMap> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).m_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::OpNestedMap");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::OpSortedVecNestedMapRaw> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).m_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::OpSortedVecNestedMapRaw");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::OpSortedVecNestedMap1> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).m_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::OpSortedVecNestedMap1");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::OpSortedVecNestedMap2> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).m_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::OpSortedVecNestedMap2");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::OpSortedVecNestedMap3> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).m_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::OpSortedVecNestedMap3");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::OpSortedVecNestedMap4> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).m_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::OpSortedVecNestedMap4");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::OpSortedVecNestedMap> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).m_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::OpSortedVecNestedMap");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::OpUnorderedMapInt> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).m_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::OpUnorderedMapInt");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::OpLargeMixed> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).var1_ref());
    case 2:
      return f(1, static_cast<T&&>(t).var2_ref());
    case 3:
      return f(2, static_cast<T&&>(t).var3_ref());
    case 4:
      return f(3, static_cast<T&&>(t).var4_ref());
    case 5:
      return f(4, static_cast<T&&>(t).var5_ref());
    case 6:
      return f(5, static_cast<T&&>(t).var6_ref());
    case 7:
      return f(6, static_cast<T&&>(t).var7_ref());
    case 8:
      return f(7, static_cast<T&&>(t).var8_ref());
    case 9:
      return f(8, static_cast<T&&>(t).var9_ref());
    case 10:
      return f(9, static_cast<T&&>(t).var10_ref());
    case 11:
      return f(10, static_cast<T&&>(t).var11_ref());
    case 12:
      return f(11, static_cast<T&&>(t).var12_ref());
    case 13:
      return f(12, static_cast<T&&>(t).var13_ref());
    case 14:
      return f(13, static_cast<T&&>(t).var14_ref());
    case 15:
      return f(14, static_cast<T&&>(t).var15_ref());
    case 16:
      return f(15, static_cast<T&&>(t).var16_ref());
    case 17:
      return f(16, static_cast<T&&>(t).var17_ref());
    case 18:
      return f(17, static_cast<T&&>(t).var18_ref());
    case 19:
      return f(18, static_cast<T&&>(t).var19_ref());
    case 20:
      return f(19, static_cast<T&&>(t).var20_ref());
    case 21:
      return f(20, static_cast<T&&>(t).var21_ref());
    case 22:
      return f(21, static_cast<T&&>(t).var22_ref());
    case 23:
      return f(22, static_cast<T&&>(t).var23_ref());
    case 24:
      return f(23, static_cast<T&&>(t).var24_ref());
    case 25:
      return f(24, static_cast<T&&>(t).var25_ref());
    case 26:
      return f(25, static_cast<T&&>(t).var26_ref());
    case 27:
      return f(26, static_cast<T&&>(t).var27_ref());
    case 28:
      return f(27, static_cast<T&&>(t).var28_ref());
    case 29:
      return f(28, static_cast<T&&>(t).var29_ref());
    case 30:
      return f(29, static_cast<T&&>(t).var30_ref());
    case 31:
      return f(30, static_cast<T&&>(t).var31_ref());
    case 32:
      return f(31, static_cast<T&&>(t).var32_ref());
    case 33:
      return f(32, static_cast<T&&>(t).var33_ref());
    case 34:
      return f(33, static_cast<T&&>(t).var34_ref());
    case 35:
      return f(34, static_cast<T&&>(t).var35_ref());
    case 36:
      return f(35, static_cast<T&&>(t).var36_ref());
    case 37:
      return f(36, static_cast<T&&>(t).var37_ref());
    case 38:
      return f(37, static_cast<T&&>(t).var38_ref());
    case 39:
      return f(38, static_cast<T&&>(t).var39_ref());
    case 40:
      return f(39, static_cast<T&&>(t).var40_ref());
    case 41:
      return f(40, static_cast<T&&>(t).var41_ref());
    case 42:
      return f(41, static_cast<T&&>(t).var42_ref());
    case 43:
      return f(42, static_cast<T&&>(t).var43_ref());
    case 44:
      return f(43, static_cast<T&&>(t).var44_ref());
    case 45:
      return f(44, static_cast<T&&>(t).var45_ref());
    case 46:
      return f(45, static_cast<T&&>(t).var46_ref());
    case 47:
      return f(46, static_cast<T&&>(t).var47_ref());
    case 48:
      return f(47, static_cast<T&&>(t).var48_ref());
    case 49:
      return f(48, static_cast<T&&>(t).var49_ref());
    case 50:
      return f(49, static_cast<T&&>(t).var50_ref());
    case 51:
      return f(50, static_cast<T&&>(t).var51_ref());
    case 52:
      return f(51, static_cast<T&&>(t).var52_ref());
    case 53:
      return f(52, static_cast<T&&>(t).var53_ref());
    case 54:
      return f(53, static_cast<T&&>(t).var54_ref());
    case 55:
      return f(54, static_cast<T&&>(t).var55_ref());
    case 56:
      return f(55, static_cast<T&&>(t).var56_ref());
    case 57:
      return f(56, static_cast<T&&>(t).var57_ref());
    case 58:
      return f(57, static_cast<T&&>(t).var58_ref());
    case 59:
      return f(58, static_cast<T&&>(t).var59_ref());
    case 60:
      return f(59, static_cast<T&&>(t).var60_ref());
    case 61:
      return f(60, static_cast<T&&>(t).var61_ref());
    case 62:
      return f(61, static_cast<T&&>(t).var62_ref());
    case 63:
      return f(62, static_cast<T&&>(t).var63_ref());
    case 64:
      return f(63, static_cast<T&&>(t).var64_ref());
    case 65:
      return f(64, static_cast<T&&>(t).var65_ref());
    case 66:
      return f(65, static_cast<T&&>(t).var66_ref());
    case 67:
      return f(66, static_cast<T&&>(t).var67_ref());
    case 68:
      return f(67, static_cast<T&&>(t).var68_ref());
    case 69:
      return f(68, static_cast<T&&>(t).var69_ref());
    case 70:
      return f(69, static_cast<T&&>(t).var70_ref());
    case 71:
      return f(70, static_cast<T&&>(t).var71_ref());
    case 72:
      return f(71, static_cast<T&&>(t).var72_ref());
    case 73:
      return f(72, static_cast<T&&>(t).var73_ref());
    case 74:
      return f(73, static_cast<T&&>(t).var74_ref());
    case 75:
      return f(74, static_cast<T&&>(t).var75_ref());
    case 76:
      return f(75, static_cast<T&&>(t).var76_ref());
    case 77:
      return f(76, static_cast<T&&>(t).var77_ref());
    case 78:
      return f(77, static_cast<T&&>(t).var78_ref());
    case 79:
      return f(78, static_cast<T&&>(t).var79_ref());
    case 80:
      return f(79, static_cast<T&&>(t).var80_ref());
    case 81:
      return f(80, static_cast<T&&>(t).var81_ref());
    case 82:
      return f(81, static_cast<T&&>(t).var82_ref());
    case 83:
      return f(82, static_cast<T&&>(t).var83_ref());
    case 84:
      return f(83, static_cast<T&&>(t).var84_ref());
    case 85:
      return f(84, static_cast<T&&>(t).var85_ref());
    case 86:
      return f(85, static_cast<T&&>(t).var86_ref());
    case 87:
      return f(86, static_cast<T&&>(t).var87_ref());
    case 88:
      return f(87, static_cast<T&&>(t).var88_ref());
    case 89:
      return f(88, static_cast<T&&>(t).var89_ref());
    case 90:
      return f(89, static_cast<T&&>(t).var90_ref());
    case 91:
      return f(90, static_cast<T&&>(t).var91_ref());
    case 92:
      return f(91, static_cast<T&&>(t).var92_ref());
    case 93:
      return f(92, static_cast<T&&>(t).var93_ref());
    case 94:
      return f(93, static_cast<T&&>(t).var94_ref());
    case 95:
      return f(94, static_cast<T&&>(t).var95_ref());
    case 96:
      return f(95, static_cast<T&&>(t).var96_ref());
    case 97:
      return f(96, static_cast<T&&>(t).var97_ref());
    case 98:
      return f(97, static_cast<T&&>(t).var98_ref());
    case 99:
      return f(98, static_cast<T&&>(t).var99_ref());
    case 100:
      return f(99, static_cast<T&&>(t).var100_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::OpLargeMixed");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::OpMixedInt> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).var1_ref());
    case 2:
      return f(1, static_cast<T&&>(t).var2_ref());
    case 3:
      return f(2, static_cast<T&&>(t).var3_ref());
    case 4:
      return f(3, static_cast<T&&>(t).var4_ref());
    case 5:
      return f(4, static_cast<T&&>(t).var5_ref());
    case 6:
      return f(5, static_cast<T&&>(t).var6_ref());
    case 7:
      return f(6, static_cast<T&&>(t).var7_ref());
    case 8:
      return f(7, static_cast<T&&>(t).var8_ref());
    case 9:
      return f(8, static_cast<T&&>(t).var9_ref());
    case 10:
      return f(9, static_cast<T&&>(t).varx_ref());
    case 11:
      return f(10, static_cast<T&&>(t).vary_ref());
    case 12:
      return f(11, static_cast<T&&>(t).varz_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::OpMixedInt");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::OpBigListMixedInt> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).lst_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::OpBigListMixedInt");
    }
  }
};

template <>
struct VisitByFieldId<::thrift::benchmark::OpComplexStruct> {
  template <typename F, typename T>
  void operator()([[maybe_unused]] F&& f, int32_t fieldId, [[maybe_unused]] T&& t) const {
    switch (fieldId) {
    case 1:
      return f(0, static_cast<T&&>(t).var1_ref());
    case 2:
      return f(1, static_cast<T&&>(t).var2_ref());
    case 4:
      return f(2, static_cast<T&&>(t).var3_ref());
    case 7:
      return f(3, static_cast<T&&>(t).var4_ref());
    case 11:
      return f(4, static_cast<T&&>(t).var5_ref());
    case 16:
      return f(5, static_cast<T&&>(t).var6_ref());
    case 22:
      return f(6, static_cast<T&&>(t).var7_ref());
    case 29:
      return f(7, static_cast<T&&>(t).var8_ref());
    case 37:
      return f(8, static_cast<T&&>(t).var9_ref());
    case 46:
      return f(9, static_cast<T&&>(t).var10_ref());
    case 56:
      return f(10, static_cast<T&&>(t).var11_ref());
    case 67:
      return f(11, static_cast<T&&>(t).var12_ref());
    default:
      throwInvalidThriftId(fieldId, "::thrift::benchmark::OpComplexStruct");
    }
  }
};
} // namespace detail
} // namespace thrift
} // namespace apache
