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

#pragma once

#include <lib/fidl/llcpp/array.h>
#include <lib/fidl/llcpp/coding.h>
#include <lib/fidl/llcpp/envelope.h>
#include <lib/fidl/llcpp/message.h>
#include <lib/fidl/llcpp/message_storage.h>
#include <lib/fidl/llcpp/object_view.h>
#include <lib/fidl/llcpp/string_view.h>
#include <lib/fidl/llcpp/traits.h>
#include <lib/fidl/llcpp/wire_types.h>
#include <lib/stdcompat/optional.h>

#include <cinttypes>
#ifdef __Fuchsia__

#endif  // __Fuchsia__

#include <fidl/test.table/cpp/common_types.h>
#include <fidl/test.table/cpp/markers.h>

namespace test_table {
namespace wire {
class TableWithAttributes;

class SimpleTable;

class ReverseOrdinalTable;

class OlderSimpleTable;

class NewerSimpleTable;

class ExtensionTable;

class SixtyFourOrdinalTable;

class EmptyTable;

}  // namespace wire
}  // namespace test_table
template <>
class ::fidl::WireTableBuilder<::test_table::wire::TableWithAttributes>;
template <>
class ::fidl::WireTableExternalBuilder<::test_table::wire::TableWithAttributes>;

template <>
struct ::fidl::WireTableFrame<::test_table::wire::TableWithAttributes> final {
 public:
  WireTableFrame() = default;
  // In its intended usage, WireTableFrame will be referenced by an ObjectView.
  // If the ObjectView is assigned before a move or copy, then it will reference
  // the old invalid object. Because this is unsafe, copies are disallowed and
  // moves are only allowed by friend classes that operate safely.
  WireTableFrame(const WireTableFrame&) = delete;
  WireTableFrame& operator=(const WireTableFrame&) = delete;

 private:
  WireTableFrame(WireTableFrame&&) noexcept = default;
  WireTableFrame& operator=(WireTableFrame&&) noexcept = default;

  bool HasUnknownData() const;
  ::fidl::Envelope<int64_t> x_;

  friend class ::test_table::wire::TableWithAttributes;
  friend ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::TableWithAttributes,
      ::fidl::WireTableBuilder<::test_table::wire::TableWithAttributes>>;
  friend ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::TableWithAttributes,
      ::fidl::WireTableExternalBuilder<
          ::test_table::wire::TableWithAttributes>>;
};

namespace test_table {
namespace wire {
extern "C" const fidl_type_t test_table_TableWithAttributesTable;

class TableWithAttributes {
 public:
  TableWithAttributes() = default;
  TableWithAttributes(const TableWithAttributes& other) noexcept = default;
  TableWithAttributes& operator=(const TableWithAttributes& other) noexcept =
      default;
  TableWithAttributes(TableWithAttributes&& other) noexcept = default;
  TableWithAttributes& operator=(TableWithAttributes&& other) noexcept =
      default;

  ~TableWithAttributes() = default;

  // Returns whether no field is set.
  bool IsEmpty() const { return max_ordinal_ == 0; }

  // Returns whether the table references unknown fields.
  bool HasUnknownData() const;

  // Return a builder that by defaults allocates of an arena.
  static ::fidl::WireTableBuilder<::test_table::wire::TableWithAttributes>
  Builder(::fidl::AnyArena& arena);

  // Return a builder that relies on explicitly allocating |fidl::ObjectView|s.
  static ::fidl::WireTableExternalBuilder<
      ::test_table::wire::TableWithAttributes>
  ExternalBuilder(
      ::fidl::ObjectView<
          ::fidl::WireTableFrame<::test_table::wire::TableWithAttributes>>
          frame);

  const int64_t& x() const {
    ZX_ASSERT(has_x());
    return frame_ptr_->x_.get_data();
  }
  int64_t& x() {
    ZX_ASSERT(has_x());
    return frame_ptr_->x_.get_data();
  }
  bool has_x() const { return max_ordinal_ >= 1 && frame_ptr_->x_.has_data(); }
#if defined(FIDL_WIRE_ALLOW_DEPRECATED_MUTABLE_TABLES) || false
 public:
#else   // !defined(FIDL_WIRE_ALLOW_DEPRECATED_MUTABLE_TABLES)
 private:
#endif  // FIDL_WIRE_ALLOW_DEPRECATED_MUTABLE_TABLES

  TableWithAttributes& set_x(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->x_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(1));
    return *this;
  }
  TableWithAttributes& set_x(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->x_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  TableWithAttributes& set_x(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->x_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(1));
    return *this;
  }

  TableWithAttributes& clear_x() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->x_.clear_data();
    return *this;
  }

  explicit TableWithAttributes(::fidl::AnyArena& allocator)
      : frame_ptr_(::fidl::ObjectView<::fidl::WireTableFrame<
                       ::test_table::wire::TableWithAttributes>>(allocator)) {}
  // This constructor allows a user controlled allocation (not using a Arena).
  // It should only be used when performance is key.
  // As soon as the frame is given to the table, it must not be used directly or
  // for another table.
  explicit TableWithAttributes(
      ::fidl::ObjectView<
          ::fidl::WireTableFrame<::test_table::wire::TableWithAttributes>>&&
          frame)
      : frame_ptr_(std::move(frame)) {}

  void Allocate(::fidl::AnyArena& allocator) {
    max_ordinal_ = 0;
    frame_ptr_ = ::fidl::ObjectView<
        ::fidl::WireTableFrame<::test_table::wire::TableWithAttributes>>(
        allocator);
  }
  void Init(::fidl::ObjectView<::fidl::WireTableFrame<
                ::test_table::wire::TableWithAttributes>>&& frame_ptr) {
    max_ordinal_ = 0;
    frame_ptr_ = std::move(frame_ptr);
  }

 private:
  friend ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::TableWithAttributes,
      ::fidl::WireTableBuilder<::test_table::wire::TableWithAttributes>>;
  friend ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::TableWithAttributes,
      ::fidl::WireTableExternalBuilder<
          ::test_table::wire::TableWithAttributes>>;

  uint64_t max_ordinal_ = 0;
  ::fidl::ObjectView<
      ::fidl::WireTableFrame<::test_table::wire::TableWithAttributes>>
      frame_ptr_;
};
}  // namespace wire
}  // namespace test_table
template <typename BuilderImpl>
class ::fidl::internal::WireTableBaseBuilder<
    ::test_table::wire::TableWithAttributes, BuilderImpl> {
 public:
  // Build and return the table. The builder should not be used after this.
  ::test_table::wire::TableWithAttributes Build() {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    ::test_table::wire::TableWithAttributes t = std::move(table_);
    // Poison this builder to prevent accidental reuse.
    table_.frame_ptr_ = nullptr;
    return t;
  }

  BuilderImpl& x(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->x_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(1));
    return *static_cast<BuilderImpl*>(this);
  }

 protected:
  WireTableBaseBuilder(::fidl::ObjectView<::fidl::WireTableFrame<
                           ::test_table::wire::TableWithAttributes>>&& frame)
      : table_(std::move(frame)) {}

 private:
  ::test_table::wire::TableWithAttributes table_;
};

template <>
class ::fidl::WireTableBuilder<::test_table::wire::TableWithAttributes> final
    : public ::fidl::internal::WireTableBaseBuilder<
          ::test_table::wire::TableWithAttributes,
          ::fidl::WireTableBuilder<::test_table::wire::TableWithAttributes>> {
  using Base = ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::TableWithAttributes,
      ::fidl::WireTableBuilder<::test_table::wire::TableWithAttributes>>;

 public:
  using Base::x;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::TableWithAttributes>& x(
      Args&&... args_) {
    x(::fidl::ObjectView<int64_t>(arena_.get(), std::forward<Args>(args_)...));
    return *this;
  }

 private:
  friend class ::test_table::wire::TableWithAttributes;
  WireTableBuilder(::fidl::AnyArena& arena)
      : Base(::fidl::ObjectView<
             ::fidl::WireTableFrame<::test_table::wire::TableWithAttributes>>(
            arena)),
        arena_(arena) {}

  [[maybe_unused]] std::reference_wrapper<::fidl::AnyArena> arena_;
};

template <>
class ::fidl::WireTableExternalBuilder<::test_table::wire::TableWithAttributes>
    final : public ::fidl::internal::WireTableBaseBuilder<
                ::test_table::wire::TableWithAttributes,
                ::fidl::WireTableExternalBuilder<
                    ::test_table::wire::TableWithAttributes>> {
  using Base = ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::TableWithAttributes,
      ::fidl::WireTableExternalBuilder<
          ::test_table::wire::TableWithAttributes>>;

 private:
  friend class ::test_table::wire::TableWithAttributes;
  using Base::Base;
  WireTableExternalBuilder(
      ::fidl::WireTableFrame<::test_table::wire::TableWithAttributes>* frame)
      : Base(::fidl::ObjectView<
             ::fidl::WireTableFrame<::test_table::wire::TableWithAttributes>>::
                 FromExternal(frame)) {}
};
namespace test_table {
namespace wire {
inline ::fidl::WireTableBuilder<::test_table::wire::TableWithAttributes>
TableWithAttributes::Builder(::fidl::AnyArena& arena) {
  return ::fidl::WireTableBuilder<::test_table::wire::TableWithAttributes>(
      arena);
}
inline ::fidl::WireTableExternalBuilder<::test_table::wire::TableWithAttributes>
TableWithAttributes::ExternalBuilder(
    ::fidl::ObjectView<
        ::fidl::WireTableFrame<::test_table::wire::TableWithAttributes>>
        frame) {
  return ::fidl::WireTableExternalBuilder<
      ::test_table::wire::TableWithAttributes>(std::move(frame));
}

}  // namespace wire
}  // namespace test_table
template <>
class ::fidl::WireTableBuilder<::test_table::wire::SimpleTable>;
template <>
class ::fidl::WireTableExternalBuilder<::test_table::wire::SimpleTable>;

template <>
struct ::fidl::WireTableFrame<::test_table::wire::SimpleTable> final {
 public:
  WireTableFrame() = default;
  // In its intended usage, WireTableFrame will be referenced by an ObjectView.
  // If the ObjectView is assigned before a move or copy, then it will reference
  // the old invalid object. Because this is unsafe, copies are disallowed and
  // moves are only allowed by friend classes that operate safely.
  WireTableFrame(const WireTableFrame&) = delete;
  WireTableFrame& operator=(const WireTableFrame&) = delete;

 private:
  WireTableFrame(WireTableFrame&&) noexcept = default;
  WireTableFrame& operator=(WireTableFrame&&) noexcept = default;

  bool HasUnknownData() const;
  ::fidl::Envelope<int64_t> x_;
  [[maybe_unused]] ::fidl::UntypedEnvelope reserved_1_;
  [[maybe_unused]] ::fidl::UntypedEnvelope reserved_2_;
  [[maybe_unused]] ::fidl::UntypedEnvelope reserved_3_;
  ::fidl::Envelope<int64_t> y_;

  friend class ::test_table::wire::SimpleTable;
  friend ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::SimpleTable,
      ::fidl::WireTableBuilder<::test_table::wire::SimpleTable>>;
  friend ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::SimpleTable,
      ::fidl::WireTableExternalBuilder<::test_table::wire::SimpleTable>>;
};

namespace test_table {
namespace wire {
extern "C" const fidl_type_t test_table_SimpleTableTable;

class SimpleTable {
 public:
  SimpleTable() = default;
  SimpleTable(const SimpleTable& other) noexcept = default;
  SimpleTable& operator=(const SimpleTable& other) noexcept = default;
  SimpleTable(SimpleTable&& other) noexcept = default;
  SimpleTable& operator=(SimpleTable&& other) noexcept = default;

  ~SimpleTable() = default;

  // Returns whether no field is set.
  bool IsEmpty() const { return max_ordinal_ == 0; }

  // Returns whether the table references unknown fields.
  bool HasUnknownData() const;

  // Return a builder that by defaults allocates of an arena.
  static ::fidl::WireTableBuilder<::test_table::wire::SimpleTable> Builder(
      ::fidl::AnyArena& arena);

  // Return a builder that relies on explicitly allocating |fidl::ObjectView|s.
  static ::fidl::WireTableExternalBuilder<::test_table::wire::SimpleTable>
  ExternalBuilder(::fidl::ObjectView<
                  ::fidl::WireTableFrame<::test_table::wire::SimpleTable>>
                      frame);

  const int64_t& x() const {
    ZX_ASSERT(has_x());
    return frame_ptr_->x_.get_data();
  }
  int64_t& x() {
    ZX_ASSERT(has_x());
    return frame_ptr_->x_.get_data();
  }
  bool has_x() const { return max_ordinal_ >= 1 && frame_ptr_->x_.has_data(); }

  const int64_t& y() const {
    ZX_ASSERT(has_y());
    return frame_ptr_->y_.get_data();
  }
  int64_t& y() {
    ZX_ASSERT(has_y());
    return frame_ptr_->y_.get_data();
  }
  bool has_y() const { return max_ordinal_ >= 5 && frame_ptr_->y_.has_data(); }
#if defined(FIDL_WIRE_ALLOW_DEPRECATED_MUTABLE_TABLES) || false
 public:
#else   // !defined(FIDL_WIRE_ALLOW_DEPRECATED_MUTABLE_TABLES)
 private:
#endif  // FIDL_WIRE_ALLOW_DEPRECATED_MUTABLE_TABLES

  SimpleTable& set_x(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->x_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(1));
    return *this;
  }
  SimpleTable& set_x(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->x_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SimpleTable& set_x(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->x_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(1));
    return *this;
  }

  SimpleTable& clear_x() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->x_.clear_data();
    return *this;
  }
  SimpleTable& set_y(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->y_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(5));
    return *this;
  }
  SimpleTable& set_y(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->y_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SimpleTable& set_y(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->y_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(5));
    return *this;
  }

  SimpleTable& clear_y() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->y_.clear_data();
    return *this;
  }

  explicit SimpleTable(::fidl::AnyArena& allocator)
      : frame_ptr_(::fidl::ObjectView<
                   ::fidl::WireTableFrame<::test_table::wire::SimpleTable>>(
            allocator)) {}
  // This constructor allows a user controlled allocation (not using a Arena).
  // It should only be used when performance is key.
  // As soon as the frame is given to the table, it must not be used directly or
  // for another table.
  explicit SimpleTable(
      ::fidl::ObjectView<
          ::fidl::WireTableFrame<::test_table::wire::SimpleTable>>&& frame)
      : frame_ptr_(std::move(frame)) {}

  void Allocate(::fidl::AnyArena& allocator) {
    max_ordinal_ = 0;
    frame_ptr_ = ::fidl::ObjectView<
        ::fidl::WireTableFrame<::test_table::wire::SimpleTable>>(allocator);
  }
  void
  Init(::fidl::ObjectView<
       ::fidl::WireTableFrame<::test_table::wire::SimpleTable>>&& frame_ptr) {
    max_ordinal_ = 0;
    frame_ptr_ = std::move(frame_ptr);
  }

 private:
  friend ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::SimpleTable,
      ::fidl::WireTableBuilder<::test_table::wire::SimpleTable>>;
  friend ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::SimpleTable,
      ::fidl::WireTableExternalBuilder<::test_table::wire::SimpleTable>>;

  uint64_t max_ordinal_ = 0;
  ::fidl::ObjectView<::fidl::WireTableFrame<::test_table::wire::SimpleTable>>
      frame_ptr_;
};
}  // namespace wire
}  // namespace test_table
template <typename BuilderImpl>
class ::fidl::internal::WireTableBaseBuilder<::test_table::wire::SimpleTable,
                                             BuilderImpl> {
 public:
  // Build and return the table. The builder should not be used after this.
  ::test_table::wire::SimpleTable Build() {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    ::test_table::wire::SimpleTable t = std::move(table_);
    // Poison this builder to prevent accidental reuse.
    table_.frame_ptr_ = nullptr;
    return t;
  }

  BuilderImpl& x(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->x_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(1));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& y(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->y_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(5));
    return *static_cast<BuilderImpl*>(this);
  }

 protected:
  WireTableBaseBuilder(
      ::fidl::ObjectView<
          ::fidl::WireTableFrame<::test_table::wire::SimpleTable>>&& frame)
      : table_(std::move(frame)) {}

 private:
  ::test_table::wire::SimpleTable table_;
};

template <>
class ::fidl::WireTableBuilder<::test_table::wire::SimpleTable> final
    : public ::fidl::internal::WireTableBaseBuilder<
          ::test_table::wire::SimpleTable,
          ::fidl::WireTableBuilder<::test_table::wire::SimpleTable>> {
  using Base = ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::SimpleTable,
      ::fidl::WireTableBuilder<::test_table::wire::SimpleTable>>;

 public:
  using Base::x;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SimpleTable>& x(
      Args&&... args_) {
    x(::fidl::ObjectView<int64_t>(arena_.get(), std::forward<Args>(args_)...));
    return *this;
  }
  using Base::y;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SimpleTable>& y(
      Args&&... args_) {
    y(::fidl::ObjectView<int64_t>(arena_.get(), std::forward<Args>(args_)...));
    return *this;
  }

 private:
  friend class ::test_table::wire::SimpleTable;
  WireTableBuilder(::fidl::AnyArena& arena)
      : Base(::fidl::ObjectView<
             ::fidl::WireTableFrame<::test_table::wire::SimpleTable>>(arena)),
        arena_(arena) {}

  [[maybe_unused]] std::reference_wrapper<::fidl::AnyArena> arena_;
};

template <>
class ::fidl::WireTableExternalBuilder<::test_table::wire::SimpleTable> final
    : public ::fidl::internal::WireTableBaseBuilder<
          ::test_table::wire::SimpleTable,
          ::fidl::WireTableExternalBuilder<::test_table::wire::SimpleTable>> {
  using Base = ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::SimpleTable,
      ::fidl::WireTableExternalBuilder<::test_table::wire::SimpleTable>>;

 private:
  friend class ::test_table::wire::SimpleTable;
  using Base::Base;
  WireTableExternalBuilder(
      ::fidl::WireTableFrame<::test_table::wire::SimpleTable>* frame)
      : Base(::fidl::ObjectView<::fidl::WireTableFrame<
                 ::test_table::wire::SimpleTable>>::FromExternal(frame)) {}
};
namespace test_table {
namespace wire {
inline ::fidl::WireTableBuilder<::test_table::wire::SimpleTable>
SimpleTable::Builder(::fidl::AnyArena& arena) {
  return ::fidl::WireTableBuilder<::test_table::wire::SimpleTable>(arena);
}
inline ::fidl::WireTableExternalBuilder<::test_table::wire::SimpleTable>
SimpleTable::ExternalBuilder(
    ::fidl::ObjectView<::fidl::WireTableFrame<::test_table::wire::SimpleTable>>
        frame) {
  return ::fidl::WireTableExternalBuilder<::test_table::wire::SimpleTable>(
      std::move(frame));
}

}  // namespace wire
}  // namespace test_table
template <>
class ::fidl::WireTableBuilder<::test_table::wire::ReverseOrdinalTable>;
template <>
class ::fidl::WireTableExternalBuilder<::test_table::wire::ReverseOrdinalTable>;

template <>
struct ::fidl::WireTableFrame<::test_table::wire::ReverseOrdinalTable> final {
 public:
  WireTableFrame() = default;
  // In its intended usage, WireTableFrame will be referenced by an ObjectView.
  // If the ObjectView is assigned before a move or copy, then it will reference
  // the old invalid object. Because this is unsafe, copies are disallowed and
  // moves are only allowed by friend classes that operate safely.
  WireTableFrame(const WireTableFrame&) = delete;
  WireTableFrame& operator=(const WireTableFrame&) = delete;

 private:
  WireTableFrame(WireTableFrame&&) noexcept = default;
  WireTableFrame& operator=(WireTableFrame&&) noexcept = default;

  bool HasUnknownData() const;
  ::fidl::Envelope<int64_t> z_;
  ::fidl::Envelope<int64_t> y_;
  ::fidl::Envelope<int64_t> x_;

  friend class ::test_table::wire::ReverseOrdinalTable;
  friend ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::ReverseOrdinalTable,
      ::fidl::WireTableBuilder<::test_table::wire::ReverseOrdinalTable>>;
  friend ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::ReverseOrdinalTable,
      ::fidl::WireTableExternalBuilder<
          ::test_table::wire::ReverseOrdinalTable>>;
};

namespace test_table {
namespace wire {
extern "C" const fidl_type_t test_table_ReverseOrdinalTableTable;

class ReverseOrdinalTable {
 public:
  ReverseOrdinalTable() = default;
  ReverseOrdinalTable(const ReverseOrdinalTable& other) noexcept = default;
  ReverseOrdinalTable& operator=(const ReverseOrdinalTable& other) noexcept =
      default;
  ReverseOrdinalTable(ReverseOrdinalTable&& other) noexcept = default;
  ReverseOrdinalTable& operator=(ReverseOrdinalTable&& other) noexcept =
      default;

  ~ReverseOrdinalTable() = default;

  // Returns whether no field is set.
  bool IsEmpty() const { return max_ordinal_ == 0; }

  // Returns whether the table references unknown fields.
  bool HasUnknownData() const;

  // Return a builder that by defaults allocates of an arena.
  static ::fidl::WireTableBuilder<::test_table::wire::ReverseOrdinalTable>
  Builder(::fidl::AnyArena& arena);

  // Return a builder that relies on explicitly allocating |fidl::ObjectView|s.
  static ::fidl::WireTableExternalBuilder<
      ::test_table::wire::ReverseOrdinalTable>
  ExternalBuilder(
      ::fidl::ObjectView<
          ::fidl::WireTableFrame<::test_table::wire::ReverseOrdinalTable>>
          frame);

  const int64_t& z() const {
    ZX_ASSERT(has_z());
    return frame_ptr_->z_.get_data();
  }
  int64_t& z() {
    ZX_ASSERT(has_z());
    return frame_ptr_->z_.get_data();
  }
  bool has_z() const { return max_ordinal_ >= 1 && frame_ptr_->z_.has_data(); }

  const int64_t& y() const {
    ZX_ASSERT(has_y());
    return frame_ptr_->y_.get_data();
  }
  int64_t& y() {
    ZX_ASSERT(has_y());
    return frame_ptr_->y_.get_data();
  }
  bool has_y() const { return max_ordinal_ >= 2 && frame_ptr_->y_.has_data(); }

  const int64_t& x() const {
    ZX_ASSERT(has_x());
    return frame_ptr_->x_.get_data();
  }
  int64_t& x() {
    ZX_ASSERT(has_x());
    return frame_ptr_->x_.get_data();
  }
  bool has_x() const { return max_ordinal_ >= 3 && frame_ptr_->x_.has_data(); }
#if defined(FIDL_WIRE_ALLOW_DEPRECATED_MUTABLE_TABLES) || false
 public:
#else   // !defined(FIDL_WIRE_ALLOW_DEPRECATED_MUTABLE_TABLES)
 private:
#endif  // FIDL_WIRE_ALLOW_DEPRECATED_MUTABLE_TABLES

  ReverseOrdinalTable& set_z(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->z_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(1));
    return *this;
  }
  ReverseOrdinalTable& set_z(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->z_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  ReverseOrdinalTable& set_z(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->z_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(1));
    return *this;
  }

  ReverseOrdinalTable& clear_z() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->z_.clear_data();
    return *this;
  }
  ReverseOrdinalTable& set_y(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->y_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(2));
    return *this;
  }
  ReverseOrdinalTable& set_y(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->y_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  ReverseOrdinalTable& set_y(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->y_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(2));
    return *this;
  }

  ReverseOrdinalTable& clear_y() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->y_.clear_data();
    return *this;
  }
  ReverseOrdinalTable& set_x(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->x_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(3));
    return *this;
  }
  ReverseOrdinalTable& set_x(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->x_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  ReverseOrdinalTable& set_x(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->x_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(3));
    return *this;
  }

  ReverseOrdinalTable& clear_x() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->x_.clear_data();
    return *this;
  }

  explicit ReverseOrdinalTable(::fidl::AnyArena& allocator)
      : frame_ptr_(::fidl::ObjectView<::fidl::WireTableFrame<
                       ::test_table::wire::ReverseOrdinalTable>>(allocator)) {}
  // This constructor allows a user controlled allocation (not using a Arena).
  // It should only be used when performance is key.
  // As soon as the frame is given to the table, it must not be used directly or
  // for another table.
  explicit ReverseOrdinalTable(
      ::fidl::ObjectView<
          ::fidl::WireTableFrame<::test_table::wire::ReverseOrdinalTable>>&&
          frame)
      : frame_ptr_(std::move(frame)) {}

  void Allocate(::fidl::AnyArena& allocator) {
    max_ordinal_ = 0;
    frame_ptr_ = ::fidl::ObjectView<
        ::fidl::WireTableFrame<::test_table::wire::ReverseOrdinalTable>>(
        allocator);
  }
  void Init(::fidl::ObjectView<::fidl::WireTableFrame<
                ::test_table::wire::ReverseOrdinalTable>>&& frame_ptr) {
    max_ordinal_ = 0;
    frame_ptr_ = std::move(frame_ptr);
  }

 private:
  friend ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::ReverseOrdinalTable,
      ::fidl::WireTableBuilder<::test_table::wire::ReverseOrdinalTable>>;
  friend ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::ReverseOrdinalTable,
      ::fidl::WireTableExternalBuilder<
          ::test_table::wire::ReverseOrdinalTable>>;

  uint64_t max_ordinal_ = 0;
  ::fidl::ObjectView<
      ::fidl::WireTableFrame<::test_table::wire::ReverseOrdinalTable>>
      frame_ptr_;
};
}  // namespace wire
}  // namespace test_table
template <typename BuilderImpl>
class ::fidl::internal::WireTableBaseBuilder<
    ::test_table::wire::ReverseOrdinalTable, BuilderImpl> {
 public:
  // Build and return the table. The builder should not be used after this.
  ::test_table::wire::ReverseOrdinalTable Build() {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    ::test_table::wire::ReverseOrdinalTable t = std::move(table_);
    // Poison this builder to prevent accidental reuse.
    table_.frame_ptr_ = nullptr;
    return t;
  }

  BuilderImpl& z(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->z_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(1));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& y(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->y_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(2));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& x(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->x_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(3));
    return *static_cast<BuilderImpl*>(this);
  }

 protected:
  WireTableBaseBuilder(::fidl::ObjectView<::fidl::WireTableFrame<
                           ::test_table::wire::ReverseOrdinalTable>>&& frame)
      : table_(std::move(frame)) {}

 private:
  ::test_table::wire::ReverseOrdinalTable table_;
};

template <>
class ::fidl::WireTableBuilder<::test_table::wire::ReverseOrdinalTable> final
    : public ::fidl::internal::WireTableBaseBuilder<
          ::test_table::wire::ReverseOrdinalTable,
          ::fidl::WireTableBuilder<::test_table::wire::ReverseOrdinalTable>> {
  using Base = ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::ReverseOrdinalTable,
      ::fidl::WireTableBuilder<::test_table::wire::ReverseOrdinalTable>>;

 public:
  using Base::z;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::ReverseOrdinalTable>& z(
      Args&&... args_) {
    z(::fidl::ObjectView<int64_t>(arena_.get(), std::forward<Args>(args_)...));
    return *this;
  }
  using Base::y;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::ReverseOrdinalTable>& y(
      Args&&... args_) {
    y(::fidl::ObjectView<int64_t>(arena_.get(), std::forward<Args>(args_)...));
    return *this;
  }
  using Base::x;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::ReverseOrdinalTable>& x(
      Args&&... args_) {
    x(::fidl::ObjectView<int64_t>(arena_.get(), std::forward<Args>(args_)...));
    return *this;
  }

 private:
  friend class ::test_table::wire::ReverseOrdinalTable;
  WireTableBuilder(::fidl::AnyArena& arena)
      : Base(::fidl::ObjectView<
             ::fidl::WireTableFrame<::test_table::wire::ReverseOrdinalTable>>(
            arena)),
        arena_(arena) {}

  [[maybe_unused]] std::reference_wrapper<::fidl::AnyArena> arena_;
};

template <>
class ::fidl::WireTableExternalBuilder<::test_table::wire::ReverseOrdinalTable>
    final : public ::fidl::internal::WireTableBaseBuilder<
                ::test_table::wire::ReverseOrdinalTable,
                ::fidl::WireTableExternalBuilder<
                    ::test_table::wire::ReverseOrdinalTable>> {
  using Base = ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::ReverseOrdinalTable,
      ::fidl::WireTableExternalBuilder<
          ::test_table::wire::ReverseOrdinalTable>>;

 private:
  friend class ::test_table::wire::ReverseOrdinalTable;
  using Base::Base;
  WireTableExternalBuilder(
      ::fidl::WireTableFrame<::test_table::wire::ReverseOrdinalTable>* frame)
      : Base(::fidl::ObjectView<
             ::fidl::WireTableFrame<::test_table::wire::ReverseOrdinalTable>>::
                 FromExternal(frame)) {}
};
namespace test_table {
namespace wire {
inline ::fidl::WireTableBuilder<::test_table::wire::ReverseOrdinalTable>
ReverseOrdinalTable::Builder(::fidl::AnyArena& arena) {
  return ::fidl::WireTableBuilder<::test_table::wire::ReverseOrdinalTable>(
      arena);
}
inline ::fidl::WireTableExternalBuilder<::test_table::wire::ReverseOrdinalTable>
ReverseOrdinalTable::ExternalBuilder(
    ::fidl::ObjectView<
        ::fidl::WireTableFrame<::test_table::wire::ReverseOrdinalTable>>
        frame) {
  return ::fidl::WireTableExternalBuilder<
      ::test_table::wire::ReverseOrdinalTable>(std::move(frame));
}

}  // namespace wire
}  // namespace test_table
template <>
class ::fidl::WireTableBuilder<::test_table::wire::OlderSimpleTable>;
template <>
class ::fidl::WireTableExternalBuilder<::test_table::wire::OlderSimpleTable>;

template <>
struct ::fidl::WireTableFrame<::test_table::wire::OlderSimpleTable> final {
 public:
  WireTableFrame() = default;
  // In its intended usage, WireTableFrame will be referenced by an ObjectView.
  // If the ObjectView is assigned before a move or copy, then it will reference
  // the old invalid object. Because this is unsafe, copies are disallowed and
  // moves are only allowed by friend classes that operate safely.
  WireTableFrame(const WireTableFrame&) = delete;
  WireTableFrame& operator=(const WireTableFrame&) = delete;

 private:
  WireTableFrame(WireTableFrame&&) noexcept = default;
  WireTableFrame& operator=(WireTableFrame&&) noexcept = default;

  bool HasUnknownData() const;
  ::fidl::Envelope<int64_t> x_;

  friend class ::test_table::wire::OlderSimpleTable;
  friend ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::OlderSimpleTable,
      ::fidl::WireTableBuilder<::test_table::wire::OlderSimpleTable>>;
  friend ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::OlderSimpleTable,
      ::fidl::WireTableExternalBuilder<::test_table::wire::OlderSimpleTable>>;
};

namespace test_table {
namespace wire {
extern "C" const fidl_type_t test_table_OlderSimpleTableTable;

class OlderSimpleTable {
 public:
  OlderSimpleTable() = default;
  OlderSimpleTable(const OlderSimpleTable& other) noexcept = default;
  OlderSimpleTable& operator=(const OlderSimpleTable& other) noexcept = default;
  OlderSimpleTable(OlderSimpleTable&& other) noexcept = default;
  OlderSimpleTable& operator=(OlderSimpleTable&& other) noexcept = default;

  ~OlderSimpleTable() = default;

  // Returns whether no field is set.
  bool IsEmpty() const { return max_ordinal_ == 0; }

  // Returns whether the table references unknown fields.
  bool HasUnknownData() const;

  // Return a builder that by defaults allocates of an arena.
  static ::fidl::WireTableBuilder<::test_table::wire::OlderSimpleTable> Builder(
      ::fidl::AnyArena& arena);

  // Return a builder that relies on explicitly allocating |fidl::ObjectView|s.
  static ::fidl::WireTableExternalBuilder<::test_table::wire::OlderSimpleTable>
  ExternalBuilder(::fidl::ObjectView<
                  ::fidl::WireTableFrame<::test_table::wire::OlderSimpleTable>>
                      frame);

  const int64_t& x() const {
    ZX_ASSERT(has_x());
    return frame_ptr_->x_.get_data();
  }
  int64_t& x() {
    ZX_ASSERT(has_x());
    return frame_ptr_->x_.get_data();
  }
  bool has_x() const { return max_ordinal_ >= 1 && frame_ptr_->x_.has_data(); }
#if defined(FIDL_WIRE_ALLOW_DEPRECATED_MUTABLE_TABLES) || false
 public:
#else   // !defined(FIDL_WIRE_ALLOW_DEPRECATED_MUTABLE_TABLES)
 private:
#endif  // FIDL_WIRE_ALLOW_DEPRECATED_MUTABLE_TABLES

  OlderSimpleTable& set_x(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->x_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(1));
    return *this;
  }
  OlderSimpleTable& set_x(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->x_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  OlderSimpleTable& set_x(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->x_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(1));
    return *this;
  }

  OlderSimpleTable& clear_x() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->x_.clear_data();
    return *this;
  }

  explicit OlderSimpleTable(::fidl::AnyArena& allocator)
      : frame_ptr_(
            ::fidl::ObjectView<
                ::fidl::WireTableFrame<::test_table::wire::OlderSimpleTable>>(
                allocator)) {}
  // This constructor allows a user controlled allocation (not using a Arena).
  // It should only be used when performance is key.
  // As soon as the frame is given to the table, it must not be used directly or
  // for another table.
  explicit OlderSimpleTable(
      ::fidl::ObjectView<
          ::fidl::WireTableFrame<::test_table::wire::OlderSimpleTable>>&& frame)
      : frame_ptr_(std::move(frame)) {}

  void Allocate(::fidl::AnyArena& allocator) {
    max_ordinal_ = 0;
    frame_ptr_ = ::fidl::ObjectView<
        ::fidl::WireTableFrame<::test_table::wire::OlderSimpleTable>>(
        allocator);
  }
  void Init(::fidl::ObjectView<::fidl::WireTableFrame<
                ::test_table::wire::OlderSimpleTable>>&& frame_ptr) {
    max_ordinal_ = 0;
    frame_ptr_ = std::move(frame_ptr);
  }

 private:
  friend ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::OlderSimpleTable,
      ::fidl::WireTableBuilder<::test_table::wire::OlderSimpleTable>>;
  friend ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::OlderSimpleTable,
      ::fidl::WireTableExternalBuilder<::test_table::wire::OlderSimpleTable>>;

  uint64_t max_ordinal_ = 0;
  ::fidl::ObjectView<
      ::fidl::WireTableFrame<::test_table::wire::OlderSimpleTable>>
      frame_ptr_;
};
}  // namespace wire
}  // namespace test_table
template <typename BuilderImpl>
class ::fidl::internal::WireTableBaseBuilder<
    ::test_table::wire::OlderSimpleTable, BuilderImpl> {
 public:
  // Build and return the table. The builder should not be used after this.
  ::test_table::wire::OlderSimpleTable Build() {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    ::test_table::wire::OlderSimpleTable t = std::move(table_);
    // Poison this builder to prevent accidental reuse.
    table_.frame_ptr_ = nullptr;
    return t;
  }

  BuilderImpl& x(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->x_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(1));
    return *static_cast<BuilderImpl*>(this);
  }

 protected:
  WireTableBaseBuilder(
      ::fidl::ObjectView<
          ::fidl::WireTableFrame<::test_table::wire::OlderSimpleTable>>&& frame)
      : table_(std::move(frame)) {}

 private:
  ::test_table::wire::OlderSimpleTable table_;
};

template <>
class ::fidl::WireTableBuilder<::test_table::wire::OlderSimpleTable> final
    : public ::fidl::internal::WireTableBaseBuilder<
          ::test_table::wire::OlderSimpleTable,
          ::fidl::WireTableBuilder<::test_table::wire::OlderSimpleTable>> {
  using Base = ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::OlderSimpleTable,
      ::fidl::WireTableBuilder<::test_table::wire::OlderSimpleTable>>;

 public:
  using Base::x;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::OlderSimpleTable>& x(
      Args&&... args_) {
    x(::fidl::ObjectView<int64_t>(arena_.get(), std::forward<Args>(args_)...));
    return *this;
  }

 private:
  friend class ::test_table::wire::OlderSimpleTable;
  WireTableBuilder(::fidl::AnyArena& arena)
      : Base(::fidl::ObjectView<
             ::fidl::WireTableFrame<::test_table::wire::OlderSimpleTable>>(
            arena)),
        arena_(arena) {}

  [[maybe_unused]] std::reference_wrapper<::fidl::AnyArena> arena_;
};

template <>
class ::fidl::WireTableExternalBuilder<::test_table::wire::OlderSimpleTable>
    final : public ::fidl::internal::WireTableBaseBuilder<
                ::test_table::wire::OlderSimpleTable,
                ::fidl::WireTableExternalBuilder<
                    ::test_table::wire::OlderSimpleTable>> {
  using Base = ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::OlderSimpleTable,
      ::fidl::WireTableExternalBuilder<::test_table::wire::OlderSimpleTable>>;

 private:
  friend class ::test_table::wire::OlderSimpleTable;
  using Base::Base;
  WireTableExternalBuilder(
      ::fidl::WireTableFrame<::test_table::wire::OlderSimpleTable>* frame)
      : Base(::fidl::ObjectView<::fidl::WireTableFrame<
                 ::test_table::wire::OlderSimpleTable>>::FromExternal(frame)) {}
};
namespace test_table {
namespace wire {
inline ::fidl::WireTableBuilder<::test_table::wire::OlderSimpleTable>
OlderSimpleTable::Builder(::fidl::AnyArena& arena) {
  return ::fidl::WireTableBuilder<::test_table::wire::OlderSimpleTable>(arena);
}
inline ::fidl::WireTableExternalBuilder<::test_table::wire::OlderSimpleTable>
OlderSimpleTable::ExternalBuilder(
    ::fidl::ObjectView<
        ::fidl::WireTableFrame<::test_table::wire::OlderSimpleTable>>
        frame) {
  return ::fidl::WireTableExternalBuilder<::test_table::wire::OlderSimpleTable>(
      std::move(frame));
}

}  // namespace wire
}  // namespace test_table
template <>
class ::fidl::WireTableBuilder<::test_table::wire::NewerSimpleTable>;
template <>
class ::fidl::WireTableExternalBuilder<::test_table::wire::NewerSimpleTable>;

template <>
struct ::fidl::WireTableFrame<::test_table::wire::NewerSimpleTable> final {
 public:
  WireTableFrame() = default;
  // In its intended usage, WireTableFrame will be referenced by an ObjectView.
  // If the ObjectView is assigned before a move or copy, then it will reference
  // the old invalid object. Because this is unsafe, copies are disallowed and
  // moves are only allowed by friend classes that operate safely.
  WireTableFrame(const WireTableFrame&) = delete;
  WireTableFrame& operator=(const WireTableFrame&) = delete;

 private:
  WireTableFrame(WireTableFrame&&) noexcept = default;
  WireTableFrame& operator=(WireTableFrame&&) noexcept = default;

  bool HasUnknownData() const;
  ::fidl::Envelope<int64_t> x_;
  [[maybe_unused]] ::fidl::UntypedEnvelope reserved_1_;
  [[maybe_unused]] ::fidl::UntypedEnvelope reserved_2_;
  [[maybe_unused]] ::fidl::UntypedEnvelope reserved_3_;
  ::fidl::Envelope<int64_t> y_;
  ::fidl::Envelope<int64_t> z_;

  friend class ::test_table::wire::NewerSimpleTable;
  friend ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::NewerSimpleTable,
      ::fidl::WireTableBuilder<::test_table::wire::NewerSimpleTable>>;
  friend ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::NewerSimpleTable,
      ::fidl::WireTableExternalBuilder<::test_table::wire::NewerSimpleTable>>;
};

namespace test_table {
namespace wire {
extern "C" const fidl_type_t test_table_NewerSimpleTableTable;

class NewerSimpleTable {
 public:
  NewerSimpleTable() = default;
  NewerSimpleTable(const NewerSimpleTable& other) noexcept = default;
  NewerSimpleTable& operator=(const NewerSimpleTable& other) noexcept = default;
  NewerSimpleTable(NewerSimpleTable&& other) noexcept = default;
  NewerSimpleTable& operator=(NewerSimpleTable&& other) noexcept = default;

  ~NewerSimpleTable() = default;

  // Returns whether no field is set.
  bool IsEmpty() const { return max_ordinal_ == 0; }

  // Returns whether the table references unknown fields.
  bool HasUnknownData() const;

  // Return a builder that by defaults allocates of an arena.
  static ::fidl::WireTableBuilder<::test_table::wire::NewerSimpleTable> Builder(
      ::fidl::AnyArena& arena);

  // Return a builder that relies on explicitly allocating |fidl::ObjectView|s.
  static ::fidl::WireTableExternalBuilder<::test_table::wire::NewerSimpleTable>
  ExternalBuilder(::fidl::ObjectView<
                  ::fidl::WireTableFrame<::test_table::wire::NewerSimpleTable>>
                      frame);

  const int64_t& x() const {
    ZX_ASSERT(has_x());
    return frame_ptr_->x_.get_data();
  }
  int64_t& x() {
    ZX_ASSERT(has_x());
    return frame_ptr_->x_.get_data();
  }
  bool has_x() const { return max_ordinal_ >= 1 && frame_ptr_->x_.has_data(); }

  const int64_t& y() const {
    ZX_ASSERT(has_y());
    return frame_ptr_->y_.get_data();
  }
  int64_t& y() {
    ZX_ASSERT(has_y());
    return frame_ptr_->y_.get_data();
  }
  bool has_y() const { return max_ordinal_ >= 5 && frame_ptr_->y_.has_data(); }

  const int64_t& z() const {
    ZX_ASSERT(has_z());
    return frame_ptr_->z_.get_data();
  }
  int64_t& z() {
    ZX_ASSERT(has_z());
    return frame_ptr_->z_.get_data();
  }
  bool has_z() const { return max_ordinal_ >= 6 && frame_ptr_->z_.has_data(); }
#if defined(FIDL_WIRE_ALLOW_DEPRECATED_MUTABLE_TABLES) || false
 public:
#else   // !defined(FIDL_WIRE_ALLOW_DEPRECATED_MUTABLE_TABLES)
 private:
#endif  // FIDL_WIRE_ALLOW_DEPRECATED_MUTABLE_TABLES

  NewerSimpleTable& set_x(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->x_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(1));
    return *this;
  }
  NewerSimpleTable& set_x(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->x_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  NewerSimpleTable& set_x(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->x_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(1));
    return *this;
  }

  NewerSimpleTable& clear_x() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->x_.clear_data();
    return *this;
  }
  NewerSimpleTable& set_y(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->y_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(5));
    return *this;
  }
  NewerSimpleTable& set_y(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->y_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  NewerSimpleTable& set_y(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->y_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(5));
    return *this;
  }

  NewerSimpleTable& clear_y() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->y_.clear_data();
    return *this;
  }
  NewerSimpleTable& set_z(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->z_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(6));
    return *this;
  }
  NewerSimpleTable& set_z(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->z_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  NewerSimpleTable& set_z(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->z_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(6));
    return *this;
  }

  NewerSimpleTable& clear_z() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->z_.clear_data();
    return *this;
  }

  explicit NewerSimpleTable(::fidl::AnyArena& allocator)
      : frame_ptr_(
            ::fidl::ObjectView<
                ::fidl::WireTableFrame<::test_table::wire::NewerSimpleTable>>(
                allocator)) {}
  // This constructor allows a user controlled allocation (not using a Arena).
  // It should only be used when performance is key.
  // As soon as the frame is given to the table, it must not be used directly or
  // for another table.
  explicit NewerSimpleTable(
      ::fidl::ObjectView<
          ::fidl::WireTableFrame<::test_table::wire::NewerSimpleTable>>&& frame)
      : frame_ptr_(std::move(frame)) {}

  void Allocate(::fidl::AnyArena& allocator) {
    max_ordinal_ = 0;
    frame_ptr_ = ::fidl::ObjectView<
        ::fidl::WireTableFrame<::test_table::wire::NewerSimpleTable>>(
        allocator);
  }
  void Init(::fidl::ObjectView<::fidl::WireTableFrame<
                ::test_table::wire::NewerSimpleTable>>&& frame_ptr) {
    max_ordinal_ = 0;
    frame_ptr_ = std::move(frame_ptr);
  }

 private:
  friend ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::NewerSimpleTable,
      ::fidl::WireTableBuilder<::test_table::wire::NewerSimpleTable>>;
  friend ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::NewerSimpleTable,
      ::fidl::WireTableExternalBuilder<::test_table::wire::NewerSimpleTable>>;

  uint64_t max_ordinal_ = 0;
  ::fidl::ObjectView<
      ::fidl::WireTableFrame<::test_table::wire::NewerSimpleTable>>
      frame_ptr_;
};
}  // namespace wire
}  // namespace test_table
template <typename BuilderImpl>
class ::fidl::internal::WireTableBaseBuilder<
    ::test_table::wire::NewerSimpleTable, BuilderImpl> {
 public:
  // Build and return the table. The builder should not be used after this.
  ::test_table::wire::NewerSimpleTable Build() {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    ::test_table::wire::NewerSimpleTable t = std::move(table_);
    // Poison this builder to prevent accidental reuse.
    table_.frame_ptr_ = nullptr;
    return t;
  }

  BuilderImpl& x(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->x_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(1));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& y(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->y_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(5));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& z(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->z_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(6));
    return *static_cast<BuilderImpl*>(this);
  }

 protected:
  WireTableBaseBuilder(
      ::fidl::ObjectView<
          ::fidl::WireTableFrame<::test_table::wire::NewerSimpleTable>>&& frame)
      : table_(std::move(frame)) {}

 private:
  ::test_table::wire::NewerSimpleTable table_;
};

template <>
class ::fidl::WireTableBuilder<::test_table::wire::NewerSimpleTable> final
    : public ::fidl::internal::WireTableBaseBuilder<
          ::test_table::wire::NewerSimpleTable,
          ::fidl::WireTableBuilder<::test_table::wire::NewerSimpleTable>> {
  using Base = ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::NewerSimpleTable,
      ::fidl::WireTableBuilder<::test_table::wire::NewerSimpleTable>>;

 public:
  using Base::x;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::NewerSimpleTable>& x(
      Args&&... args_) {
    x(::fidl::ObjectView<int64_t>(arena_.get(), std::forward<Args>(args_)...));
    return *this;
  }
  using Base::y;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::NewerSimpleTable>& y(
      Args&&... args_) {
    y(::fidl::ObjectView<int64_t>(arena_.get(), std::forward<Args>(args_)...));
    return *this;
  }
  using Base::z;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::NewerSimpleTable>& z(
      Args&&... args_) {
    z(::fidl::ObjectView<int64_t>(arena_.get(), std::forward<Args>(args_)...));
    return *this;
  }

 private:
  friend class ::test_table::wire::NewerSimpleTable;
  WireTableBuilder(::fidl::AnyArena& arena)
      : Base(::fidl::ObjectView<
             ::fidl::WireTableFrame<::test_table::wire::NewerSimpleTable>>(
            arena)),
        arena_(arena) {}

  [[maybe_unused]] std::reference_wrapper<::fidl::AnyArena> arena_;
};

template <>
class ::fidl::WireTableExternalBuilder<::test_table::wire::NewerSimpleTable>
    final : public ::fidl::internal::WireTableBaseBuilder<
                ::test_table::wire::NewerSimpleTable,
                ::fidl::WireTableExternalBuilder<
                    ::test_table::wire::NewerSimpleTable>> {
  using Base = ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::NewerSimpleTable,
      ::fidl::WireTableExternalBuilder<::test_table::wire::NewerSimpleTable>>;

 private:
  friend class ::test_table::wire::NewerSimpleTable;
  using Base::Base;
  WireTableExternalBuilder(
      ::fidl::WireTableFrame<::test_table::wire::NewerSimpleTable>* frame)
      : Base(::fidl::ObjectView<::fidl::WireTableFrame<
                 ::test_table::wire::NewerSimpleTable>>::FromExternal(frame)) {}
};
namespace test_table {
namespace wire {
inline ::fidl::WireTableBuilder<::test_table::wire::NewerSimpleTable>
NewerSimpleTable::Builder(::fidl::AnyArena& arena) {
  return ::fidl::WireTableBuilder<::test_table::wire::NewerSimpleTable>(arena);
}
inline ::fidl::WireTableExternalBuilder<::test_table::wire::NewerSimpleTable>
NewerSimpleTable::ExternalBuilder(
    ::fidl::ObjectView<
        ::fidl::WireTableFrame<::test_table::wire::NewerSimpleTable>>
        frame) {
  return ::fidl::WireTableExternalBuilder<::test_table::wire::NewerSimpleTable>(
      std::move(frame));
}

}  // namespace wire
}  // namespace test_table
template <>
class ::fidl::WireTableBuilder<::test_table::wire::ExtensionTable>;
template <>
class ::fidl::WireTableExternalBuilder<::test_table::wire::ExtensionTable>;

template <>
struct ::fidl::WireTableFrame<::test_table::wire::ExtensionTable> final {
 public:
  WireTableFrame() = default;
  // In its intended usage, WireTableFrame will be referenced by an ObjectView.
  // If the ObjectView is assigned before a move or copy, then it will reference
  // the old invalid object. Because this is unsafe, copies are disallowed and
  // moves are only allowed by friend classes that operate safely.
  WireTableFrame(const WireTableFrame&) = delete;
  WireTableFrame& operator=(const WireTableFrame&) = delete;

 private:
  WireTableFrame(WireTableFrame&&) noexcept = default;
  WireTableFrame& operator=(WireTableFrame&&) noexcept = default;

  bool HasUnknownData() const;

  friend class ::test_table::wire::ExtensionTable;
  friend ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::ExtensionTable,
      ::fidl::WireTableBuilder<::test_table::wire::ExtensionTable>>;
  friend ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::ExtensionTable,
      ::fidl::WireTableExternalBuilder<::test_table::wire::ExtensionTable>>;
};

namespace test_table {
namespace wire {
extern "C" const fidl_type_t test_table_ExtensionTableTable;

class ExtensionTable {
 public:
  ExtensionTable() = default;
  ExtensionTable(const ExtensionTable& other) noexcept = default;
  ExtensionTable& operator=(const ExtensionTable& other) noexcept = default;
  ExtensionTable(ExtensionTable&& other) noexcept = default;
  ExtensionTable& operator=(ExtensionTable&& other) noexcept = default;

  ~ExtensionTable() = default;

  // Returns whether no field is set.
  bool IsEmpty() const { return max_ordinal_ == 0; }

  // Returns whether the table references unknown fields.
  bool HasUnknownData() const;

  // Return a builder that by defaults allocates of an arena.
  static ::fidl::WireTableBuilder<::test_table::wire::ExtensionTable> Builder(
      ::fidl::AnyArena& arena);

  // Return a builder that relies on explicitly allocating |fidl::ObjectView|s.
  static ::fidl::WireTableExternalBuilder<::test_table::wire::ExtensionTable>
  ExternalBuilder(::fidl::ObjectView<
                  ::fidl::WireTableFrame<::test_table::wire::ExtensionTable>>
                      frame);
#if defined(FIDL_WIRE_ALLOW_DEPRECATED_MUTABLE_TABLES) || false
 public:
#else   // !defined(FIDL_WIRE_ALLOW_DEPRECATED_MUTABLE_TABLES)
 private:
#endif  // FIDL_WIRE_ALLOW_DEPRECATED_MUTABLE_TABLES

  explicit ExtensionTable(::fidl::AnyArena& allocator)
      : frame_ptr_(::fidl::ObjectView<
                   ::fidl::WireTableFrame<::test_table::wire::ExtensionTable>>(
            allocator)) {}
  // This constructor allows a user controlled allocation (not using a Arena).
  // It should only be used when performance is key.
  // As soon as the frame is given to the table, it must not be used directly or
  // for another table.
  explicit ExtensionTable(
      ::fidl::ObjectView<
          ::fidl::WireTableFrame<::test_table::wire::ExtensionTable>>&& frame)
      : frame_ptr_(std::move(frame)) {}

  void Allocate(::fidl::AnyArena& allocator) {
    max_ordinal_ = 0;
    frame_ptr_ = ::fidl::ObjectView<
        ::fidl::WireTableFrame<::test_table::wire::ExtensionTable>>(allocator);
  }
  void Init(::fidl::ObjectView<::fidl::WireTableFrame<
                ::test_table::wire::ExtensionTable>>&& frame_ptr) {
    max_ordinal_ = 0;
    frame_ptr_ = std::move(frame_ptr);
  }

 private:
  friend ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::ExtensionTable,
      ::fidl::WireTableBuilder<::test_table::wire::ExtensionTable>>;
  friend ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::ExtensionTable,
      ::fidl::WireTableExternalBuilder<::test_table::wire::ExtensionTable>>;

  uint64_t max_ordinal_ = 0;
  ::fidl::ObjectView<::fidl::WireTableFrame<::test_table::wire::ExtensionTable>>
      frame_ptr_;
};
}  // namespace wire
}  // namespace test_table
template <typename BuilderImpl>
class ::fidl::internal::WireTableBaseBuilder<::test_table::wire::ExtensionTable,
                                             BuilderImpl> {
 public:
  // Build and return the table. The builder should not be used after this.
  ::test_table::wire::ExtensionTable Build() {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    ::test_table::wire::ExtensionTable t = std::move(table_);
    // Poison this builder to prevent accidental reuse.
    table_.frame_ptr_ = nullptr;
    return t;
  }

 protected:
  WireTableBaseBuilder(
      ::fidl::ObjectView<
          ::fidl::WireTableFrame<::test_table::wire::ExtensionTable>>&& frame)
      : table_(std::move(frame)) {}

 private:
  ::test_table::wire::ExtensionTable table_;
};

template <>
class ::fidl::WireTableBuilder<::test_table::wire::ExtensionTable> final
    : public ::fidl::internal::WireTableBaseBuilder<
          ::test_table::wire::ExtensionTable,
          ::fidl::WireTableBuilder<::test_table::wire::ExtensionTable>> {
  using Base = ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::ExtensionTable,
      ::fidl::WireTableBuilder<::test_table::wire::ExtensionTable>>;

 public:
 private:
  friend class ::test_table::wire::ExtensionTable;
  WireTableBuilder(::fidl::AnyArena& arena)
      : Base(::fidl::ObjectView<
             ::fidl::WireTableFrame<::test_table::wire::ExtensionTable>>(
            arena)),
        arena_(arena) {}

  [[maybe_unused]] std::reference_wrapper<::fidl::AnyArena> arena_;
};

template <>
class ::fidl::WireTableExternalBuilder<::test_table::wire::ExtensionTable> final
    : public ::fidl::internal::WireTableBaseBuilder<
          ::test_table::wire::ExtensionTable,
          ::fidl::WireTableExternalBuilder<
              ::test_table::wire::ExtensionTable>> {
  using Base = ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::ExtensionTable,
      ::fidl::WireTableExternalBuilder<::test_table::wire::ExtensionTable>>;

 private:
  friend class ::test_table::wire::ExtensionTable;
  using Base::Base;
  WireTableExternalBuilder(
      ::fidl::WireTableFrame<::test_table::wire::ExtensionTable>* frame)
      : Base(::fidl::ObjectView<::fidl::WireTableFrame<
                 ::test_table::wire::ExtensionTable>>::FromExternal(frame)) {}
};
namespace test_table {
namespace wire {
inline ::fidl::WireTableBuilder<::test_table::wire::ExtensionTable>
ExtensionTable::Builder(::fidl::AnyArena& arena) {
  return ::fidl::WireTableBuilder<::test_table::wire::ExtensionTable>(arena);
}
inline ::fidl::WireTableExternalBuilder<::test_table::wire::ExtensionTable>
ExtensionTable::ExternalBuilder(
    ::fidl::ObjectView<
        ::fidl::WireTableFrame<::test_table::wire::ExtensionTable>>
        frame) {
  return ::fidl::WireTableExternalBuilder<::test_table::wire::ExtensionTable>(
      std::move(frame));
}

}  // namespace wire
}  // namespace test_table
template <>
class ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>;
template <>
class ::fidl::WireTableExternalBuilder<
    ::test_table::wire::SixtyFourOrdinalTable>;

template <>
struct ::fidl::WireTableFrame<::test_table::wire::SixtyFourOrdinalTable> final {
 public:
  WireTableFrame() = default;
  // In its intended usage, WireTableFrame will be referenced by an ObjectView.
  // If the ObjectView is assigned before a move or copy, then it will reference
  // the old invalid object. Because this is unsafe, copies are disallowed and
  // moves are only allowed by friend classes that operate safely.
  WireTableFrame(const WireTableFrame&) = delete;
  WireTableFrame& operator=(const WireTableFrame&) = delete;

 private:
  WireTableFrame(WireTableFrame&&) noexcept = default;
  WireTableFrame& operator=(WireTableFrame&&) noexcept = default;

  bool HasUnknownData() const;
  ::fidl::Envelope<int64_t> v1_;
  ::fidl::Envelope<int64_t> v2_;
  ::fidl::Envelope<int64_t> v3_;
  ::fidl::Envelope<int64_t> v4_;
  ::fidl::Envelope<int64_t> v5_;
  ::fidl::Envelope<int64_t> v6_;
  ::fidl::Envelope<int64_t> v7_;
  ::fidl::Envelope<int64_t> v8_;
  ::fidl::Envelope<int64_t> v9_;
  ::fidl::Envelope<int64_t> v10_;
  ::fidl::Envelope<int64_t> v11_;
  ::fidl::Envelope<int64_t> v12_;
  ::fidl::Envelope<int64_t> v13_;
  ::fidl::Envelope<int64_t> v14_;
  ::fidl::Envelope<int64_t> v15_;
  ::fidl::Envelope<int64_t> v16_;
  ::fidl::Envelope<int64_t> v17_;
  ::fidl::Envelope<int64_t> v18_;
  ::fidl::Envelope<int64_t> v19_;
  ::fidl::Envelope<int64_t> v20_;
  ::fidl::Envelope<int64_t> v21_;
  ::fidl::Envelope<int64_t> v22_;
  ::fidl::Envelope<int64_t> v23_;
  ::fidl::Envelope<int64_t> v24_;
  ::fidl::Envelope<int64_t> v25_;
  ::fidl::Envelope<int64_t> v26_;
  ::fidl::Envelope<int64_t> v27_;
  ::fidl::Envelope<int64_t> v28_;
  ::fidl::Envelope<int64_t> v29_;
  ::fidl::Envelope<int64_t> v30_;
  ::fidl::Envelope<int64_t> v31_;
  ::fidl::Envelope<int64_t> v32_;
  ::fidl::Envelope<int64_t> v33_;
  ::fidl::Envelope<int64_t> v34_;
  ::fidl::Envelope<int64_t> v35_;
  ::fidl::Envelope<int64_t> v36_;
  ::fidl::Envelope<int64_t> v37_;
  ::fidl::Envelope<int64_t> v38_;
  ::fidl::Envelope<int64_t> v39_;
  ::fidl::Envelope<int64_t> v40_;
  ::fidl::Envelope<int64_t> v41_;
  ::fidl::Envelope<int64_t> v42_;
  ::fidl::Envelope<int64_t> v43_;
  ::fidl::Envelope<int64_t> v44_;
  ::fidl::Envelope<int64_t> v45_;
  ::fidl::Envelope<int64_t> v46_;
  ::fidl::Envelope<int64_t> v47_;
  ::fidl::Envelope<int64_t> v48_;
  ::fidl::Envelope<int64_t> v49_;
  ::fidl::Envelope<int64_t> v50_;
  ::fidl::Envelope<int64_t> v51_;
  ::fidl::Envelope<int64_t> v52_;
  ::fidl::Envelope<int64_t> v53_;
  ::fidl::Envelope<int64_t> v54_;
  ::fidl::Envelope<int64_t> v55_;
  ::fidl::Envelope<int64_t> v56_;
  ::fidl::Envelope<int64_t> v57_;
  ::fidl::Envelope<int64_t> v58_;
  ::fidl::Envelope<int64_t> v59_;
  ::fidl::Envelope<int64_t> v60_;
  ::fidl::Envelope<int64_t> v61_;
  ::fidl::Envelope<int64_t> v62_;
  ::fidl::Envelope<int64_t> v63_;
  ::fidl::Envelope<::test_table::wire::ExtensionTable> v64_;

  friend class ::test_table::wire::SixtyFourOrdinalTable;
  friend ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::SixtyFourOrdinalTable,
      ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>>;
  friend ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::SixtyFourOrdinalTable,
      ::fidl::WireTableExternalBuilder<
          ::test_table::wire::SixtyFourOrdinalTable>>;
};

namespace test_table {
namespace wire {
extern "C" const fidl_type_t test_table_SixtyFourOrdinalTableTable;

class SixtyFourOrdinalTable {
 public:
  SixtyFourOrdinalTable() = default;
  SixtyFourOrdinalTable(const SixtyFourOrdinalTable& other) noexcept = default;
  SixtyFourOrdinalTable& operator=(
      const SixtyFourOrdinalTable& other) noexcept = default;
  SixtyFourOrdinalTable(SixtyFourOrdinalTable&& other) noexcept = default;
  SixtyFourOrdinalTable& operator=(SixtyFourOrdinalTable&& other) noexcept =
      default;

  ~SixtyFourOrdinalTable() = default;

  // Returns whether no field is set.
  bool IsEmpty() const { return max_ordinal_ == 0; }

  // Returns whether the table references unknown fields.
  bool HasUnknownData() const;

  // Return a builder that by defaults allocates of an arena.
  static ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>
  Builder(::fidl::AnyArena& arena);

  // Return a builder that relies on explicitly allocating |fidl::ObjectView|s.
  static ::fidl::WireTableExternalBuilder<
      ::test_table::wire::SixtyFourOrdinalTable>
  ExternalBuilder(
      ::fidl::ObjectView<
          ::fidl::WireTableFrame<::test_table::wire::SixtyFourOrdinalTable>>
          frame);

  const int64_t& v1() const {
    ZX_ASSERT(has_v1());
    return frame_ptr_->v1_.get_data();
  }
  int64_t& v1() {
    ZX_ASSERT(has_v1());
    return frame_ptr_->v1_.get_data();
  }
  bool has_v1() const {
    return max_ordinal_ >= 1 && frame_ptr_->v1_.has_data();
  }

  const int64_t& v2() const {
    ZX_ASSERT(has_v2());
    return frame_ptr_->v2_.get_data();
  }
  int64_t& v2() {
    ZX_ASSERT(has_v2());
    return frame_ptr_->v2_.get_data();
  }
  bool has_v2() const {
    return max_ordinal_ >= 2 && frame_ptr_->v2_.has_data();
  }

  const int64_t& v3() const {
    ZX_ASSERT(has_v3());
    return frame_ptr_->v3_.get_data();
  }
  int64_t& v3() {
    ZX_ASSERT(has_v3());
    return frame_ptr_->v3_.get_data();
  }
  bool has_v3() const {
    return max_ordinal_ >= 3 && frame_ptr_->v3_.has_data();
  }

  const int64_t& v4() const {
    ZX_ASSERT(has_v4());
    return frame_ptr_->v4_.get_data();
  }
  int64_t& v4() {
    ZX_ASSERT(has_v4());
    return frame_ptr_->v4_.get_data();
  }
  bool has_v4() const {
    return max_ordinal_ >= 4 && frame_ptr_->v4_.has_data();
  }

  const int64_t& v5() const {
    ZX_ASSERT(has_v5());
    return frame_ptr_->v5_.get_data();
  }
  int64_t& v5() {
    ZX_ASSERT(has_v5());
    return frame_ptr_->v5_.get_data();
  }
  bool has_v5() const {
    return max_ordinal_ >= 5 && frame_ptr_->v5_.has_data();
  }

  const int64_t& v6() const {
    ZX_ASSERT(has_v6());
    return frame_ptr_->v6_.get_data();
  }
  int64_t& v6() {
    ZX_ASSERT(has_v6());
    return frame_ptr_->v6_.get_data();
  }
  bool has_v6() const {
    return max_ordinal_ >= 6 && frame_ptr_->v6_.has_data();
  }

  const int64_t& v7() const {
    ZX_ASSERT(has_v7());
    return frame_ptr_->v7_.get_data();
  }
  int64_t& v7() {
    ZX_ASSERT(has_v7());
    return frame_ptr_->v7_.get_data();
  }
  bool has_v7() const {
    return max_ordinal_ >= 7 && frame_ptr_->v7_.has_data();
  }

  const int64_t& v8() const {
    ZX_ASSERT(has_v8());
    return frame_ptr_->v8_.get_data();
  }
  int64_t& v8() {
    ZX_ASSERT(has_v8());
    return frame_ptr_->v8_.get_data();
  }
  bool has_v8() const {
    return max_ordinal_ >= 8 && frame_ptr_->v8_.has_data();
  }

  const int64_t& v9() const {
    ZX_ASSERT(has_v9());
    return frame_ptr_->v9_.get_data();
  }
  int64_t& v9() {
    ZX_ASSERT(has_v9());
    return frame_ptr_->v9_.get_data();
  }
  bool has_v9() const {
    return max_ordinal_ >= 9 && frame_ptr_->v9_.has_data();
  }

  const int64_t& v10() const {
    ZX_ASSERT(has_v10());
    return frame_ptr_->v10_.get_data();
  }
  int64_t& v10() {
    ZX_ASSERT(has_v10());
    return frame_ptr_->v10_.get_data();
  }
  bool has_v10() const {
    return max_ordinal_ >= 10 && frame_ptr_->v10_.has_data();
  }

  const int64_t& v11() const {
    ZX_ASSERT(has_v11());
    return frame_ptr_->v11_.get_data();
  }
  int64_t& v11() {
    ZX_ASSERT(has_v11());
    return frame_ptr_->v11_.get_data();
  }
  bool has_v11() const {
    return max_ordinal_ >= 11 && frame_ptr_->v11_.has_data();
  }

  const int64_t& v12() const {
    ZX_ASSERT(has_v12());
    return frame_ptr_->v12_.get_data();
  }
  int64_t& v12() {
    ZX_ASSERT(has_v12());
    return frame_ptr_->v12_.get_data();
  }
  bool has_v12() const {
    return max_ordinal_ >= 12 && frame_ptr_->v12_.has_data();
  }

  const int64_t& v13() const {
    ZX_ASSERT(has_v13());
    return frame_ptr_->v13_.get_data();
  }
  int64_t& v13() {
    ZX_ASSERT(has_v13());
    return frame_ptr_->v13_.get_data();
  }
  bool has_v13() const {
    return max_ordinal_ >= 13 && frame_ptr_->v13_.has_data();
  }

  const int64_t& v14() const {
    ZX_ASSERT(has_v14());
    return frame_ptr_->v14_.get_data();
  }
  int64_t& v14() {
    ZX_ASSERT(has_v14());
    return frame_ptr_->v14_.get_data();
  }
  bool has_v14() const {
    return max_ordinal_ >= 14 && frame_ptr_->v14_.has_data();
  }

  const int64_t& v15() const {
    ZX_ASSERT(has_v15());
    return frame_ptr_->v15_.get_data();
  }
  int64_t& v15() {
    ZX_ASSERT(has_v15());
    return frame_ptr_->v15_.get_data();
  }
  bool has_v15() const {
    return max_ordinal_ >= 15 && frame_ptr_->v15_.has_data();
  }

  const int64_t& v16() const {
    ZX_ASSERT(has_v16());
    return frame_ptr_->v16_.get_data();
  }
  int64_t& v16() {
    ZX_ASSERT(has_v16());
    return frame_ptr_->v16_.get_data();
  }
  bool has_v16() const {
    return max_ordinal_ >= 16 && frame_ptr_->v16_.has_data();
  }

  const int64_t& v17() const {
    ZX_ASSERT(has_v17());
    return frame_ptr_->v17_.get_data();
  }
  int64_t& v17() {
    ZX_ASSERT(has_v17());
    return frame_ptr_->v17_.get_data();
  }
  bool has_v17() const {
    return max_ordinal_ >= 17 && frame_ptr_->v17_.has_data();
  }

  const int64_t& v18() const {
    ZX_ASSERT(has_v18());
    return frame_ptr_->v18_.get_data();
  }
  int64_t& v18() {
    ZX_ASSERT(has_v18());
    return frame_ptr_->v18_.get_data();
  }
  bool has_v18() const {
    return max_ordinal_ >= 18 && frame_ptr_->v18_.has_data();
  }

  const int64_t& v19() const {
    ZX_ASSERT(has_v19());
    return frame_ptr_->v19_.get_data();
  }
  int64_t& v19() {
    ZX_ASSERT(has_v19());
    return frame_ptr_->v19_.get_data();
  }
  bool has_v19() const {
    return max_ordinal_ >= 19 && frame_ptr_->v19_.has_data();
  }

  const int64_t& v20() const {
    ZX_ASSERT(has_v20());
    return frame_ptr_->v20_.get_data();
  }
  int64_t& v20() {
    ZX_ASSERT(has_v20());
    return frame_ptr_->v20_.get_data();
  }
  bool has_v20() const {
    return max_ordinal_ >= 20 && frame_ptr_->v20_.has_data();
  }

  const int64_t& v21() const {
    ZX_ASSERT(has_v21());
    return frame_ptr_->v21_.get_data();
  }
  int64_t& v21() {
    ZX_ASSERT(has_v21());
    return frame_ptr_->v21_.get_data();
  }
  bool has_v21() const {
    return max_ordinal_ >= 21 && frame_ptr_->v21_.has_data();
  }

  const int64_t& v22() const {
    ZX_ASSERT(has_v22());
    return frame_ptr_->v22_.get_data();
  }
  int64_t& v22() {
    ZX_ASSERT(has_v22());
    return frame_ptr_->v22_.get_data();
  }
  bool has_v22() const {
    return max_ordinal_ >= 22 && frame_ptr_->v22_.has_data();
  }

  const int64_t& v23() const {
    ZX_ASSERT(has_v23());
    return frame_ptr_->v23_.get_data();
  }
  int64_t& v23() {
    ZX_ASSERT(has_v23());
    return frame_ptr_->v23_.get_data();
  }
  bool has_v23() const {
    return max_ordinal_ >= 23 && frame_ptr_->v23_.has_data();
  }

  const int64_t& v24() const {
    ZX_ASSERT(has_v24());
    return frame_ptr_->v24_.get_data();
  }
  int64_t& v24() {
    ZX_ASSERT(has_v24());
    return frame_ptr_->v24_.get_data();
  }
  bool has_v24() const {
    return max_ordinal_ >= 24 && frame_ptr_->v24_.has_data();
  }

  const int64_t& v25() const {
    ZX_ASSERT(has_v25());
    return frame_ptr_->v25_.get_data();
  }
  int64_t& v25() {
    ZX_ASSERT(has_v25());
    return frame_ptr_->v25_.get_data();
  }
  bool has_v25() const {
    return max_ordinal_ >= 25 && frame_ptr_->v25_.has_data();
  }

  const int64_t& v26() const {
    ZX_ASSERT(has_v26());
    return frame_ptr_->v26_.get_data();
  }
  int64_t& v26() {
    ZX_ASSERT(has_v26());
    return frame_ptr_->v26_.get_data();
  }
  bool has_v26() const {
    return max_ordinal_ >= 26 && frame_ptr_->v26_.has_data();
  }

  const int64_t& v27() const {
    ZX_ASSERT(has_v27());
    return frame_ptr_->v27_.get_data();
  }
  int64_t& v27() {
    ZX_ASSERT(has_v27());
    return frame_ptr_->v27_.get_data();
  }
  bool has_v27() const {
    return max_ordinal_ >= 27 && frame_ptr_->v27_.has_data();
  }

  const int64_t& v28() const {
    ZX_ASSERT(has_v28());
    return frame_ptr_->v28_.get_data();
  }
  int64_t& v28() {
    ZX_ASSERT(has_v28());
    return frame_ptr_->v28_.get_data();
  }
  bool has_v28() const {
    return max_ordinal_ >= 28 && frame_ptr_->v28_.has_data();
  }

  const int64_t& v29() const {
    ZX_ASSERT(has_v29());
    return frame_ptr_->v29_.get_data();
  }
  int64_t& v29() {
    ZX_ASSERT(has_v29());
    return frame_ptr_->v29_.get_data();
  }
  bool has_v29() const {
    return max_ordinal_ >= 29 && frame_ptr_->v29_.has_data();
  }

  const int64_t& v30() const {
    ZX_ASSERT(has_v30());
    return frame_ptr_->v30_.get_data();
  }
  int64_t& v30() {
    ZX_ASSERT(has_v30());
    return frame_ptr_->v30_.get_data();
  }
  bool has_v30() const {
    return max_ordinal_ >= 30 && frame_ptr_->v30_.has_data();
  }

  const int64_t& v31() const {
    ZX_ASSERT(has_v31());
    return frame_ptr_->v31_.get_data();
  }
  int64_t& v31() {
    ZX_ASSERT(has_v31());
    return frame_ptr_->v31_.get_data();
  }
  bool has_v31() const {
    return max_ordinal_ >= 31 && frame_ptr_->v31_.has_data();
  }

  const int64_t& v32() const {
    ZX_ASSERT(has_v32());
    return frame_ptr_->v32_.get_data();
  }
  int64_t& v32() {
    ZX_ASSERT(has_v32());
    return frame_ptr_->v32_.get_data();
  }
  bool has_v32() const {
    return max_ordinal_ >= 32 && frame_ptr_->v32_.has_data();
  }

  const int64_t& v33() const {
    ZX_ASSERT(has_v33());
    return frame_ptr_->v33_.get_data();
  }
  int64_t& v33() {
    ZX_ASSERT(has_v33());
    return frame_ptr_->v33_.get_data();
  }
  bool has_v33() const {
    return max_ordinal_ >= 33 && frame_ptr_->v33_.has_data();
  }

  const int64_t& v34() const {
    ZX_ASSERT(has_v34());
    return frame_ptr_->v34_.get_data();
  }
  int64_t& v34() {
    ZX_ASSERT(has_v34());
    return frame_ptr_->v34_.get_data();
  }
  bool has_v34() const {
    return max_ordinal_ >= 34 && frame_ptr_->v34_.has_data();
  }

  const int64_t& v35() const {
    ZX_ASSERT(has_v35());
    return frame_ptr_->v35_.get_data();
  }
  int64_t& v35() {
    ZX_ASSERT(has_v35());
    return frame_ptr_->v35_.get_data();
  }
  bool has_v35() const {
    return max_ordinal_ >= 35 && frame_ptr_->v35_.has_data();
  }

  const int64_t& v36() const {
    ZX_ASSERT(has_v36());
    return frame_ptr_->v36_.get_data();
  }
  int64_t& v36() {
    ZX_ASSERT(has_v36());
    return frame_ptr_->v36_.get_data();
  }
  bool has_v36() const {
    return max_ordinal_ >= 36 && frame_ptr_->v36_.has_data();
  }

  const int64_t& v37() const {
    ZX_ASSERT(has_v37());
    return frame_ptr_->v37_.get_data();
  }
  int64_t& v37() {
    ZX_ASSERT(has_v37());
    return frame_ptr_->v37_.get_data();
  }
  bool has_v37() const {
    return max_ordinal_ >= 37 && frame_ptr_->v37_.has_data();
  }

  const int64_t& v38() const {
    ZX_ASSERT(has_v38());
    return frame_ptr_->v38_.get_data();
  }
  int64_t& v38() {
    ZX_ASSERT(has_v38());
    return frame_ptr_->v38_.get_data();
  }
  bool has_v38() const {
    return max_ordinal_ >= 38 && frame_ptr_->v38_.has_data();
  }

  const int64_t& v39() const {
    ZX_ASSERT(has_v39());
    return frame_ptr_->v39_.get_data();
  }
  int64_t& v39() {
    ZX_ASSERT(has_v39());
    return frame_ptr_->v39_.get_data();
  }
  bool has_v39() const {
    return max_ordinal_ >= 39 && frame_ptr_->v39_.has_data();
  }

  const int64_t& v40() const {
    ZX_ASSERT(has_v40());
    return frame_ptr_->v40_.get_data();
  }
  int64_t& v40() {
    ZX_ASSERT(has_v40());
    return frame_ptr_->v40_.get_data();
  }
  bool has_v40() const {
    return max_ordinal_ >= 40 && frame_ptr_->v40_.has_data();
  }

  const int64_t& v41() const {
    ZX_ASSERT(has_v41());
    return frame_ptr_->v41_.get_data();
  }
  int64_t& v41() {
    ZX_ASSERT(has_v41());
    return frame_ptr_->v41_.get_data();
  }
  bool has_v41() const {
    return max_ordinal_ >= 41 && frame_ptr_->v41_.has_data();
  }

  const int64_t& v42() const {
    ZX_ASSERT(has_v42());
    return frame_ptr_->v42_.get_data();
  }
  int64_t& v42() {
    ZX_ASSERT(has_v42());
    return frame_ptr_->v42_.get_data();
  }
  bool has_v42() const {
    return max_ordinal_ >= 42 && frame_ptr_->v42_.has_data();
  }

  const int64_t& v43() const {
    ZX_ASSERT(has_v43());
    return frame_ptr_->v43_.get_data();
  }
  int64_t& v43() {
    ZX_ASSERT(has_v43());
    return frame_ptr_->v43_.get_data();
  }
  bool has_v43() const {
    return max_ordinal_ >= 43 && frame_ptr_->v43_.has_data();
  }

  const int64_t& v44() const {
    ZX_ASSERT(has_v44());
    return frame_ptr_->v44_.get_data();
  }
  int64_t& v44() {
    ZX_ASSERT(has_v44());
    return frame_ptr_->v44_.get_data();
  }
  bool has_v44() const {
    return max_ordinal_ >= 44 && frame_ptr_->v44_.has_data();
  }

  const int64_t& v45() const {
    ZX_ASSERT(has_v45());
    return frame_ptr_->v45_.get_data();
  }
  int64_t& v45() {
    ZX_ASSERT(has_v45());
    return frame_ptr_->v45_.get_data();
  }
  bool has_v45() const {
    return max_ordinal_ >= 45 && frame_ptr_->v45_.has_data();
  }

  const int64_t& v46() const {
    ZX_ASSERT(has_v46());
    return frame_ptr_->v46_.get_data();
  }
  int64_t& v46() {
    ZX_ASSERT(has_v46());
    return frame_ptr_->v46_.get_data();
  }
  bool has_v46() const {
    return max_ordinal_ >= 46 && frame_ptr_->v46_.has_data();
  }

  const int64_t& v47() const {
    ZX_ASSERT(has_v47());
    return frame_ptr_->v47_.get_data();
  }
  int64_t& v47() {
    ZX_ASSERT(has_v47());
    return frame_ptr_->v47_.get_data();
  }
  bool has_v47() const {
    return max_ordinal_ >= 47 && frame_ptr_->v47_.has_data();
  }

  const int64_t& v48() const {
    ZX_ASSERT(has_v48());
    return frame_ptr_->v48_.get_data();
  }
  int64_t& v48() {
    ZX_ASSERT(has_v48());
    return frame_ptr_->v48_.get_data();
  }
  bool has_v48() const {
    return max_ordinal_ >= 48 && frame_ptr_->v48_.has_data();
  }

  const int64_t& v49() const {
    ZX_ASSERT(has_v49());
    return frame_ptr_->v49_.get_data();
  }
  int64_t& v49() {
    ZX_ASSERT(has_v49());
    return frame_ptr_->v49_.get_data();
  }
  bool has_v49() const {
    return max_ordinal_ >= 49 && frame_ptr_->v49_.has_data();
  }

  const int64_t& v50() const {
    ZX_ASSERT(has_v50());
    return frame_ptr_->v50_.get_data();
  }
  int64_t& v50() {
    ZX_ASSERT(has_v50());
    return frame_ptr_->v50_.get_data();
  }
  bool has_v50() const {
    return max_ordinal_ >= 50 && frame_ptr_->v50_.has_data();
  }

  const int64_t& v51() const {
    ZX_ASSERT(has_v51());
    return frame_ptr_->v51_.get_data();
  }
  int64_t& v51() {
    ZX_ASSERT(has_v51());
    return frame_ptr_->v51_.get_data();
  }
  bool has_v51() const {
    return max_ordinal_ >= 51 && frame_ptr_->v51_.has_data();
  }

  const int64_t& v52() const {
    ZX_ASSERT(has_v52());
    return frame_ptr_->v52_.get_data();
  }
  int64_t& v52() {
    ZX_ASSERT(has_v52());
    return frame_ptr_->v52_.get_data();
  }
  bool has_v52() const {
    return max_ordinal_ >= 52 && frame_ptr_->v52_.has_data();
  }

  const int64_t& v53() const {
    ZX_ASSERT(has_v53());
    return frame_ptr_->v53_.get_data();
  }
  int64_t& v53() {
    ZX_ASSERT(has_v53());
    return frame_ptr_->v53_.get_data();
  }
  bool has_v53() const {
    return max_ordinal_ >= 53 && frame_ptr_->v53_.has_data();
  }

  const int64_t& v54() const {
    ZX_ASSERT(has_v54());
    return frame_ptr_->v54_.get_data();
  }
  int64_t& v54() {
    ZX_ASSERT(has_v54());
    return frame_ptr_->v54_.get_data();
  }
  bool has_v54() const {
    return max_ordinal_ >= 54 && frame_ptr_->v54_.has_data();
  }

  const int64_t& v55() const {
    ZX_ASSERT(has_v55());
    return frame_ptr_->v55_.get_data();
  }
  int64_t& v55() {
    ZX_ASSERT(has_v55());
    return frame_ptr_->v55_.get_data();
  }
  bool has_v55() const {
    return max_ordinal_ >= 55 && frame_ptr_->v55_.has_data();
  }

  const int64_t& v56() const {
    ZX_ASSERT(has_v56());
    return frame_ptr_->v56_.get_data();
  }
  int64_t& v56() {
    ZX_ASSERT(has_v56());
    return frame_ptr_->v56_.get_data();
  }
  bool has_v56() const {
    return max_ordinal_ >= 56 && frame_ptr_->v56_.has_data();
  }

  const int64_t& v57() const {
    ZX_ASSERT(has_v57());
    return frame_ptr_->v57_.get_data();
  }
  int64_t& v57() {
    ZX_ASSERT(has_v57());
    return frame_ptr_->v57_.get_data();
  }
  bool has_v57() const {
    return max_ordinal_ >= 57 && frame_ptr_->v57_.has_data();
  }

  const int64_t& v58() const {
    ZX_ASSERT(has_v58());
    return frame_ptr_->v58_.get_data();
  }
  int64_t& v58() {
    ZX_ASSERT(has_v58());
    return frame_ptr_->v58_.get_data();
  }
  bool has_v58() const {
    return max_ordinal_ >= 58 && frame_ptr_->v58_.has_data();
  }

  const int64_t& v59() const {
    ZX_ASSERT(has_v59());
    return frame_ptr_->v59_.get_data();
  }
  int64_t& v59() {
    ZX_ASSERT(has_v59());
    return frame_ptr_->v59_.get_data();
  }
  bool has_v59() const {
    return max_ordinal_ >= 59 && frame_ptr_->v59_.has_data();
  }

  const int64_t& v60() const {
    ZX_ASSERT(has_v60());
    return frame_ptr_->v60_.get_data();
  }
  int64_t& v60() {
    ZX_ASSERT(has_v60());
    return frame_ptr_->v60_.get_data();
  }
  bool has_v60() const {
    return max_ordinal_ >= 60 && frame_ptr_->v60_.has_data();
  }

  const int64_t& v61() const {
    ZX_ASSERT(has_v61());
    return frame_ptr_->v61_.get_data();
  }
  int64_t& v61() {
    ZX_ASSERT(has_v61());
    return frame_ptr_->v61_.get_data();
  }
  bool has_v61() const {
    return max_ordinal_ >= 61 && frame_ptr_->v61_.has_data();
  }

  const int64_t& v62() const {
    ZX_ASSERT(has_v62());
    return frame_ptr_->v62_.get_data();
  }
  int64_t& v62() {
    ZX_ASSERT(has_v62());
    return frame_ptr_->v62_.get_data();
  }
  bool has_v62() const {
    return max_ordinal_ >= 62 && frame_ptr_->v62_.has_data();
  }

  const int64_t& v63() const {
    ZX_ASSERT(has_v63());
    return frame_ptr_->v63_.get_data();
  }
  int64_t& v63() {
    ZX_ASSERT(has_v63());
    return frame_ptr_->v63_.get_data();
  }
  bool has_v63() const {
    return max_ordinal_ >= 63 && frame_ptr_->v63_.has_data();
  }

  const ::test_table::wire::ExtensionTable& v64() const {
    ZX_ASSERT(has_v64());
    return frame_ptr_->v64_.get_data();
  }
  ::test_table::wire::ExtensionTable& v64() {
    ZX_ASSERT(has_v64());
    return frame_ptr_->v64_.get_data();
  }
  bool has_v64() const {
    return max_ordinal_ >= 64 && frame_ptr_->v64_.has_data();
  }
#if defined(FIDL_WIRE_ALLOW_DEPRECATED_MUTABLE_TABLES) || false
 public:
#else   // !defined(FIDL_WIRE_ALLOW_DEPRECATED_MUTABLE_TABLES)
 private:
#endif  // FIDL_WIRE_ALLOW_DEPRECATED_MUTABLE_TABLES

  SixtyFourOrdinalTable& set_v1(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v1_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(1));
    return *this;
  }
  SixtyFourOrdinalTable& set_v1(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v1_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v1(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v1_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(1));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v1() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v1_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v2(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v2_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(2));
    return *this;
  }
  SixtyFourOrdinalTable& set_v2(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v2_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v2(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v2_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(2));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v2() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v2_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v3(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v3_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(3));
    return *this;
  }
  SixtyFourOrdinalTable& set_v3(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v3_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v3(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v3_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(3));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v3() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v3_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v4(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v4_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(4));
    return *this;
  }
  SixtyFourOrdinalTable& set_v4(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v4_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v4(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v4_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(4));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v4() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v4_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v5(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v5_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(5));
    return *this;
  }
  SixtyFourOrdinalTable& set_v5(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v5_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v5(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v5_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(5));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v5() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v5_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v6(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v6_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(6));
    return *this;
  }
  SixtyFourOrdinalTable& set_v6(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v6_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v6(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v6_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(6));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v6() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v6_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v7(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v7_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(7));
    return *this;
  }
  SixtyFourOrdinalTable& set_v7(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v7_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v7(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v7_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(7));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v7() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v7_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v8(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v8_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(8));
    return *this;
  }
  SixtyFourOrdinalTable& set_v8(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v8_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v8(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v8_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(8));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v8() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v8_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v9(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v9_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(9));
    return *this;
  }
  SixtyFourOrdinalTable& set_v9(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v9_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v9(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v9_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(9));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v9() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v9_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v10(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v10_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(10));
    return *this;
  }
  SixtyFourOrdinalTable& set_v10(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v10_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v10(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v10_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(10));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v10() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v10_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v11(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v11_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(11));
    return *this;
  }
  SixtyFourOrdinalTable& set_v11(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v11_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v11(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v11_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(11));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v11() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v11_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v12(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v12_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(12));
    return *this;
  }
  SixtyFourOrdinalTable& set_v12(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v12_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v12(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v12_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(12));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v12() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v12_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v13(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v13_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(13));
    return *this;
  }
  SixtyFourOrdinalTable& set_v13(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v13_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v13(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v13_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(13));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v13() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v13_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v14(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v14_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(14));
    return *this;
  }
  SixtyFourOrdinalTable& set_v14(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v14_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v14(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v14_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(14));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v14() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v14_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v15(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v15_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(15));
    return *this;
  }
  SixtyFourOrdinalTable& set_v15(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v15_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v15(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v15_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(15));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v15() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v15_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v16(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v16_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(16));
    return *this;
  }
  SixtyFourOrdinalTable& set_v16(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v16_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v16(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v16_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(16));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v16() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v16_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v17(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v17_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(17));
    return *this;
  }
  SixtyFourOrdinalTable& set_v17(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v17_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v17(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v17_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(17));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v17() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v17_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v18(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v18_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(18));
    return *this;
  }
  SixtyFourOrdinalTable& set_v18(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v18_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v18(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v18_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(18));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v18() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v18_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v19(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v19_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(19));
    return *this;
  }
  SixtyFourOrdinalTable& set_v19(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v19_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v19(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v19_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(19));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v19() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v19_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v20(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v20_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(20));
    return *this;
  }
  SixtyFourOrdinalTable& set_v20(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v20_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v20(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v20_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(20));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v20() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v20_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v21(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v21_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(21));
    return *this;
  }
  SixtyFourOrdinalTable& set_v21(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v21_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v21(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v21_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(21));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v21() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v21_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v22(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v22_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(22));
    return *this;
  }
  SixtyFourOrdinalTable& set_v22(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v22_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v22(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v22_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(22));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v22() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v22_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v23(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v23_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(23));
    return *this;
  }
  SixtyFourOrdinalTable& set_v23(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v23_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v23(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v23_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(23));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v23() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v23_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v24(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v24_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(24));
    return *this;
  }
  SixtyFourOrdinalTable& set_v24(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v24_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v24(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v24_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(24));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v24() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v24_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v25(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v25_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(25));
    return *this;
  }
  SixtyFourOrdinalTable& set_v25(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v25_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v25(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v25_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(25));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v25() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v25_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v26(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v26_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(26));
    return *this;
  }
  SixtyFourOrdinalTable& set_v26(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v26_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v26(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v26_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(26));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v26() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v26_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v27(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v27_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(27));
    return *this;
  }
  SixtyFourOrdinalTable& set_v27(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v27_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v27(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v27_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(27));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v27() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v27_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v28(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v28_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(28));
    return *this;
  }
  SixtyFourOrdinalTable& set_v28(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v28_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v28(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v28_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(28));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v28() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v28_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v29(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v29_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(29));
    return *this;
  }
  SixtyFourOrdinalTable& set_v29(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v29_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v29(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v29_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(29));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v29() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v29_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v30(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v30_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(30));
    return *this;
  }
  SixtyFourOrdinalTable& set_v30(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v30_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v30(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v30_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(30));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v30() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v30_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v31(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v31_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(31));
    return *this;
  }
  SixtyFourOrdinalTable& set_v31(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v31_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v31(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v31_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(31));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v31() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v31_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v32(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v32_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(32));
    return *this;
  }
  SixtyFourOrdinalTable& set_v32(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v32_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v32(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v32_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(32));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v32() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v32_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v33(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v33_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(33));
    return *this;
  }
  SixtyFourOrdinalTable& set_v33(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v33_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v33(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v33_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(33));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v33() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v33_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v34(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v34_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(34));
    return *this;
  }
  SixtyFourOrdinalTable& set_v34(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v34_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v34(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v34_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(34));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v34() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v34_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v35(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v35_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(35));
    return *this;
  }
  SixtyFourOrdinalTable& set_v35(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v35_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v35(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v35_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(35));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v35() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v35_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v36(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v36_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(36));
    return *this;
  }
  SixtyFourOrdinalTable& set_v36(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v36_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v36(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v36_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(36));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v36() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v36_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v37(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v37_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(37));
    return *this;
  }
  SixtyFourOrdinalTable& set_v37(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v37_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v37(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v37_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(37));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v37() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v37_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v38(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v38_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(38));
    return *this;
  }
  SixtyFourOrdinalTable& set_v38(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v38_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v38(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v38_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(38));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v38() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v38_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v39(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v39_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(39));
    return *this;
  }
  SixtyFourOrdinalTable& set_v39(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v39_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v39(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v39_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(39));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v39() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v39_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v40(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v40_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(40));
    return *this;
  }
  SixtyFourOrdinalTable& set_v40(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v40_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v40(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v40_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(40));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v40() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v40_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v41(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v41_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(41));
    return *this;
  }
  SixtyFourOrdinalTable& set_v41(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v41_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v41(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v41_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(41));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v41() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v41_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v42(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v42_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(42));
    return *this;
  }
  SixtyFourOrdinalTable& set_v42(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v42_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v42(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v42_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(42));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v42() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v42_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v43(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v43_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(43));
    return *this;
  }
  SixtyFourOrdinalTable& set_v43(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v43_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v43(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v43_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(43));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v43() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v43_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v44(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v44_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(44));
    return *this;
  }
  SixtyFourOrdinalTable& set_v44(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v44_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v44(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v44_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(44));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v44() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v44_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v45(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v45_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(45));
    return *this;
  }
  SixtyFourOrdinalTable& set_v45(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v45_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v45(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v45_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(45));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v45() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v45_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v46(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v46_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(46));
    return *this;
  }
  SixtyFourOrdinalTable& set_v46(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v46_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v46(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v46_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(46));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v46() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v46_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v47(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v47_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(47));
    return *this;
  }
  SixtyFourOrdinalTable& set_v47(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v47_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v47(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v47_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(47));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v47() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v47_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v48(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v48_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(48));
    return *this;
  }
  SixtyFourOrdinalTable& set_v48(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v48_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v48(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v48_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(48));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v48() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v48_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v49(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v49_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(49));
    return *this;
  }
  SixtyFourOrdinalTable& set_v49(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v49_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v49(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v49_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(49));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v49() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v49_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v50(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v50_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(50));
    return *this;
  }
  SixtyFourOrdinalTable& set_v50(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v50_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v50(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v50_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(50));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v50() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v50_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v51(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v51_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(51));
    return *this;
  }
  SixtyFourOrdinalTable& set_v51(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v51_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v51(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v51_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(51));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v51() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v51_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v52(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v52_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(52));
    return *this;
  }
  SixtyFourOrdinalTable& set_v52(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v52_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v52(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v52_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(52));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v52() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v52_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v53(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v53_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(53));
    return *this;
  }
  SixtyFourOrdinalTable& set_v53(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v53_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v53(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v53_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(53));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v53() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v53_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v54(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v54_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(54));
    return *this;
  }
  SixtyFourOrdinalTable& set_v54(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v54_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v54(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v54_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(54));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v54() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v54_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v55(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v55_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(55));
    return *this;
  }
  SixtyFourOrdinalTable& set_v55(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v55_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v55(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v55_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(55));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v55() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v55_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v56(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v56_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(56));
    return *this;
  }
  SixtyFourOrdinalTable& set_v56(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v56_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v56(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v56_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(56));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v56() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v56_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v57(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v57_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(57));
    return *this;
  }
  SixtyFourOrdinalTable& set_v57(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v57_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v57(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v57_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(57));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v57() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v57_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v58(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v58_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(58));
    return *this;
  }
  SixtyFourOrdinalTable& set_v58(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v58_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v58(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v58_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(58));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v58() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v58_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v59(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v59_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(59));
    return *this;
  }
  SixtyFourOrdinalTable& set_v59(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v59_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v59(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v59_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(59));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v59() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v59_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v60(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v60_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(60));
    return *this;
  }
  SixtyFourOrdinalTable& set_v60(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v60_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v60(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v60_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(60));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v60() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v60_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v61(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v61_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(61));
    return *this;
  }
  SixtyFourOrdinalTable& set_v61(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v61_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v61(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v61_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(61));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v61() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v61_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v62(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v62_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(62));
    return *this;
  }
  SixtyFourOrdinalTable& set_v62(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v62_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v62(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v62_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(62));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v62() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v62_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v63(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v63_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(63));
    return *this;
  }
  SixtyFourOrdinalTable& set_v63(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v63_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v63(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v63_.set_data(
        ::fidl::ObjectView<int64_t>(allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(63));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v63() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v63_.clear_data();
    return *this;
  }
  SixtyFourOrdinalTable& set_v64(
      ::fidl::ObjectView<::test_table::wire::ExtensionTable> elem) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v64_.set_data(elem);
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(64));
    return *this;
  }
  SixtyFourOrdinalTable& set_v64(std::nullptr_t) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v64_.set_data(nullptr);
    return *this;
  }
  template <typename... Args>
  SixtyFourOrdinalTable& set_v64(::fidl::AnyArena& allocator, Args&&... args) {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v64_.set_data(
        ::fidl::ObjectView<::test_table::wire::ExtensionTable>(
            allocator, std::forward<Args>(args)...));
    max_ordinal_ = std::max(max_ordinal_, static_cast<uint64_t>(64));
    return *this;
  }

  SixtyFourOrdinalTable& clear_v64() {
    ZX_DEBUG_ASSERT(frame_ptr_ != nullptr);
    frame_ptr_->v64_.clear_data();
    return *this;
  }

  explicit SixtyFourOrdinalTable(::fidl::AnyArena& allocator)
      : frame_ptr_(::fidl::ObjectView<::fidl::WireTableFrame<
                       ::test_table::wire::SixtyFourOrdinalTable>>(allocator)) {
  }
  // This constructor allows a user controlled allocation (not using a Arena).
  // It should only be used when performance is key.
  // As soon as the frame is given to the table, it must not be used directly or
  // for another table.
  explicit SixtyFourOrdinalTable(
      ::fidl::ObjectView<
          ::fidl::WireTableFrame<::test_table::wire::SixtyFourOrdinalTable>>&&
          frame)
      : frame_ptr_(std::move(frame)) {}

  void Allocate(::fidl::AnyArena& allocator) {
    max_ordinal_ = 0;
    frame_ptr_ = ::fidl::ObjectView<
        ::fidl::WireTableFrame<::test_table::wire::SixtyFourOrdinalTable>>(
        allocator);
  }
  void Init(::fidl::ObjectView<::fidl::WireTableFrame<
                ::test_table::wire::SixtyFourOrdinalTable>>&& frame_ptr) {
    max_ordinal_ = 0;
    frame_ptr_ = std::move(frame_ptr);
  }

 private:
  friend ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::SixtyFourOrdinalTable,
      ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>>;
  friend ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::SixtyFourOrdinalTable,
      ::fidl::WireTableExternalBuilder<
          ::test_table::wire::SixtyFourOrdinalTable>>;

  uint64_t max_ordinal_ = 0;
  ::fidl::ObjectView<
      ::fidl::WireTableFrame<::test_table::wire::SixtyFourOrdinalTable>>
      frame_ptr_;
};
}  // namespace wire
}  // namespace test_table
template <typename BuilderImpl>
class ::fidl::internal::WireTableBaseBuilder<
    ::test_table::wire::SixtyFourOrdinalTable, BuilderImpl> {
 public:
  // Build and return the table. The builder should not be used after this.
  ::test_table::wire::SixtyFourOrdinalTable Build() {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    ::test_table::wire::SixtyFourOrdinalTable t = std::move(table_);
    // Poison this builder to prevent accidental reuse.
    table_.frame_ptr_ = nullptr;
    return t;
  }

  BuilderImpl& v1(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v1_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(1));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v2(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v2_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(2));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v3(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v3_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(3));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v4(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v4_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(4));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v5(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v5_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(5));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v6(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v6_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(6));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v7(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v7_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(7));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v8(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v8_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(8));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v9(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v9_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(9));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v10(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v10_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(10));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v11(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v11_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(11));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v12(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v12_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(12));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v13(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v13_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(13));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v14(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v14_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(14));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v15(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v15_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(15));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v16(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v16_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(16));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v17(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v17_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(17));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v18(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v18_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(18));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v19(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v19_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(19));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v20(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v20_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(20));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v21(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v21_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(21));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v22(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v22_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(22));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v23(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v23_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(23));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v24(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v24_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(24));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v25(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v25_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(25));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v26(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v26_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(26));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v27(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v27_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(27));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v28(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v28_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(28));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v29(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v29_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(29));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v30(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v30_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(30));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v31(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v31_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(31));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v32(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v32_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(32));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v33(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v33_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(33));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v34(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v34_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(34));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v35(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v35_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(35));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v36(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v36_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(36));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v37(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v37_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(37));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v38(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v38_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(38));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v39(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v39_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(39));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v40(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v40_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(40));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v41(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v41_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(41));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v42(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v42_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(42));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v43(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v43_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(43));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v44(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v44_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(44));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v45(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v45_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(45));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v46(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v46_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(46));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v47(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v47_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(47));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v48(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v48_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(48));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v49(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v49_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(49));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v50(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v50_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(50));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v51(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v51_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(51));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v52(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v52_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(52));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v53(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v53_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(53));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v54(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v54_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(54));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v55(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v55_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(55));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v56(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v56_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(56));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v57(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v57_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(57));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v58(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v58_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(58));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v59(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v59_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(59));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v60(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v60_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(60));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v61(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v61_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(61));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v62(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v62_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(62));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v63(::fidl::ObjectView<int64_t> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v63_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(63));
    return *static_cast<BuilderImpl*>(this);
  }

  BuilderImpl& v64(
      ::fidl::ObjectView<::test_table::wire::ExtensionTable> elem) {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    table_.frame_ptr_->v64_.set_data(elem);
    table_.max_ordinal_ =
        std::max(table_.max_ordinal_, static_cast<uint64_t>(64));
    return *static_cast<BuilderImpl*>(this);
  }

 protected:
  WireTableBaseBuilder(::fidl::ObjectView<::fidl::WireTableFrame<
                           ::test_table::wire::SixtyFourOrdinalTable>>&& frame)
      : table_(std::move(frame)) {}

 private:
  ::test_table::wire::SixtyFourOrdinalTable table_;
};

template <>
class ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable> final
    : public ::fidl::internal::WireTableBaseBuilder<
          ::test_table::wire::SixtyFourOrdinalTable,
          ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>> {
  using Base = ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::SixtyFourOrdinalTable,
      ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>>;

 public:
  using Base::v1;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v1(
      Args&&... args_) {
    v1(::fidl::ObjectView<int64_t>(arena_.get(), std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v2;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v2(
      Args&&... args_) {
    v2(::fidl::ObjectView<int64_t>(arena_.get(), std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v3;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v3(
      Args&&... args_) {
    v3(::fidl::ObjectView<int64_t>(arena_.get(), std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v4;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v4(
      Args&&... args_) {
    v4(::fidl::ObjectView<int64_t>(arena_.get(), std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v5;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v5(
      Args&&... args_) {
    v5(::fidl::ObjectView<int64_t>(arena_.get(), std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v6;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v6(
      Args&&... args_) {
    v6(::fidl::ObjectView<int64_t>(arena_.get(), std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v7;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v7(
      Args&&... args_) {
    v7(::fidl::ObjectView<int64_t>(arena_.get(), std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v8;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v8(
      Args&&... args_) {
    v8(::fidl::ObjectView<int64_t>(arena_.get(), std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v9;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v9(
      Args&&... args_) {
    v9(::fidl::ObjectView<int64_t>(arena_.get(), std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v10;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v10(
      Args&&... args_) {
    v10(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v11;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v11(
      Args&&... args_) {
    v11(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v12;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v12(
      Args&&... args_) {
    v12(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v13;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v13(
      Args&&... args_) {
    v13(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v14;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v14(
      Args&&... args_) {
    v14(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v15;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v15(
      Args&&... args_) {
    v15(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v16;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v16(
      Args&&... args_) {
    v16(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v17;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v17(
      Args&&... args_) {
    v17(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v18;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v18(
      Args&&... args_) {
    v18(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v19;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v19(
      Args&&... args_) {
    v19(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v20;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v20(
      Args&&... args_) {
    v20(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v21;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v21(
      Args&&... args_) {
    v21(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v22;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v22(
      Args&&... args_) {
    v22(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v23;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v23(
      Args&&... args_) {
    v23(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v24;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v24(
      Args&&... args_) {
    v24(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v25;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v25(
      Args&&... args_) {
    v25(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v26;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v26(
      Args&&... args_) {
    v26(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v27;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v27(
      Args&&... args_) {
    v27(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v28;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v28(
      Args&&... args_) {
    v28(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v29;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v29(
      Args&&... args_) {
    v29(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v30;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v30(
      Args&&... args_) {
    v30(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v31;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v31(
      Args&&... args_) {
    v31(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v32;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v32(
      Args&&... args_) {
    v32(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v33;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v33(
      Args&&... args_) {
    v33(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v34;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v34(
      Args&&... args_) {
    v34(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v35;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v35(
      Args&&... args_) {
    v35(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v36;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v36(
      Args&&... args_) {
    v36(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v37;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v37(
      Args&&... args_) {
    v37(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v38;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v38(
      Args&&... args_) {
    v38(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v39;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v39(
      Args&&... args_) {
    v39(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v40;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v40(
      Args&&... args_) {
    v40(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v41;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v41(
      Args&&... args_) {
    v41(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v42;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v42(
      Args&&... args_) {
    v42(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v43;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v43(
      Args&&... args_) {
    v43(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v44;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v44(
      Args&&... args_) {
    v44(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v45;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v45(
      Args&&... args_) {
    v45(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v46;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v46(
      Args&&... args_) {
    v46(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v47;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v47(
      Args&&... args_) {
    v47(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v48;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v48(
      Args&&... args_) {
    v48(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v49;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v49(
      Args&&... args_) {
    v49(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v50;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v50(
      Args&&... args_) {
    v50(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v51;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v51(
      Args&&... args_) {
    v51(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v52;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v52(
      Args&&... args_) {
    v52(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v53;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v53(
      Args&&... args_) {
    v53(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v54;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v54(
      Args&&... args_) {
    v54(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v55;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v55(
      Args&&... args_) {
    v55(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v56;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v56(
      Args&&... args_) {
    v56(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v57;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v57(
      Args&&... args_) {
    v57(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v58;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v58(
      Args&&... args_) {
    v58(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v59;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v59(
      Args&&... args_) {
    v59(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v60;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v60(
      Args&&... args_) {
    v60(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v61;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v61(
      Args&&... args_) {
    v61(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v62;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v62(
      Args&&... args_) {
    v62(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v63;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v63(
      Args&&... args_) {
    v63(::fidl::ObjectView<int64_t>(arena_.get(),
                                    std::forward<Args>(args_)...));
    return *this;
  }
  using Base::v64;

  template <typename... Args>
  ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>& v64(
      Args&&... args_) {
    v64(::fidl::ObjectView<::test_table::wire::ExtensionTable>(
        arena_.get(), std::forward<Args>(args_)...));
    return *this;
  }

 private:
  friend class ::test_table::wire::SixtyFourOrdinalTable;
  WireTableBuilder(::fidl::AnyArena& arena)
      : Base(::fidl::ObjectView<
             ::fidl::WireTableFrame<::test_table::wire::SixtyFourOrdinalTable>>(
            arena)),
        arena_(arena) {}

  [[maybe_unused]] std::reference_wrapper<::fidl::AnyArena> arena_;
};

template <>
class ::fidl::WireTableExternalBuilder<
    ::test_table::wire::SixtyFourOrdinalTable>
    final : public ::fidl::internal::WireTableBaseBuilder<
                ::test_table::wire::SixtyFourOrdinalTable,
                ::fidl::WireTableExternalBuilder<
                    ::test_table::wire::SixtyFourOrdinalTable>> {
  using Base = ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::SixtyFourOrdinalTable,
      ::fidl::WireTableExternalBuilder<
          ::test_table::wire::SixtyFourOrdinalTable>>;

 private:
  friend class ::test_table::wire::SixtyFourOrdinalTable;
  using Base::Base;
  WireTableExternalBuilder(
      ::fidl::WireTableFrame<::test_table::wire::SixtyFourOrdinalTable>* frame)
      : Base(::fidl::ObjectView<::fidl::WireTableFrame<
                 ::test_table::wire::SixtyFourOrdinalTable>>::
                 FromExternal(frame)) {}
};
namespace test_table {
namespace wire {
inline ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>
SixtyFourOrdinalTable::Builder(::fidl::AnyArena& arena) {
  return ::fidl::WireTableBuilder<::test_table::wire::SixtyFourOrdinalTable>(
      arena);
}
inline ::fidl::WireTableExternalBuilder<
    ::test_table::wire::SixtyFourOrdinalTable>
SixtyFourOrdinalTable::ExternalBuilder(
    ::fidl::ObjectView<
        ::fidl::WireTableFrame<::test_table::wire::SixtyFourOrdinalTable>>
        frame) {
  return ::fidl::WireTableExternalBuilder<
      ::test_table::wire::SixtyFourOrdinalTable>(std::move(frame));
}

}  // namespace wire
}  // namespace test_table
template <>
class ::fidl::WireTableBuilder<::test_table::wire::EmptyTable>;
template <>
class ::fidl::WireTableExternalBuilder<::test_table::wire::EmptyTable>;

template <>
struct ::fidl::WireTableFrame<::test_table::wire::EmptyTable> final {
 public:
  WireTableFrame() = default;
  // In its intended usage, WireTableFrame will be referenced by an ObjectView.
  // If the ObjectView is assigned before a move or copy, then it will reference
  // the old invalid object. Because this is unsafe, copies are disallowed and
  // moves are only allowed by friend classes that operate safely.
  WireTableFrame(const WireTableFrame&) = delete;
  WireTableFrame& operator=(const WireTableFrame&) = delete;

 private:
  WireTableFrame(WireTableFrame&&) noexcept = default;
  WireTableFrame& operator=(WireTableFrame&&) noexcept = default;

  bool HasUnknownData() const;

  friend class ::test_table::wire::EmptyTable;
  friend ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::EmptyTable,
      ::fidl::WireTableBuilder<::test_table::wire::EmptyTable>>;
  friend ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::EmptyTable,
      ::fidl::WireTableExternalBuilder<::test_table::wire::EmptyTable>>;
};

namespace test_table {
namespace wire {
extern "C" const fidl_type_t test_table_EmptyTableTable;

class EmptyTable {
 public:
  EmptyTable() = default;
  EmptyTable(const EmptyTable& other) noexcept = default;
  EmptyTable& operator=(const EmptyTable& other) noexcept = default;
  EmptyTable(EmptyTable&& other) noexcept = default;
  EmptyTable& operator=(EmptyTable&& other) noexcept = default;

  ~EmptyTable() = default;

  // Returns whether no field is set.
  bool IsEmpty() const { return max_ordinal_ == 0; }

  // Returns whether the table references unknown fields.
  bool HasUnknownData() const;

  // Return a builder that by defaults allocates of an arena.
  static ::fidl::WireTableBuilder<::test_table::wire::EmptyTable> Builder(
      ::fidl::AnyArena& arena);

  // Return a builder that relies on explicitly allocating |fidl::ObjectView|s.
  static ::fidl::WireTableExternalBuilder<::test_table::wire::EmptyTable>
  ExternalBuilder(
      ::fidl::ObjectView<::fidl::WireTableFrame<::test_table::wire::EmptyTable>>
          frame);
#if defined(FIDL_WIRE_ALLOW_DEPRECATED_MUTABLE_TABLES) || false
 public:
#else   // !defined(FIDL_WIRE_ALLOW_DEPRECATED_MUTABLE_TABLES)
 private:
#endif  // FIDL_WIRE_ALLOW_DEPRECATED_MUTABLE_TABLES

  explicit EmptyTable(::fidl::AnyArena& allocator)
      : frame_ptr_(::fidl::ObjectView<
                   ::fidl::WireTableFrame<::test_table::wire::EmptyTable>>(
            allocator)) {}
  // This constructor allows a user controlled allocation (not using a Arena).
  // It should only be used when performance is key.
  // As soon as the frame is given to the table, it must not be used directly or
  // for another table.
  explicit EmptyTable(
      ::fidl::ObjectView<
          ::fidl::WireTableFrame<::test_table::wire::EmptyTable>>&& frame)
      : frame_ptr_(std::move(frame)) {}

  void Allocate(::fidl::AnyArena& allocator) {
    max_ordinal_ = 0;
    frame_ptr_ = ::fidl::ObjectView<
        ::fidl::WireTableFrame<::test_table::wire::EmptyTable>>(allocator);
  }
  void Init(
      ::fidl::ObjectView<
          ::fidl::WireTableFrame<::test_table::wire::EmptyTable>>&& frame_ptr) {
    max_ordinal_ = 0;
    frame_ptr_ = std::move(frame_ptr);
  }

 private:
  friend ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::EmptyTable,
      ::fidl::WireTableBuilder<::test_table::wire::EmptyTable>>;
  friend ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::EmptyTable,
      ::fidl::WireTableExternalBuilder<::test_table::wire::EmptyTable>>;

  uint64_t max_ordinal_ = 0;
  ::fidl::ObjectView<::fidl::WireTableFrame<::test_table::wire::EmptyTable>>
      frame_ptr_;
};
}  // namespace wire
}  // namespace test_table
template <typename BuilderImpl>
class ::fidl::internal::WireTableBaseBuilder<::test_table::wire::EmptyTable,
                                             BuilderImpl> {
 public:
  // Build and return the table. The builder should not be used after this.
  ::test_table::wire::EmptyTable Build() {
    ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr);
    ::test_table::wire::EmptyTable t = std::move(table_);
    // Poison this builder to prevent accidental reuse.
    table_.frame_ptr_ = nullptr;
    return t;
  }

 protected:
  WireTableBaseBuilder(
      ::fidl::ObjectView<
          ::fidl::WireTableFrame<::test_table::wire::EmptyTable>>&& frame)
      : table_(std::move(frame)) {}

 private:
  ::test_table::wire::EmptyTable table_;
};

template <>
class ::fidl::WireTableBuilder<::test_table::wire::EmptyTable> final
    : public ::fidl::internal::WireTableBaseBuilder<
          ::test_table::wire::EmptyTable,
          ::fidl::WireTableBuilder<::test_table::wire::EmptyTable>> {
  using Base = ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::EmptyTable,
      ::fidl::WireTableBuilder<::test_table::wire::EmptyTable>>;

 public:
 private:
  friend class ::test_table::wire::EmptyTable;
  WireTableBuilder(::fidl::AnyArena& arena)
      : Base(::fidl::ObjectView<
             ::fidl::WireTableFrame<::test_table::wire::EmptyTable>>(arena)),
        arena_(arena) {}

  [[maybe_unused]] std::reference_wrapper<::fidl::AnyArena> arena_;
};

template <>
class ::fidl::WireTableExternalBuilder<::test_table::wire::EmptyTable> final
    : public ::fidl::internal::WireTableBaseBuilder<
          ::test_table::wire::EmptyTable,
          ::fidl::WireTableExternalBuilder<::test_table::wire::EmptyTable>> {
  using Base = ::fidl::internal::WireTableBaseBuilder<
      ::test_table::wire::EmptyTable,
      ::fidl::WireTableExternalBuilder<::test_table::wire::EmptyTable>>;

 private:
  friend class ::test_table::wire::EmptyTable;
  using Base::Base;
  WireTableExternalBuilder(
      ::fidl::WireTableFrame<::test_table::wire::EmptyTable>* frame)
      : Base(::fidl::ObjectView<::fidl::WireTableFrame<
                 ::test_table::wire::EmptyTable>>::FromExternal(frame)) {}
};
namespace test_table {
namespace wire {
inline ::fidl::WireTableBuilder<::test_table::wire::EmptyTable>
EmptyTable::Builder(::fidl::AnyArena& arena) {
  return ::fidl::WireTableBuilder<::test_table::wire::EmptyTable>(arena);
}
inline ::fidl::WireTableExternalBuilder<::test_table::wire::EmptyTable>
EmptyTable::ExternalBuilder(
    ::fidl::ObjectView<::fidl::WireTableFrame<::test_table::wire::EmptyTable>>
        frame) {
  return ::fidl::WireTableExternalBuilder<::test_table::wire::EmptyTable>(
      std::move(frame));
}

}  // namespace wire
}  // namespace test_table
namespace fidl {

template <>
struct TypeTraits<::test_table::wire::TableWithAttributes> {
  static constexpr const fidl_type_t* kType =
      &::test_table::wire::test_table_TableWithAttributesTable;
  static constexpr uint32_t kMaxNumHandles = 0;
  static constexpr uint32_t kPrimarySize = 16;
  static constexpr uint32_t kPrimarySizeV1 = 16;
  [[maybe_unused]] static constexpr uint32_t kMaxOutOfLine = 16;
  static constexpr uint32_t kMaxOutOfLineV1 = 24;
  static constexpr bool kHasPointer = true;
};

template <>
struct IsFidlType<::test_table::wire::TableWithAttributes>
    : public std::true_type {};
template <>
struct IsTable<::test_table::wire::TableWithAttributes>
    : public std::true_type {};
static_assert(
    std::is_standard_layout_v<::test_table::wire::TableWithAttributes>);

template <>
struct TypeTraits<::test_table::wire::SimpleTable> {
  static constexpr const fidl_type_t* kType =
      &::test_table::wire::test_table_SimpleTableTable;
  static constexpr uint32_t kMaxNumHandles = 0;
  static constexpr uint32_t kPrimarySize = 16;
  static constexpr uint32_t kPrimarySizeV1 = 16;
  [[maybe_unused]] static constexpr uint32_t kMaxOutOfLine = 56;
  static constexpr uint32_t kMaxOutOfLineV1 = 96;
  static constexpr bool kHasPointer = true;
};

template <>
struct IsFidlType<::test_table::wire::SimpleTable> : public std::true_type {};
template <>
struct IsTable<::test_table::wire::SimpleTable> : public std::true_type {};
static_assert(std::is_standard_layout_v<::test_table::wire::SimpleTable>);

template <>
struct TypeTraits<::test_table::wire::ReverseOrdinalTable> {
  static constexpr const fidl_type_t* kType =
      &::test_table::wire::test_table_ReverseOrdinalTableTable;
  static constexpr uint32_t kMaxNumHandles = 0;
  static constexpr uint32_t kPrimarySize = 16;
  static constexpr uint32_t kPrimarySizeV1 = 16;
  [[maybe_unused]] static constexpr uint32_t kMaxOutOfLine = 48;
  static constexpr uint32_t kMaxOutOfLineV1 = 72;
  static constexpr bool kHasPointer = true;
};

template <>
struct IsFidlType<::test_table::wire::ReverseOrdinalTable>
    : public std::true_type {};
template <>
struct IsTable<::test_table::wire::ReverseOrdinalTable>
    : public std::true_type {};
static_assert(
    std::is_standard_layout_v<::test_table::wire::ReverseOrdinalTable>);

template <>
struct TypeTraits<::test_table::wire::OlderSimpleTable> {
  static constexpr const fidl_type_t* kType =
      &::test_table::wire::test_table_OlderSimpleTableTable;
  static constexpr uint32_t kMaxNumHandles = 0;
  static constexpr uint32_t kPrimarySize = 16;
  static constexpr uint32_t kPrimarySizeV1 = 16;
  [[maybe_unused]] static constexpr uint32_t kMaxOutOfLine = 16;
  static constexpr uint32_t kMaxOutOfLineV1 = 24;
  static constexpr bool kHasPointer = true;
};

template <>
struct IsFidlType<::test_table::wire::OlderSimpleTable>
    : public std::true_type {};
template <>
struct IsTable<::test_table::wire::OlderSimpleTable> : public std::true_type {};
static_assert(std::is_standard_layout_v<::test_table::wire::OlderSimpleTable>);

template <>
struct TypeTraits<::test_table::wire::NewerSimpleTable> {
  static constexpr const fidl_type_t* kType =
      &::test_table::wire::test_table_NewerSimpleTableTable;
  static constexpr uint32_t kMaxNumHandles = 0;
  static constexpr uint32_t kPrimarySize = 16;
  static constexpr uint32_t kPrimarySizeV1 = 16;
  [[maybe_unused]] static constexpr uint32_t kMaxOutOfLine = 72;
  static constexpr uint32_t kMaxOutOfLineV1 = 120;
  static constexpr bool kHasPointer = true;
};

template <>
struct IsFidlType<::test_table::wire::NewerSimpleTable>
    : public std::true_type {};
template <>
struct IsTable<::test_table::wire::NewerSimpleTable> : public std::true_type {};
static_assert(std::is_standard_layout_v<::test_table::wire::NewerSimpleTable>);

template <>
struct TypeTraits<::test_table::wire::ExtensionTable> {
  static constexpr const fidl_type_t* kType =
      &::test_table::wire::test_table_ExtensionTableTable;
  static constexpr uint32_t kMaxNumHandles = 0;
  static constexpr uint32_t kPrimarySize = 16;
  static constexpr uint32_t kPrimarySizeV1 = 16;
  [[maybe_unused]] static constexpr uint32_t kMaxOutOfLine = 0;
  static constexpr uint32_t kMaxOutOfLineV1 = 0;
  static constexpr bool kHasPointer = true;
};

template <>
struct IsFidlType<::test_table::wire::ExtensionTable> : public std::true_type {
};
template <>
struct IsTable<::test_table::wire::ExtensionTable> : public std::true_type {};
static_assert(std::is_standard_layout_v<::test_table::wire::ExtensionTable>);

template <>
struct TypeTraits<::test_table::wire::SixtyFourOrdinalTable> {
  static constexpr const fidl_type_t* kType =
      &::test_table::wire::test_table_SixtyFourOrdinalTableTable;
  static constexpr uint32_t kMaxNumHandles = 0;
  static constexpr uint32_t kPrimarySize = 16;
  static constexpr uint32_t kPrimarySizeV1 = 16;
  [[maybe_unused]] static constexpr uint32_t kMaxOutOfLine = 1032;
  static constexpr uint32_t kMaxOutOfLineV1 = 1544;
  static constexpr bool kHasPointer = true;
};

template <>
struct IsFidlType<::test_table::wire::SixtyFourOrdinalTable>
    : public std::true_type {};
template <>
struct IsTable<::test_table::wire::SixtyFourOrdinalTable>
    : public std::true_type {};
static_assert(
    std::is_standard_layout_v<::test_table::wire::SixtyFourOrdinalTable>);

template <>
struct TypeTraits<::test_table::wire::EmptyTable> {
  static constexpr const fidl_type_t* kType =
      &::test_table::wire::test_table_EmptyTableTable;
  static constexpr uint32_t kMaxNumHandles = 0;
  static constexpr uint32_t kPrimarySize = 16;
  static constexpr uint32_t kPrimarySizeV1 = 16;
  [[maybe_unused]] static constexpr uint32_t kMaxOutOfLine = 0;
  static constexpr uint32_t kMaxOutOfLineV1 = 0;
  static constexpr bool kHasPointer = true;
};

template <>
struct IsFidlType<::test_table::wire::EmptyTable> : public std::true_type {};
template <>
struct IsTable<::test_table::wire::EmptyTable> : public std::true_type {};
static_assert(std::is_standard_layout_v<::test_table::wire::EmptyTable>);

}  // namespace fidl