// WARNING: This file is machine generated by fidlgen.

// fidl_experiment = output_index_json

#pragma once

#include <fidl/test.table/cpp/natural_types.h>
#include <lib/fidl/cpp/hlcpp_conversion.h>
#include <lib/fidl/cpp/wire/service_handler.h>
#include <test/table/cpp/fidl.h>

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wshadow"

namespace fidl {
namespace internal {

template <>
struct NaturalToHLCPPTraits<::test_table::EmptyTable> {
  using HLCPPType = ::test::table::EmptyTable;
  static inline ::test::table::EmptyTable Convert(::test_table::EmptyTable&&);
};
template <>
struct HLCPPToNaturalTraits<::test::table::EmptyTable> {
  using NaturalType = ::test_table::EmptyTable;
  static inline ::test_table::EmptyTable Convert(::test::table::EmptyTable&&);
};
template <>
struct NaturalToHLCPPTraits<::test_table::SimpleTable> {
  using HLCPPType = ::test::table::SimpleTable;
  static inline ::test::table::SimpleTable Convert(::test_table::SimpleTable&&);
};
template <>
struct HLCPPToNaturalTraits<::test::table::SimpleTable> {
  using NaturalType = ::test_table::SimpleTable;
  static inline ::test_table::SimpleTable Convert(::test::table::SimpleTable&&);
};
template <>
struct NaturalToHLCPPTraits<::test_table::OlderSimpleTable> {
  using HLCPPType = ::test::table::OlderSimpleTable;
  static inline ::test::table::OlderSimpleTable Convert(::test_table::OlderSimpleTable&&);
};
template <>
struct HLCPPToNaturalTraits<::test::table::OlderSimpleTable> {
  using NaturalType = ::test_table::OlderSimpleTable;
  static inline ::test_table::OlderSimpleTable Convert(::test::table::OlderSimpleTable&&);
};
template <>
struct NaturalToHLCPPTraits<::test_table::NewerSimpleTable> {
  using HLCPPType = ::test::table::NewerSimpleTable;
  static inline ::test::table::NewerSimpleTable Convert(::test_table::NewerSimpleTable&&);
};
template <>
struct HLCPPToNaturalTraits<::test::table::NewerSimpleTable> {
  using NaturalType = ::test_table::NewerSimpleTable;
  static inline ::test_table::NewerSimpleTable Convert(::test::table::NewerSimpleTable&&);
};
template <>
struct NaturalToHLCPPTraits<::test_table::ReverseOrdinalTable> {
  using HLCPPType = ::test::table::ReverseOrdinalTable;
  static inline ::test::table::ReverseOrdinalTable Convert(::test_table::ReverseOrdinalTable&&);
};
template <>
struct HLCPPToNaturalTraits<::test::table::ReverseOrdinalTable> {
  using NaturalType = ::test_table::ReverseOrdinalTable;
  static inline ::test_table::ReverseOrdinalTable Convert(::test::table::ReverseOrdinalTable&&);
};
template <>
struct NaturalToHLCPPTraits<::test_table::TableWithAttributes> {
  using HLCPPType = ::test::table::TableWithAttributes;
  static inline ::test::table::TableWithAttributes Convert(::test_table::TableWithAttributes&&);
};
template <>
struct HLCPPToNaturalTraits<::test::table::TableWithAttributes> {
  using NaturalType = ::test_table::TableWithAttributes;
  static inline ::test_table::TableWithAttributes Convert(::test::table::TableWithAttributes&&);
};
template <>
struct NaturalToHLCPPTraits<::test_table::ExtensionTable> {
  using HLCPPType = ::test::table::ExtensionTable;
  static inline ::test::table::ExtensionTable Convert(::test_table::ExtensionTable&&);
};
template <>
struct HLCPPToNaturalTraits<::test::table::ExtensionTable> {
  using NaturalType = ::test_table::ExtensionTable;
  static inline ::test_table::ExtensionTable Convert(::test::table::ExtensionTable&&);
};
template <>
struct NaturalToHLCPPTraits<::test_table::SixtyFourOrdinalTable> {
  using HLCPPType = ::test::table::SixtyFourOrdinalTable;
  static inline ::test::table::SixtyFourOrdinalTable Convert(::test_table::SixtyFourOrdinalTable&&);
};
template <>
struct HLCPPToNaturalTraits<::test::table::SixtyFourOrdinalTable> {
  using NaturalType = ::test_table::SixtyFourOrdinalTable;
  static inline ::test_table::SixtyFourOrdinalTable Convert(::test::table::SixtyFourOrdinalTable&&);
};

::test::table::EmptyTable NaturalToHLCPPTraits<::test_table::EmptyTable>::Convert(::test_table::EmptyTable&& value) {
  ::test::table::EmptyTable hlcpp;
  return hlcpp;
}

::test_table::EmptyTable HLCPPToNaturalTraits<::test::table::EmptyTable>::Convert(::test::table::EmptyTable&& value) {
  ::test_table::EmptyTable natural;
  return natural;
}
::test::table::SimpleTable NaturalToHLCPPTraits<::test_table::SimpleTable>::Convert(::test_table::SimpleTable&& value) {
  ::test::table::SimpleTable hlcpp;
  if (value.x().has_value()) {
    hlcpp.set_x(::fidl::NaturalToHLCPP(std::move(value.x().value())));
  }
  if (value.y().has_value()) {
    hlcpp.set_y(::fidl::NaturalToHLCPP(std::move(value.y().value())));
  }
  return hlcpp;
}

::test_table::SimpleTable HLCPPToNaturalTraits<::test::table::SimpleTable>::Convert(::test::table::SimpleTable&& value) {
  ::test_table::SimpleTable natural;
  if (value.has_x()) {
    natural.x() = ::fidl::HLCPPToNatural(std::move(*value.mutable_x()));
  }
  if (value.has_y()) {
    natural.y() = ::fidl::HLCPPToNatural(std::move(*value.mutable_y()));
  }
  return natural;
}
::test::table::OlderSimpleTable NaturalToHLCPPTraits<::test_table::OlderSimpleTable>::Convert(::test_table::OlderSimpleTable&& value) {
  ::test::table::OlderSimpleTable hlcpp;
  if (value.x().has_value()) {
    hlcpp.set_x(::fidl::NaturalToHLCPP(std::move(value.x().value())));
  }
  return hlcpp;
}

::test_table::OlderSimpleTable HLCPPToNaturalTraits<::test::table::OlderSimpleTable>::Convert(::test::table::OlderSimpleTable&& value) {
  ::test_table::OlderSimpleTable natural;
  if (value.has_x()) {
    natural.x() = ::fidl::HLCPPToNatural(std::move(*value.mutable_x()));
  }
  return natural;
}
::test::table::NewerSimpleTable NaturalToHLCPPTraits<::test_table::NewerSimpleTable>::Convert(::test_table::NewerSimpleTable&& value) {
  ::test::table::NewerSimpleTable hlcpp;
  if (value.x().has_value()) {
    hlcpp.set_x(::fidl::NaturalToHLCPP(std::move(value.x().value())));
  }
  if (value.y().has_value()) {
    hlcpp.set_y(::fidl::NaturalToHLCPP(std::move(value.y().value())));
  }
  if (value.z().has_value()) {
    hlcpp.set_z(::fidl::NaturalToHLCPP(std::move(value.z().value())));
  }
  return hlcpp;
}

::test_table::NewerSimpleTable HLCPPToNaturalTraits<::test::table::NewerSimpleTable>::Convert(::test::table::NewerSimpleTable&& value) {
  ::test_table::NewerSimpleTable natural;
  if (value.has_x()) {
    natural.x() = ::fidl::HLCPPToNatural(std::move(*value.mutable_x()));
  }
  if (value.has_y()) {
    natural.y() = ::fidl::HLCPPToNatural(std::move(*value.mutable_y()));
  }
  if (value.has_z()) {
    natural.z() = ::fidl::HLCPPToNatural(std::move(*value.mutable_z()));
  }
  return natural;
}
::test::table::ReverseOrdinalTable NaturalToHLCPPTraits<::test_table::ReverseOrdinalTable>::Convert(::test_table::ReverseOrdinalTable&& value) {
  ::test::table::ReverseOrdinalTable hlcpp;
  if (value.z().has_value()) {
    hlcpp.set_z(::fidl::NaturalToHLCPP(std::move(value.z().value())));
  }
  if (value.y().has_value()) {
    hlcpp.set_y(::fidl::NaturalToHLCPP(std::move(value.y().value())));
  }
  if (value.x().has_value()) {
    hlcpp.set_x(::fidl::NaturalToHLCPP(std::move(value.x().value())));
  }
  return hlcpp;
}

::test_table::ReverseOrdinalTable HLCPPToNaturalTraits<::test::table::ReverseOrdinalTable>::Convert(::test::table::ReverseOrdinalTable&& value) {
  ::test_table::ReverseOrdinalTable natural;
  if (value.has_z()) {
    natural.z() = ::fidl::HLCPPToNatural(std::move(*value.mutable_z()));
  }
  if (value.has_y()) {
    natural.y() = ::fidl::HLCPPToNatural(std::move(*value.mutable_y()));
  }
  if (value.has_x()) {
    natural.x() = ::fidl::HLCPPToNatural(std::move(*value.mutable_x()));
  }
  return natural;
}
::test::table::TableWithAttributes NaturalToHLCPPTraits<::test_table::TableWithAttributes>::Convert(::test_table::TableWithAttributes&& value) {
  ::test::table::TableWithAttributes hlcpp;
  if (value.x().has_value()) {
    hlcpp.set_x(::fidl::NaturalToHLCPP(std::move(value.x().value())));
  }
  return hlcpp;
}

::test_table::TableWithAttributes HLCPPToNaturalTraits<::test::table::TableWithAttributes>::Convert(::test::table::TableWithAttributes&& value) {
  ::test_table::TableWithAttributes natural;
  if (value.has_x()) {
    natural.x() = ::fidl::HLCPPToNatural(std::move(*value.mutable_x()));
  }
  return natural;
}
::test::table::ExtensionTable NaturalToHLCPPTraits<::test_table::ExtensionTable>::Convert(::test_table::ExtensionTable&& value) {
  ::test::table::ExtensionTable hlcpp;
  return hlcpp;
}

::test_table::ExtensionTable HLCPPToNaturalTraits<::test::table::ExtensionTable>::Convert(::test::table::ExtensionTable&& value) {
  ::test_table::ExtensionTable natural;
  return natural;
}
::test::table::SixtyFourOrdinalTable NaturalToHLCPPTraits<::test_table::SixtyFourOrdinalTable>::Convert(::test_table::SixtyFourOrdinalTable&& value) {
  ::test::table::SixtyFourOrdinalTable hlcpp;
  if (value.v1().has_value()) {
    hlcpp.set_v1(::fidl::NaturalToHLCPP(std::move(value.v1().value())));
  }
  if (value.v2().has_value()) {
    hlcpp.set_v2(::fidl::NaturalToHLCPP(std::move(value.v2().value())));
  }
  if (value.v3().has_value()) {
    hlcpp.set_v3(::fidl::NaturalToHLCPP(std::move(value.v3().value())));
  }
  if (value.v4().has_value()) {
    hlcpp.set_v4(::fidl::NaturalToHLCPP(std::move(value.v4().value())));
  }
  if (value.v5().has_value()) {
    hlcpp.set_v5(::fidl::NaturalToHLCPP(std::move(value.v5().value())));
  }
  if (value.v6().has_value()) {
    hlcpp.set_v6(::fidl::NaturalToHLCPP(std::move(value.v6().value())));
  }
  if (value.v7().has_value()) {
    hlcpp.set_v7(::fidl::NaturalToHLCPP(std::move(value.v7().value())));
  }
  if (value.v8().has_value()) {
    hlcpp.set_v8(::fidl::NaturalToHLCPP(std::move(value.v8().value())));
  }
  if (value.v9().has_value()) {
    hlcpp.set_v9(::fidl::NaturalToHLCPP(std::move(value.v9().value())));
  }
  if (value.v10().has_value()) {
    hlcpp.set_v10(::fidl::NaturalToHLCPP(std::move(value.v10().value())));
  }
  if (value.v11().has_value()) {
    hlcpp.set_v11(::fidl::NaturalToHLCPP(std::move(value.v11().value())));
  }
  if (value.v12().has_value()) {
    hlcpp.set_v12(::fidl::NaturalToHLCPP(std::move(value.v12().value())));
  }
  if (value.v13().has_value()) {
    hlcpp.set_v13(::fidl::NaturalToHLCPP(std::move(value.v13().value())));
  }
  if (value.v14().has_value()) {
    hlcpp.set_v14(::fidl::NaturalToHLCPP(std::move(value.v14().value())));
  }
  if (value.v15().has_value()) {
    hlcpp.set_v15(::fidl::NaturalToHLCPP(std::move(value.v15().value())));
  }
  if (value.v16().has_value()) {
    hlcpp.set_v16(::fidl::NaturalToHLCPP(std::move(value.v16().value())));
  }
  if (value.v17().has_value()) {
    hlcpp.set_v17(::fidl::NaturalToHLCPP(std::move(value.v17().value())));
  }
  if (value.v18().has_value()) {
    hlcpp.set_v18(::fidl::NaturalToHLCPP(std::move(value.v18().value())));
  }
  if (value.v19().has_value()) {
    hlcpp.set_v19(::fidl::NaturalToHLCPP(std::move(value.v19().value())));
  }
  if (value.v20().has_value()) {
    hlcpp.set_v20(::fidl::NaturalToHLCPP(std::move(value.v20().value())));
  }
  if (value.v21().has_value()) {
    hlcpp.set_v21(::fidl::NaturalToHLCPP(std::move(value.v21().value())));
  }
  if (value.v22().has_value()) {
    hlcpp.set_v22(::fidl::NaturalToHLCPP(std::move(value.v22().value())));
  }
  if (value.v23().has_value()) {
    hlcpp.set_v23(::fidl::NaturalToHLCPP(std::move(value.v23().value())));
  }
  if (value.v24().has_value()) {
    hlcpp.set_v24(::fidl::NaturalToHLCPP(std::move(value.v24().value())));
  }
  if (value.v25().has_value()) {
    hlcpp.set_v25(::fidl::NaturalToHLCPP(std::move(value.v25().value())));
  }
  if (value.v26().has_value()) {
    hlcpp.set_v26(::fidl::NaturalToHLCPP(std::move(value.v26().value())));
  }
  if (value.v27().has_value()) {
    hlcpp.set_v27(::fidl::NaturalToHLCPP(std::move(value.v27().value())));
  }
  if (value.v28().has_value()) {
    hlcpp.set_v28(::fidl::NaturalToHLCPP(std::move(value.v28().value())));
  }
  if (value.v29().has_value()) {
    hlcpp.set_v29(::fidl::NaturalToHLCPP(std::move(value.v29().value())));
  }
  if (value.v30().has_value()) {
    hlcpp.set_v30(::fidl::NaturalToHLCPP(std::move(value.v30().value())));
  }
  if (value.v31().has_value()) {
    hlcpp.set_v31(::fidl::NaturalToHLCPP(std::move(value.v31().value())));
  }
  if (value.v32().has_value()) {
    hlcpp.set_v32(::fidl::NaturalToHLCPP(std::move(value.v32().value())));
  }
  if (value.v33().has_value()) {
    hlcpp.set_v33(::fidl::NaturalToHLCPP(std::move(value.v33().value())));
  }
  if (value.v34().has_value()) {
    hlcpp.set_v34(::fidl::NaturalToHLCPP(std::move(value.v34().value())));
  }
  if (value.v35().has_value()) {
    hlcpp.set_v35(::fidl::NaturalToHLCPP(std::move(value.v35().value())));
  }
  if (value.v36().has_value()) {
    hlcpp.set_v36(::fidl::NaturalToHLCPP(std::move(value.v36().value())));
  }
  if (value.v37().has_value()) {
    hlcpp.set_v37(::fidl::NaturalToHLCPP(std::move(value.v37().value())));
  }
  if (value.v38().has_value()) {
    hlcpp.set_v38(::fidl::NaturalToHLCPP(std::move(value.v38().value())));
  }
  if (value.v39().has_value()) {
    hlcpp.set_v39(::fidl::NaturalToHLCPP(std::move(value.v39().value())));
  }
  if (value.v40().has_value()) {
    hlcpp.set_v40(::fidl::NaturalToHLCPP(std::move(value.v40().value())));
  }
  if (value.v41().has_value()) {
    hlcpp.set_v41(::fidl::NaturalToHLCPP(std::move(value.v41().value())));
  }
  if (value.v42().has_value()) {
    hlcpp.set_v42(::fidl::NaturalToHLCPP(std::move(value.v42().value())));
  }
  if (value.v43().has_value()) {
    hlcpp.set_v43(::fidl::NaturalToHLCPP(std::move(value.v43().value())));
  }
  if (value.v44().has_value()) {
    hlcpp.set_v44(::fidl::NaturalToHLCPP(std::move(value.v44().value())));
  }
  if (value.v45().has_value()) {
    hlcpp.set_v45(::fidl::NaturalToHLCPP(std::move(value.v45().value())));
  }
  if (value.v46().has_value()) {
    hlcpp.set_v46(::fidl::NaturalToHLCPP(std::move(value.v46().value())));
  }
  if (value.v47().has_value()) {
    hlcpp.set_v47(::fidl::NaturalToHLCPP(std::move(value.v47().value())));
  }
  if (value.v48().has_value()) {
    hlcpp.set_v48(::fidl::NaturalToHLCPP(std::move(value.v48().value())));
  }
  if (value.v49().has_value()) {
    hlcpp.set_v49(::fidl::NaturalToHLCPP(std::move(value.v49().value())));
  }
  if (value.v50().has_value()) {
    hlcpp.set_v50(::fidl::NaturalToHLCPP(std::move(value.v50().value())));
  }
  if (value.v51().has_value()) {
    hlcpp.set_v51(::fidl::NaturalToHLCPP(std::move(value.v51().value())));
  }
  if (value.v52().has_value()) {
    hlcpp.set_v52(::fidl::NaturalToHLCPP(std::move(value.v52().value())));
  }
  if (value.v53().has_value()) {
    hlcpp.set_v53(::fidl::NaturalToHLCPP(std::move(value.v53().value())));
  }
  if (value.v54().has_value()) {
    hlcpp.set_v54(::fidl::NaturalToHLCPP(std::move(value.v54().value())));
  }
  if (value.v55().has_value()) {
    hlcpp.set_v55(::fidl::NaturalToHLCPP(std::move(value.v55().value())));
  }
  if (value.v56().has_value()) {
    hlcpp.set_v56(::fidl::NaturalToHLCPP(std::move(value.v56().value())));
  }
  if (value.v57().has_value()) {
    hlcpp.set_v57(::fidl::NaturalToHLCPP(std::move(value.v57().value())));
  }
  if (value.v58().has_value()) {
    hlcpp.set_v58(::fidl::NaturalToHLCPP(std::move(value.v58().value())));
  }
  if (value.v59().has_value()) {
    hlcpp.set_v59(::fidl::NaturalToHLCPP(std::move(value.v59().value())));
  }
  if (value.v60().has_value()) {
    hlcpp.set_v60(::fidl::NaturalToHLCPP(std::move(value.v60().value())));
  }
  if (value.v61().has_value()) {
    hlcpp.set_v61(::fidl::NaturalToHLCPP(std::move(value.v61().value())));
  }
  if (value.v62().has_value()) {
    hlcpp.set_v62(::fidl::NaturalToHLCPP(std::move(value.v62().value())));
  }
  if (value.v63().has_value()) {
    hlcpp.set_v63(::fidl::NaturalToHLCPP(std::move(value.v63().value())));
  }
  if (value.v64().has_value()) {
    hlcpp.set_v64(::fidl::NaturalToHLCPP(std::move(value.v64().value())));
  }
  return hlcpp;
}

::test_table::SixtyFourOrdinalTable HLCPPToNaturalTraits<::test::table::SixtyFourOrdinalTable>::Convert(::test::table::SixtyFourOrdinalTable&& value) {
  ::test_table::SixtyFourOrdinalTable natural;
  if (value.has_v1()) {
    natural.v1() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v1()));
  }
  if (value.has_v2()) {
    natural.v2() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v2()));
  }
  if (value.has_v3()) {
    natural.v3() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v3()));
  }
  if (value.has_v4()) {
    natural.v4() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v4()));
  }
  if (value.has_v5()) {
    natural.v5() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v5()));
  }
  if (value.has_v6()) {
    natural.v6() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v6()));
  }
  if (value.has_v7()) {
    natural.v7() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v7()));
  }
  if (value.has_v8()) {
    natural.v8() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v8()));
  }
  if (value.has_v9()) {
    natural.v9() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v9()));
  }
  if (value.has_v10()) {
    natural.v10() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v10()));
  }
  if (value.has_v11()) {
    natural.v11() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v11()));
  }
  if (value.has_v12()) {
    natural.v12() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v12()));
  }
  if (value.has_v13()) {
    natural.v13() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v13()));
  }
  if (value.has_v14()) {
    natural.v14() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v14()));
  }
  if (value.has_v15()) {
    natural.v15() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v15()));
  }
  if (value.has_v16()) {
    natural.v16() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v16()));
  }
  if (value.has_v17()) {
    natural.v17() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v17()));
  }
  if (value.has_v18()) {
    natural.v18() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v18()));
  }
  if (value.has_v19()) {
    natural.v19() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v19()));
  }
  if (value.has_v20()) {
    natural.v20() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v20()));
  }
  if (value.has_v21()) {
    natural.v21() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v21()));
  }
  if (value.has_v22()) {
    natural.v22() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v22()));
  }
  if (value.has_v23()) {
    natural.v23() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v23()));
  }
  if (value.has_v24()) {
    natural.v24() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v24()));
  }
  if (value.has_v25()) {
    natural.v25() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v25()));
  }
  if (value.has_v26()) {
    natural.v26() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v26()));
  }
  if (value.has_v27()) {
    natural.v27() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v27()));
  }
  if (value.has_v28()) {
    natural.v28() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v28()));
  }
  if (value.has_v29()) {
    natural.v29() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v29()));
  }
  if (value.has_v30()) {
    natural.v30() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v30()));
  }
  if (value.has_v31()) {
    natural.v31() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v31()));
  }
  if (value.has_v32()) {
    natural.v32() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v32()));
  }
  if (value.has_v33()) {
    natural.v33() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v33()));
  }
  if (value.has_v34()) {
    natural.v34() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v34()));
  }
  if (value.has_v35()) {
    natural.v35() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v35()));
  }
  if (value.has_v36()) {
    natural.v36() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v36()));
  }
  if (value.has_v37()) {
    natural.v37() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v37()));
  }
  if (value.has_v38()) {
    natural.v38() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v38()));
  }
  if (value.has_v39()) {
    natural.v39() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v39()));
  }
  if (value.has_v40()) {
    natural.v40() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v40()));
  }
  if (value.has_v41()) {
    natural.v41() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v41()));
  }
  if (value.has_v42()) {
    natural.v42() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v42()));
  }
  if (value.has_v43()) {
    natural.v43() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v43()));
  }
  if (value.has_v44()) {
    natural.v44() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v44()));
  }
  if (value.has_v45()) {
    natural.v45() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v45()));
  }
  if (value.has_v46()) {
    natural.v46() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v46()));
  }
  if (value.has_v47()) {
    natural.v47() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v47()));
  }
  if (value.has_v48()) {
    natural.v48() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v48()));
  }
  if (value.has_v49()) {
    natural.v49() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v49()));
  }
  if (value.has_v50()) {
    natural.v50() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v50()));
  }
  if (value.has_v51()) {
    natural.v51() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v51()));
  }
  if (value.has_v52()) {
    natural.v52() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v52()));
  }
  if (value.has_v53()) {
    natural.v53() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v53()));
  }
  if (value.has_v54()) {
    natural.v54() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v54()));
  }
  if (value.has_v55()) {
    natural.v55() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v55()));
  }
  if (value.has_v56()) {
    natural.v56() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v56()));
  }
  if (value.has_v57()) {
    natural.v57() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v57()));
  }
  if (value.has_v58()) {
    natural.v58() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v58()));
  }
  if (value.has_v59()) {
    natural.v59() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v59()));
  }
  if (value.has_v60()) {
    natural.v60() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v60()));
  }
  if (value.has_v61()) {
    natural.v61() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v61()));
  }
  if (value.has_v62()) {
    natural.v62() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v62()));
  }
  if (value.has_v63()) {
    natural.v63() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v63()));
  }
  if (value.has_v64()) {
    natural.v64() = ::fidl::HLCPPToNatural(std::move(*value.mutable_v64()));
  }
  return natural;
}

#pragma clang diagnostic pop

}  // namespace internal
}  // namespace fidl