/src/mruby/genfiles/ruby.pb.cc

Source (jump to first uncovered line)
// Generated by the protocol buffer compiler.  DO NOT EDIT!
// NO CHECKED-IN PROTOBUF GENCODE
// source: ruby.proto
// Protobuf C++ Version: 5.29.3

#include "ruby.pb.h"

#include <algorithm>
#include <type_traits>
#include "google/protobuf/io/coded_stream.h"
#include "google/protobuf/generated_message_tctable_impl.h"
#include "google/protobuf/extension_set.h"
#include "google/protobuf/generated_message_util.h"
#include "google/protobuf/wire_format_lite.h"
#include "google/protobuf/descriptor.h"
#include "google/protobuf/generated_message_reflection.h"
#include "google/protobuf/reflection_ops.h"
#include "google/protobuf/wire_format.h"
// @@protoc_insertion_point(includes)

// Must be included last.
#include "google/protobuf/port_def.inc"
PROTOBUF_PRAGMA_INIT_SEG
namespace _pb = ::google::protobuf;
namespace _pbi = ::google::protobuf::internal;
namespace _fl = ::google::protobuf::internal::field_layout;
namespace ruby_fuzzer {

inline constexpr VarRef::Impl_::Impl_(
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        varnum_{0} {}

template <typename>
PROTOBUF_CONSTEXPR VarRef::VarRef(::_pbi::ConstantInitialized)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(_class_data_.base()),
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(),
#endif  // PROTOBUF_CUSTOM_VTABLE
      _impl_(::_pbi::ConstantInitialized()) {
}
struct VarRefDefaultTypeInternal {
  PROTOBUF_CONSTEXPR VarRefDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~VarRefDefaultTypeInternal() {}
  union {
    VarRef _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 VarRefDefaultTypeInternal _VarRef_default_instance_;

inline constexpr Time::Impl_::Impl_(
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        t_arg_{0u},
        t_func_{static_cast< ::ruby_fuzzer::Time_T_methods >(1)} {}

template <typename>
PROTOBUF_CONSTEXPR Time::Time(::_pbi::ConstantInitialized)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(_class_data_.base()),
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(),
#endif  // PROTOBUF_CUSTOM_VTABLE
      _impl_(::_pbi::ConstantInitialized()) {
}
struct TimeDefaultTypeInternal {
  PROTOBUF_CONSTEXPR TimeDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~TimeDefaultTypeInternal() {}
  union {
    Time _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TimeDefaultTypeInternal _Time_default_instance_;

inline constexpr StringExtNoArg::Impl_::Impl_(
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        str_arg_(
            &::google::protobuf::internal::fixed_address_empty_string,
            ::_pbi::ConstantInitialized()),
        str_op_{static_cast< ::ruby_fuzzer::StringExtNoArg_StrExtOp >(0)} {}

template <typename>
PROTOBUF_CONSTEXPR StringExtNoArg::StringExtNoArg(::_pbi::ConstantInitialized)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(_class_data_.base()),
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(),
#endif  // PROTOBUF_CUSTOM_VTABLE
      _impl_(::_pbi::ConstantInitialized()) {
}
struct StringExtNoArgDefaultTypeInternal {
  PROTOBUF_CONSTEXPR StringExtNoArgDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~StringExtNoArgDefaultTypeInternal() {}
  union {
    StringExtNoArg _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StringExtNoArgDefaultTypeInternal _StringExtNoArg_default_instance_;

inline constexpr MathConst::Impl_::Impl_(
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        math_const_{static_cast< ::ruby_fuzzer::MathConst_MathConstLit >(0)} {}

template <typename>
PROTOBUF_CONSTEXPR MathConst::MathConst(::_pbi::ConstantInitialized)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(_class_data_.base()),
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(),
#endif  // PROTOBUF_CUSTOM_VTABLE
      _impl_(::_pbi::ConstantInitialized()) {
}
struct MathConstDefaultTypeInternal {
  PROTOBUF_CONSTEXPR MathConstDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~MathConstDefaultTypeInternal() {}
  union {
    MathConst _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MathConstDefaultTypeInternal _MathConst_default_instance_;

inline constexpr KVPair::Impl_::Impl_(
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        key_(
            &::google::protobuf::internal::fixed_address_empty_string,
            ::_pbi::ConstantInitialized()),
        val_(
            &::google::protobuf::internal::fixed_address_empty_string,
            ::_pbi::ConstantInitialized()) {}

template <typename>
PROTOBUF_CONSTEXPR KVPair::KVPair(::_pbi::ConstantInitialized)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(_class_data_.base()),
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(),
#endif  // PROTOBUF_CUSTOM_VTABLE
      _impl_(::_pbi::ConstantInitialized()) {
}
struct KVPairDefaultTypeInternal {
  PROTOBUF_CONSTEXPR KVPairDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~KVPairDefaultTypeInternal() {}
  union {
    KVPair _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 KVPairDefaultTypeInternal _KVPair_default_instance_;

inline constexpr Const::Impl_::Impl_(
    ::_pbi::ConstantInitialized) noexcept
      : const_oneof_{},
        _cached_size_{0},
        _oneof_case_{} {}

template <typename>
PROTOBUF_CONSTEXPR Const::Const(::_pbi::ConstantInitialized)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(_class_data_.base()),
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(),
#endif  // PROTOBUF_CUSTOM_VTABLE
      _impl_(::_pbi::ConstantInitialized()) {
}
struct ConstDefaultTypeInternal {
  PROTOBUF_CONSTEXPR ConstDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~ConstDefaultTypeInternal() {}
  union {
    Const _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ConstDefaultTypeInternal _Const_default_instance_;

inline constexpr HashType::Impl_::Impl_(
    ::_pbi::ConstantInitialized) noexcept
      : keyval_{},
        _cached_size_{0} {}

template <typename>
PROTOBUF_CONSTEXPR HashType::HashType(::_pbi::ConstantInitialized)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(_class_data_.base()),
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(),
#endif  // PROTOBUF_CUSTOM_VTABLE
      _impl_(::_pbi::ConstantInitialized()) {
}
struct HashTypeDefaultTypeInternal {
  PROTOBUF_CONSTEXPR HashTypeDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~HashTypeDefaultTypeInternal() {}
  union {
    HashType _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 HashTypeDefaultTypeInternal _HashType_default_instance_;

inline constexpr BinaryOp::Impl_::Impl_(
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        left_{nullptr},
        right_{nullptr},
        op_{static_cast< ::ruby_fuzzer::BinaryOp_Op >(0)} {}

template <typename>
PROTOBUF_CONSTEXPR BinaryOp::BinaryOp(::_pbi::ConstantInitialized)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(_class_data_.base()),
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(),
#endif  // PROTOBUF_CUSTOM_VTABLE
      _impl_(::_pbi::ConstantInitialized()) {
}
struct BinaryOpDefaultTypeInternal {
  PROTOBUF_CONSTEXPR BinaryOpDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~BinaryOpDefaultTypeInternal() {}
  union {
    BinaryOp _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BinaryOpDefaultTypeInternal _BinaryOp_default_instance_;

inline constexpr Rvalue::Impl_::Impl_(
    ::_pbi::ConstantInitialized) noexcept
      : rvalue_oneof_{},
        _cached_size_{0},
        _oneof_case_{} {}

template <typename>
PROTOBUF_CONSTEXPR Rvalue::Rvalue(::_pbi::ConstantInitialized)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(_class_data_.base()),
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(),
#endif  // PROTOBUF_CUSTOM_VTABLE
      _impl_(::_pbi::ConstantInitialized()) {
}
struct RvalueDefaultTypeInternal {
  PROTOBUF_CONSTEXPR RvalueDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~RvalueDefaultTypeInternal() {}
  union {
    Rvalue _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RvalueDefaultTypeInternal _Rvalue_default_instance_;

inline constexpr ArrType::Impl_::Impl_(
    ::_pbi::ConstantInitialized) noexcept
      : elements_{},
        _cached_size_{0} {}

template <typename>
PROTOBUF_CONSTEXPR ArrType::ArrType(::_pbi::ConstantInitialized)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(_class_data_.base()),
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(),
#endif  // PROTOBUF_CUSTOM_VTABLE
      _impl_(::_pbi::ConstantInitialized()) {
}
struct ArrTypeDefaultTypeInternal {
  PROTOBUF_CONSTEXPR ArrTypeDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~ArrTypeDefaultTypeInternal() {}
  union {
    ArrType _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ArrTypeDefaultTypeInternal _ArrType_default_instance_;

inline constexpr Ternary::Impl_::Impl_(
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        tern_cond_{nullptr},
        t_branch_{nullptr},
        f_branch_{nullptr} {}

template <typename>
PROTOBUF_CONSTEXPR Ternary::Ternary(::_pbi::ConstantInitialized)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(_class_data_.base()),
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(),
#endif  // PROTOBUF_CUSTOM_VTABLE
      _impl_(::_pbi::ConstantInitialized()) {
}
struct TernaryDefaultTypeInternal {
  PROTOBUF_CONSTEXPR TernaryDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~TernaryDefaultTypeInternal() {}
  union {
    Ternary _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TernaryDefaultTypeInternal _Ternary_default_instance_;

inline constexpr ObjectSpace::Impl_::Impl_(
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        os_arg_{nullptr},
        os_func_{static_cast< ::ruby_fuzzer::ObjectSpace_OS_methods >(1)} {}

template <typename>
PROTOBUF_CONSTEXPR ObjectSpace::ObjectSpace(::_pbi::ConstantInitialized)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(_class_data_.base()),
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(),
#endif  // PROTOBUF_CUSTOM_VTABLE
      _impl_(::_pbi::ConstantInitialized()) {
}
struct ObjectSpaceDefaultTypeInternal {
  PROTOBUF_CONSTEXPR ObjectSpaceDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~ObjectSpaceDefaultTypeInternal() {}
  union {
    ObjectSpace _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ObjectSpaceDefaultTypeInternal _ObjectSpace_default_instance_;

inline constexpr MathType::Impl_::Impl_(
    ::_pbi::ConstantInitialized) noexcept
      : math_arg_oneof_{},
        _cached_size_{0},
        _oneof_case_{} {}

template <typename>
PROTOBUF_CONSTEXPR MathType::MathType(::_pbi::ConstantInitialized)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(_class_data_.base()),
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(),
#endif  // PROTOBUF_CUSTOM_VTABLE
      _impl_(::_pbi::ConstantInitialized()) {
}
struct MathTypeDefaultTypeInternal {
  PROTOBUF_CONSTEXPR MathTypeDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~MathTypeDefaultTypeInternal() {}
  union {
    MathType _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MathTypeDefaultTypeInternal _MathType_default_instance_;

inline constexpr AssignmentStatement::Impl_::Impl_(
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        rvalue_{nullptr} {}

template <typename>
PROTOBUF_CONSTEXPR AssignmentStatement::AssignmentStatement(::_pbi::ConstantInitialized)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(_class_data_.base()),
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(),
#endif  // PROTOBUF_CUSTOM_VTABLE
      _impl_(::_pbi::ConstantInitialized()) {
}
struct AssignmentStatementDefaultTypeInternal {
  PROTOBUF_CONSTEXPR AssignmentStatementDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~AssignmentStatementDefaultTypeInternal() {}
  union {
    AssignmentStatement _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AssignmentStatementDefaultTypeInternal _AssignmentStatement_default_instance_;

inline constexpr Array::Impl_::Impl_(
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        arr_arg_{nullptr},
        val_arg_{nullptr},
        arr_func_{static_cast< ::ruby_fuzzer::Array_Arr_methods >(1)} {}

template <typename>
PROTOBUF_CONSTEXPR Array::Array(::_pbi::ConstantInitialized)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(_class_data_.base()),
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(),
#endif  // PROTOBUF_CUSTOM_VTABLE
      _impl_(::_pbi::ConstantInitialized()) {
}
struct ArrayDefaultTypeInternal {
  PROTOBUF_CONSTEXPR ArrayDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~ArrayDefaultTypeInternal() {}
  union {
    Array _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ArrayDefaultTypeInternal _Array_default_instance_;

inline constexpr MathOps::Impl_::Impl_(
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        math_arg_{nullptr},
        math_op_{static_cast< ::ruby_fuzzer::MathOps_Mops >(1)} {}

template <typename>
PROTOBUF_CONSTEXPR MathOps::MathOps(::_pbi::ConstantInitialized)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(_class_data_.base()),
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(),
#endif  // PROTOBUF_CUSTOM_VTABLE
      _impl_(::_pbi::ConstantInitialized()) {
}
struct MathOpsDefaultTypeInternal {
  PROTOBUF_CONSTEXPR MathOpsDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~MathOpsDefaultTypeInternal() {}
  union {
    MathOps _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MathOpsDefaultTypeInternal _MathOps_default_instance_;

inline constexpr BuiltinFuncs::Impl_::Impl_(
    ::_pbi::ConstantInitialized) noexcept
      : bifunc_oneof_{},
        _cached_size_{0},
        _oneof_case_{} {}

template <typename>
PROTOBUF_CONSTEXPR BuiltinFuncs::BuiltinFuncs(::_pbi::ConstantInitialized)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(_class_data_.base()),
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(),
#endif  // PROTOBUF_CUSTOM_VTABLE
      _impl_(::_pbi::ConstantInitialized()) {
}
struct BuiltinFuncsDefaultTypeInternal {
  PROTOBUF_CONSTEXPR BuiltinFuncsDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~BuiltinFuncsDefaultTypeInternal() {}
  union {
    BuiltinFuncs _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BuiltinFuncsDefaultTypeInternal _BuiltinFuncs_default_instance_;

inline constexpr IfElse::Impl_::Impl_(
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        cond_{nullptr},
        if_body_{nullptr},
        else_body_{nullptr} {}

template <typename>
PROTOBUF_CONSTEXPR IfElse::IfElse(::_pbi::ConstantInitialized)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(_class_data_.base()),
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(),
#endif  // PROTOBUF_CUSTOM_VTABLE
      _impl_(::_pbi::ConstantInitialized()) {
}
struct IfElseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR IfElseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~IfElseDefaultTypeInternal() {}
  union {
    IfElse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 IfElseDefaultTypeInternal _IfElse_default_instance_;

inline constexpr Statement::Impl_::Impl_(
    ::_pbi::ConstantInitialized) noexcept
      : stmt_oneof_{},
        _cached_size_{0},
        _oneof_case_{} {}

template <typename>
PROTOBUF_CONSTEXPR Statement::Statement(::_pbi::ConstantInitialized)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(_class_data_.base()),
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(),
#endif  // PROTOBUF_CUSTOM_VTABLE
      _impl_(::_pbi::ConstantInitialized()) {
}
struct StatementDefaultTypeInternal {
  PROTOBUF_CONSTEXPR StatementDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~StatementDefaultTypeInternal() {}
  union {
    Statement _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StatementDefaultTypeInternal _Statement_default_instance_;

inline constexpr StatementSeq::Impl_::Impl_(
    ::_pbi::ConstantInitialized) noexcept
      : statements_{},
        _cached_size_{0} {}

template <typename>
PROTOBUF_CONSTEXPR StatementSeq::StatementSeq(::_pbi::ConstantInitialized)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(_class_data_.base()),
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(),
#endif  // PROTOBUF_CUSTOM_VTABLE
      _impl_(::_pbi::ConstantInitialized()) {
}
struct StatementSeqDefaultTypeInternal {
  PROTOBUF_CONSTEXPR StatementSeqDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~StatementSeqDefaultTypeInternal() {}
  union {
    StatementSeq _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StatementSeqDefaultTypeInternal _StatementSeq_default_instance_;

inline constexpr Function::Impl_::Impl_(
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        statements_{nullptr} {}

template <typename>
PROTOBUF_CONSTEXPR Function::Function(::_pbi::ConstantInitialized)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(_class_data_.base()),
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(),
#endif  // PROTOBUF_CUSTOM_VTABLE
      _impl_(::_pbi::ConstantInitialized()) {
}
struct FunctionDefaultTypeInternal {
  PROTOBUF_CONSTEXPR FunctionDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~FunctionDefaultTypeInternal() {}
  union {
    Function _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FunctionDefaultTypeInternal _Function_default_instance_;
}  // namespace ruby_fuzzer
static const ::_pb::EnumDescriptor* file_level_enum_descriptors_ruby_2eproto[7];
static constexpr const ::_pb::ServiceDescriptor**
    file_level_service_descriptors_ruby_2eproto = nullptr;
const ::uint32_t
    TableStruct_ruby_2eproto::offsets[] ABSL_ATTRIBUTE_SECTION_VARIABLE(
        protodesc_cold) = {
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::VarRef, _impl_._has_bits_),
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::VarRef, _internal_metadata_),
        ~0u,  // no _extensions_
        ~0u,  // no _oneof_case_
        ~0u,  // no _weak_field_map_
        ~0u,  // no _inlined_string_donated_
        ~0u,  // no _split_
        ~0u,  // no sizeof(Split)
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::VarRef, _impl_.varnum_),
        0,
        ~0u,  // no _has_bits_
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::ArrType, _internal_metadata_),
        ~0u,  // no _extensions_
        ~0u,  // no _oneof_case_
        ~0u,  // no _weak_field_map_
        ~0u,  // no _inlined_string_donated_
        ~0u,  // no _split_
        ~0u,  // no sizeof(Split)
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::ArrType, _impl_.elements_),
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::KVPair, _impl_._has_bits_),
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::KVPair, _internal_metadata_),
        ~0u,  // no _extensions_
        ~0u,  // no _oneof_case_
        ~0u,  // no _weak_field_map_
        ~0u,  // no _inlined_string_donated_
        ~0u,  // no _split_
        ~0u,  // no sizeof(Split)
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::KVPair, _impl_.key_),
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::KVPair, _impl_.val_),
        0,
        1,
        ~0u,  // no _has_bits_
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::HashType, _internal_metadata_),
        ~0u,  // no _extensions_
        ~0u,  // no _oneof_case_
        ~0u,  // no _weak_field_map_
        ~0u,  // no _inlined_string_donated_
        ~0u,  // no _split_
        ~0u,  // no sizeof(Split)
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::HashType, _impl_.keyval_),
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::StringExtNoArg, _impl_._has_bits_),
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::StringExtNoArg, _internal_metadata_),
        ~0u,  // no _extensions_
        ~0u,  // no _oneof_case_
        ~0u,  // no _weak_field_map_
        ~0u,  // no _inlined_string_donated_
        ~0u,  // no _split_
        ~0u,  // no sizeof(Split)
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::StringExtNoArg, _impl_.str_op_),
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::StringExtNoArg, _impl_.str_arg_),
        1,
        0,
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::MathConst, _impl_._has_bits_),
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::MathConst, _internal_metadata_),
        ~0u,  // no _extensions_
        ~0u,  // no _oneof_case_
        ~0u,  // no _weak_field_map_
        ~0u,  // no _inlined_string_donated_
        ~0u,  // no _split_
        ~0u,  // no sizeof(Split)
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::MathConst, _impl_.math_const_),
        0,
        ~0u,  // no _has_bits_
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::Const, _internal_metadata_),
        ~0u,  // no _extensions_
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::Const, _impl_._oneof_case_[0]),
        ~0u,  // no _weak_field_map_
        ~0u,  // no _inlined_string_donated_
        ~0u,  // no _split_
        ~0u,  // no sizeof(Split)
        ::_pbi::kInvalidFieldOffsetTag,
        ::_pbi::kInvalidFieldOffsetTag,
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::Const, _impl_.const_oneof_),
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::BinaryOp, _impl_._has_bits_),
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::BinaryOp, _internal_metadata_),
        ~0u,  // no _extensions_
        ~0u,  // no _oneof_case_
        ~0u,  // no _weak_field_map_
        ~0u,  // no _inlined_string_donated_
        ~0u,  // no _split_
        ~0u,  // no sizeof(Split)
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::BinaryOp, _impl_.op_),
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::BinaryOp, _impl_.left_),
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::BinaryOp, _impl_.right_),
        2,
        0,
        1,
        ~0u,  // no _has_bits_
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::Rvalue, _internal_metadata_),
        ~0u,  // no _extensions_
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::Rvalue, _impl_._oneof_case_[0]),
        ~0u,  // no _weak_field_map_
        ~0u,  // no _inlined_string_donated_
        ~0u,  // no _split_
        ~0u,  // no sizeof(Split)
        ::_pbi::kInvalidFieldOffsetTag,
        ::_pbi::kInvalidFieldOffsetTag,
        ::_pbi::kInvalidFieldOffsetTag,
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::Rvalue, _impl_.rvalue_oneof_),
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::AssignmentStatement, _impl_._has_bits_),
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::AssignmentStatement, _internal_metadata_),
        ~0u,  // no _extensions_
        ~0u,  // no _oneof_case_
        ~0u,  // no _weak_field_map_
        ~0u,  // no _inlined_string_donated_
        ~0u,  // no _split_
        ~0u,  // no sizeof(Split)
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::AssignmentStatement, _impl_.rvalue_),
        0,
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::IfElse, _impl_._has_bits_),
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::IfElse, _internal_metadata_),
        ~0u,  // no _extensions_
        ~0u,  // no _oneof_case_
        ~0u,  // no _weak_field_map_
        ~0u,  // no _inlined_string_donated_
        ~0u,  // no _split_
        ~0u,  // no sizeof(Split)
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::IfElse, _impl_.cond_),
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::IfElse, _impl_.if_body_),
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::IfElse, _impl_.else_body_),
        0,
        1,
        2,
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::Ternary, _impl_._has_bits_),
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::Ternary, _internal_metadata_),
        ~0u,  // no _extensions_
        ~0u,  // no _oneof_case_
        ~0u,  // no _weak_field_map_
        ~0u,  // no _inlined_string_donated_
        ~0u,  // no _split_
        ~0u,  // no sizeof(Split)
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::Ternary, _impl_.tern_cond_),
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::Ternary, _impl_.t_branch_),
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::Ternary, _impl_.f_branch_),
        0,
        1,
        2,
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::ObjectSpace, _impl_._has_bits_),
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::ObjectSpace, _internal_metadata_),
        ~0u,  // no _extensions_
        ~0u,  // no _oneof_case_
        ~0u,  // no _weak_field_map_
        ~0u,  // no _inlined_string_donated_
        ~0u,  // no _split_
        ~0u,  // no sizeof(Split)
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::ObjectSpace, _impl_.os_func_),
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::ObjectSpace, _impl_.os_arg_),
        1,
        0,
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::Time, _impl_._has_bits_),
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::Time, _internal_metadata_),
        ~0u,  // no _extensions_
        ~0u,  // no _oneof_case_
        ~0u,  // no _weak_field_map_
        ~0u,  // no _inlined_string_donated_
        ~0u,  // no _split_
        ~0u,  // no sizeof(Split)
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::Time, _impl_.t_func_),
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::Time, _impl_.t_arg_),
        1,
        0,
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::Array, _impl_._has_bits_),
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::Array, _internal_metadata_),
        ~0u,  // no _extensions_
        ~0u,  // no _oneof_case_
        ~0u,  // no _weak_field_map_
        ~0u,  // no _inlined_string_donated_
        ~0u,  // no _split_
        ~0u,  // no sizeof(Split)
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::Array, _impl_.arr_func_),
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::Array, _impl_.arr_arg_),
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::Array, _impl_.val_arg_),
        2,
        0,
        1,
        ~0u,  // no _has_bits_
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::MathType, _internal_metadata_),
        ~0u,  // no _extensions_
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::MathType, _impl_._oneof_case_[0]),
        ~0u,  // no _weak_field_map_
        ~0u,  // no _inlined_string_donated_
        ~0u,  // no _split_
        ~0u,  // no sizeof(Split)
        ::_pbi::kInvalidFieldOffsetTag,
        ::_pbi::kInvalidFieldOffsetTag,
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::MathType, _impl_.math_arg_oneof_),
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::MathOps, _impl_._has_bits_),
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::MathOps, _internal_metadata_),
        ~0u,  // no _extensions_
        ~0u,  // no _oneof_case_
        ~0u,  // no _weak_field_map_
        ~0u,  // no _inlined_string_donated_
        ~0u,  // no _split_
        ~0u,  // no sizeof(Split)
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::MathOps, _impl_.math_op_),
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::MathOps, _impl_.math_arg_),
        1,
        0,
        ~0u,  // no _has_bits_
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::BuiltinFuncs, _internal_metadata_),
        ~0u,  // no _extensions_
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::BuiltinFuncs, _impl_._oneof_case_[0]),
        ~0u,  // no _weak_field_map_
        ~0u,  // no _inlined_string_donated_
        ~0u,  // no _split_
        ~0u,  // no sizeof(Split)
        ::_pbi::kInvalidFieldOffsetTag,
        ::_pbi::kInvalidFieldOffsetTag,
        ::_pbi::kInvalidFieldOffsetTag,
        ::_pbi::kInvalidFieldOffsetTag,
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::BuiltinFuncs, _impl_.bifunc_oneof_),
        ~0u,  // no _has_bits_
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::Statement, _internal_metadata_),
        ~0u,  // no _extensions_
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::Statement, _impl_._oneof_case_[0]),
        ~0u,  // no _weak_field_map_
        ~0u,  // no _inlined_string_donated_
        ~0u,  // no _split_
        ~0u,  // no sizeof(Split)
        ::_pbi::kInvalidFieldOffsetTag,
        ::_pbi::kInvalidFieldOffsetTag,
        ::_pbi::kInvalidFieldOffsetTag,
        ::_pbi::kInvalidFieldOffsetTag,
        ::_pbi::kInvalidFieldOffsetTag,
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::Statement, _impl_.stmt_oneof_),
        ~0u,  // no _has_bits_
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::StatementSeq, _internal_metadata_),
        ~0u,  // no _extensions_
        ~0u,  // no _oneof_case_
        ~0u,  // no _weak_field_map_
        ~0u,  // no _inlined_string_donated_
        ~0u,  // no _split_
        ~0u,  // no sizeof(Split)
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::StatementSeq, _impl_.statements_),
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::Function, _impl_._has_bits_),
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::Function, _internal_metadata_),
        ~0u,  // no _extensions_
        ~0u,  // no _oneof_case_
        ~0u,  // no _weak_field_map_
        ~0u,  // no _inlined_string_donated_
        ~0u,  // no _split_
        ~0u,  // no sizeof(Split)
        PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::Function, _impl_.statements_),
        0,
};

static const ::_pbi::MigrationSchema
    schemas[] ABSL_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
        {0, 9, -1, sizeof(::ruby_fuzzer::VarRef)},
        {10, -1, -1, sizeof(::ruby_fuzzer::ArrType)},
        {19, 29, -1, sizeof(::ruby_fuzzer::KVPair)},
        {31, -1, -1, sizeof(::ruby_fuzzer::HashType)},
        {40, 50, -1, sizeof(::ruby_fuzzer::StringExtNoArg)},
        {52, 61, -1, sizeof(::ruby_fuzzer::MathConst)},
        {62, -1, -1, sizeof(::ruby_fuzzer::Const)},
        {73, 84, -1, sizeof(::ruby_fuzzer::BinaryOp)},
        {87, -1, -1, sizeof(::ruby_fuzzer::Rvalue)},
        {99, 108, -1, sizeof(::ruby_fuzzer::AssignmentStatement)},
        {109, 120, -1, sizeof(::ruby_fuzzer::IfElse)},
        {123, 134, -1, sizeof(::ruby_fuzzer::Ternary)},
        {137, 147, -1, sizeof(::ruby_fuzzer::ObjectSpace)},
        {149, 159, -1, sizeof(::ruby_fuzzer::Time)},
        {161, 172, -1, sizeof(::ruby_fuzzer::Array)},
        {175, -1, -1, sizeof(::ruby_fuzzer::MathType)},
        {186, 196, -1, sizeof(::ruby_fuzzer::MathOps)},
        {198, -1, -1, sizeof(::ruby_fuzzer::BuiltinFuncs)},
        {211, -1, -1, sizeof(::ruby_fuzzer::Statement)},
        {225, -1, -1, sizeof(::ruby_fuzzer::StatementSeq)},
        {234, 243, -1, sizeof(::ruby_fuzzer::Function)},
};
static const ::_pb::Message* const file_default_instances[] = {
    &::ruby_fuzzer::_VarRef_default_instance_._instance,
    &::ruby_fuzzer::_ArrType_default_instance_._instance,
    &::ruby_fuzzer::_KVPair_default_instance_._instance,
    &::ruby_fuzzer::_HashType_default_instance_._instance,
    &::ruby_fuzzer::_StringExtNoArg_default_instance_._instance,
    &::ruby_fuzzer::_MathConst_default_instance_._instance,
    &::ruby_fuzzer::_Const_default_instance_._instance,
    &::ruby_fuzzer::_BinaryOp_default_instance_._instance,
    &::ruby_fuzzer::_Rvalue_default_instance_._instance,
    &::ruby_fuzzer::_AssignmentStatement_default_instance_._instance,
    &::ruby_fuzzer::_IfElse_default_instance_._instance,
    &::ruby_fuzzer::_Ternary_default_instance_._instance,
    &::ruby_fuzzer::_ObjectSpace_default_instance_._instance,
    &::ruby_fuzzer::_Time_default_instance_._instance,
    &::ruby_fuzzer::_Array_default_instance_._instance,
    &::ruby_fuzzer::_MathType_default_instance_._instance,
    &::ruby_fuzzer::_MathOps_default_instance_._instance,
    &::ruby_fuzzer::_BuiltinFuncs_default_instance_._instance,
    &::ruby_fuzzer::_Statement_default_instance_._instance,
    &::ruby_fuzzer::_StatementSeq_default_instance_._instance,
    &::ruby_fuzzer::_Function_default_instance_._instance,
};
const char descriptor_table_protodef_ruby_2eproto[] ABSL_ATTRIBUTE_SECTION_VARIABLE(
    protodesc_cold) = {
    "\n\nruby.proto\022\013ruby_fuzzer\"\030\n\006VarRef\022\016\n\006v"
    "arnum\030\001 \002(\005\"/\n\007ArrType\022$\n\010elements\030\001 \003(\013"
    "2\022.ruby_fuzzer.Const\"\"\n\006KVPair\022\013\n\003key\030\001 "
    "\002(\t\022\013\n\003val\030\002 \002(\t\"/\n\010HashType\022#\n\006keyval\030\001"
    " \003(\0132\023.ruby_fuzzer.KVPair\"\341\001\n\016StringExtN"
    "oArg\0224\n\006str_op\030\001 \002(\0162$.ruby_fuzzer.Strin"
    "gExtNoArg.StrExtOp\022\017\n\007str_arg\030\002 \002(\t\"\207\001\n\010"
    "StrExtOp\022\010\n\004DUMP\020\000\022\t\n\005STRIP\020\001\022\n\n\006LSTRIP\020"
    "\002\022\n\n\006RSTRIP\020\003\022\n\n\006STRIPE\020\004\022\013\n\007LSTRIPE\020\005\022\013"
    "\n\007RSTRIPE\020\006\022\014\n\010SWAPCASE\020\007\022\r\n\tSWAPCASEE\020\010"
    "\022\013\n\007SQUEEZE\020\t\"c\n\tMathConst\0227\n\nmath_const"
    "\030\001 \002(\0162#.ruby_fuzzer.MathConst.MathConst"
    "Lit\"\035\n\014MathConstLit\022\006\n\002PI\020\000\022\005\n\001E\020\001\"=\n\005Co"
    "nst\022\021\n\007int_lit\030\001 \001(\rH\000\022\022\n\010bool_val\030\004 \001(\010"
    "H\000B\r\n\013const_oneof\"\375\001\n\010BinaryOp\022$\n\002op\030\001 \002"
    "(\0162\030.ruby_fuzzer.BinaryOp.Op\022!\n\004left\030\002 \002"
    "(\0132\023.ruby_fuzzer.Rvalue\022\"\n\005right\030\003 \002(\0132\023"
    ".ruby_fuzzer.Rvalue\"\203\001\n\002Op\022\007\n\003ADD\020\000\022\007\n\003S"
    "UB\020\001\022\007\n\003MUL\020\002\022\007\n\003DIV\020\003\022\007\n\003MOD\020\004\022\007\n\003XOR\020\005"
    "\022\007\n\003AND\020\006\022\006\n\002OR\020\007\022\006\n\002EQ\020\010\022\006\n\002NE\020\t\022\006\n\002LE\020"
    "\n\022\006\n\002GE\020\013\022\006\n\002LT\020\014\022\006\n\002GT\020\r\022\006\n\002RS\020\016\"\213\001\n\006Rv"
    "alue\022%\n\006varref\030\001 \001(\0132\023.ruby_fuzzer.VarRe"
    "fH\000\022\"\n\004cons\030\002 \001(\0132\022.ruby_fuzzer.ConstH\000\022"
    "&\n\005binop\030\003 \001(\0132\025.ruby_fuzzer.BinaryOpH\000B"
    "\016\n\014rvalue_oneof\":\n\023AssignmentStatement\022#"
    "\n\006rvalue\030\002 \002(\0132\023.ruby_fuzzer.Rvalue\"\205\001\n\006"
    "IfElse\022!\n\004cond\030\001 \002(\0132\023.ruby_fuzzer.Rvalu"
    "e\022*\n\007if_body\030\002 \002(\0132\031.ruby_fuzzer.Stateme"
    "ntSeq\022,\n\telse_body\030\003 \002(\0132\031.ruby_fuzzer.S"
    "tatementSeq\"\177\n\007Ternary\022&\n\ttern_cond\030\001 \002("
    "\0132\023.ruby_fuzzer.Rvalue\022%\n\010t_branch\030\002 \002(\013"
    "2\023.ruby_fuzzer.Rvalue\022%\n\010f_branch\030\003 \002(\0132"
    "\023.ruby_fuzzer.Rvalue\"\203\001\n\013ObjectSpace\0224\n\007"
    "os_func\030\001 \002(\0162#.ruby_fuzzer.ObjectSpace."
    "OS_methods\022%\n\006os_arg\030\002 \002(\0132\025.ruby_fuzzer"
    ".HashType\"\027\n\nOS_methods\022\t\n\005COUNT\020\001\"_\n\004Ti"
    "me\022+\n\006t_func\030\001 \002(\0162\033.ruby_fuzzer.Time.T_"
    "methods\022\r\n\005t_arg\030\002 \002(\r\"\033\n\tT_methods\022\006\n\002A"
    "T\020\001\022\006\n\002GM\020\002\"\367\002\n\005Array\0220\n\010arr_func\030\001 \002(\0162"
    "\036.ruby_fuzzer.Array.Arr_methods\022%\n\007arr_a"
    "rg\030\002 \002(\0132\024.ruby_fuzzer.ArrType\022$\n\007val_ar"
    "g\030\003 \002(\0132\023.ruby_fuzzer.Rvalue\"\356\001\n\013Arr_met"
    "hods\022\013\n\007FLATTEN\020\001\022\013\n\007COMPACT\020\002\022\t\n\005FETCH\020"
    "\003\022\010\n\004FILL\020\004\022\n\n\006ROTATE\020\005\022\014\n\010ROTATE_E\020\006\022\014\n"
    "\010DELETEIF\020\007\022\n\n\006INSERT\020\010\022\013\n\007BSEARCH\020\t\022\n\n\006"
    "KEEPIF\020\n\022\n\n\006SELECT\020\013\022\r\n\tVALUES_AT\020\014\022\t\n\005B"
    "LOCK\020\r\022\007\n\003DIG\020\016\022\t\n\005SLICE\020\017\022\010\n\004PERM\020\020\022\010\n\004"
    "COMB\020\021\022\t\n\005ASSOC\020\022\022\n\n\006RASSOC\020\023\"t\n\010MathTyp"
    "e\022(\n\tmath_rval\030\002 \001(\0132\023.ruby_fuzzer.Rvalu"
    "eH\000\022,\n\nmath_const\030\003 \001(\0132\026.ruby_fuzzer.Ma"
    "thConstH\000B\020\n\016math_arg_oneof\"\306\001\n\007MathOps\022"
    "*\n\007math_op\030\001 \002(\0162\031.ruby_fuzzer.MathOps.M"
    "ops\022\'\n\010math_arg\030\002 \002(\0132\025.ruby_fuzzer.Math"
    "Type\"f\n\004Mops\022\010\n\004CBRT\020\001\022\007\n\003COS\020\002\022\007\n\003ERF\020\003"
    "\022\010\n\004ERFC\020\004\022\007\n\003LOG\020\005\022\t\n\005LOG10\020\006\022\010\n\004LOG2\020\007"
    "\022\007\n\003SIN\020\010\022\010\n\004SQRT\020\t\022\007\n\003TAN\020\n\"\262\001\n\014Builtin"
    "Funcs\022&\n\002os\030\001 \001(\0132\030.ruby_fuzzer.ObjectSp"
    "aceH\000\022!\n\004time\030\002 \001(\0132\021.ruby_fuzzer.TimeH\000"
    "\022!\n\003arr\030\003 \001(\0132\022.ruby_fuzzer.ArrayH\000\022$\n\004m"
    "ops\030\004 \001(\0132\024.ruby_fuzzer.MathOpsH\000B\016\n\014bif"
    "unc_oneof\"\205\002\n\tStatement\0226\n\nassignment\030\001 "
    "\001(\0132 .ruby_fuzzer.AssignmentStatementH\000\022"
    "%\n\006ifelse\030\002 \001(\0132\023.ruby_fuzzer.IfElseH\000\022,"
    "\n\014ternary_stmt\030\003 \001(\0132\024.ruby_fuzzer.Terna"
    "ryH\000\022-\n\010builtins\030\004 \001(\0132\031.ruby_fuzzer.Bui"
    "ltinFuncsH\000\022.\n\tblockstmt\030\005 \001(\0132\031.ruby_fu"
    "zzer.StatementSeqH\000B\014\n\nstmt_oneof\":\n\014Sta"
    "tementSeq\022*\n\nstatements\030\001 \003(\0132\026.ruby_fuz"
    "zer.Statement\"9\n\010Function\022-\n\nstatements\030"
    "\001 \002(\0132\031.ruby_fuzzer.StatementSeq"
};
static ::absl::once_flag descriptor_table_ruby_2eproto_once;
PROTOBUF_CONSTINIT const ::_pbi::DescriptorTable descriptor_table_ruby_2eproto = {
    false,
    false,
    2792,
    descriptor_table_protodef_ruby_2eproto,
    "ruby.proto",
    &descriptor_table_ruby_2eproto_once,
    nullptr,
    0,
    21,
    schemas,
    file_default_instances,
    TableStruct_ruby_2eproto::offsets,
    file_level_enum_descriptors_ruby_2eproto,
    file_level_service_descriptors_ruby_2eproto,
};
namespace ruby_fuzzer {
const ::google::protobuf::EnumDescriptor* StringExtNoArg_StrExtOp_descriptor() {
  ::google::protobuf::internal::AssignDescriptors(&descriptor_table_ruby_2eproto);
  return file_level_enum_descriptors_ruby_2eproto[0];
}
PROTOBUF_CONSTINIT const uint32_t StringExtNoArg_StrExtOp_internal_data_[] = {
    655360u, 0u, };
bool StringExtNoArg_StrExtOp_IsValid(int value) {
  return 0 <= value && value <= 9;
}
#if (__cplusplus < 201703) && \
  (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))

constexpr StringExtNoArg_StrExtOp StringExtNoArg::DUMP;
constexpr StringExtNoArg_StrExtOp StringExtNoArg::STRIP;
constexpr StringExtNoArg_StrExtOp StringExtNoArg::LSTRIP;
constexpr StringExtNoArg_StrExtOp StringExtNoArg::RSTRIP;
constexpr StringExtNoArg_StrExtOp StringExtNoArg::STRIPE;
constexpr StringExtNoArg_StrExtOp StringExtNoArg::LSTRIPE;
constexpr StringExtNoArg_StrExtOp StringExtNoArg::RSTRIPE;
constexpr StringExtNoArg_StrExtOp StringExtNoArg::SWAPCASE;
constexpr StringExtNoArg_StrExtOp StringExtNoArg::SWAPCASEE;
constexpr StringExtNoArg_StrExtOp StringExtNoArg::SQUEEZE;
constexpr StringExtNoArg_StrExtOp StringExtNoArg::StrExtOp_MIN;
constexpr StringExtNoArg_StrExtOp StringExtNoArg::StrExtOp_MAX;
constexpr int StringExtNoArg::StrExtOp_ARRAYSIZE;

#endif  // (__cplusplus < 201703) &&
        // (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
const ::google::protobuf::EnumDescriptor* MathConst_MathConstLit_descriptor() {
  ::google::protobuf::internal::AssignDescriptors(&descriptor_table_ruby_2eproto);
  return file_level_enum_descriptors_ruby_2eproto[1];
}
PROTOBUF_CONSTINIT const uint32_t MathConst_MathConstLit_internal_data_[] = {
    131072u, 0u, };
bool MathConst_MathConstLit_IsValid(int value) {
  return 0 <= value && value <= 1;
}
#if (__cplusplus < 201703) && \
  (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))

constexpr MathConst_MathConstLit MathConst::PI;
constexpr MathConst_MathConstLit MathConst::E;
constexpr MathConst_MathConstLit MathConst::MathConstLit_MIN;
constexpr MathConst_MathConstLit MathConst::MathConstLit_MAX;
constexpr int MathConst::MathConstLit_ARRAYSIZE;

#endif  // (__cplusplus < 201703) &&
        // (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
const ::google::protobuf::EnumDescriptor* BinaryOp_Op_descriptor() {
  ::google::protobuf::internal::AssignDescriptors(&descriptor_table_ruby_2eproto);
  return file_level_enum_descriptors_ruby_2eproto[2];
}
PROTOBUF_CONSTINIT const uint32_t BinaryOp_Op_internal_data_[] = {
    983040u, 0u, };
bool BinaryOp_Op_IsValid(int value) {
  return 0 <= value && value <= 14;
}
#if (__cplusplus < 201703) && \
  (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))

constexpr BinaryOp_Op BinaryOp::ADD;
constexpr BinaryOp_Op BinaryOp::SUB;
constexpr BinaryOp_Op BinaryOp::MUL;
constexpr BinaryOp_Op BinaryOp::DIV;
constexpr BinaryOp_Op BinaryOp::MOD;
constexpr BinaryOp_Op BinaryOp::XOR;
constexpr BinaryOp_Op BinaryOp::AND;
constexpr BinaryOp_Op BinaryOp::OR;
constexpr BinaryOp_Op BinaryOp::EQ;
constexpr BinaryOp_Op BinaryOp::NE;
constexpr BinaryOp_Op BinaryOp::LE;
constexpr BinaryOp_Op BinaryOp::GE;
constexpr BinaryOp_Op BinaryOp::LT;
constexpr BinaryOp_Op BinaryOp::GT;
constexpr BinaryOp_Op BinaryOp::RS;
constexpr BinaryOp_Op BinaryOp::Op_MIN;
constexpr BinaryOp_Op BinaryOp::Op_MAX;
constexpr int BinaryOp::Op_ARRAYSIZE;

#endif  // (__cplusplus < 201703) &&
        // (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
const ::google::protobuf::EnumDescriptor* ObjectSpace_OS_methods_descriptor() {
  ::google::protobuf::internal::AssignDescriptors(&descriptor_table_ruby_2eproto);
  return file_level_enum_descriptors_ruby_2eproto[3];
}
PROTOBUF_CONSTINIT const uint32_t ObjectSpace_OS_methods_internal_data_[] = {
    65537u, 0u, };
bool ObjectSpace_OS_methods_IsValid(int value) {
  return 1 <= value && value <= 1;
}
#if (__cplusplus < 201703) && \
  (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))

constexpr ObjectSpace_OS_methods ObjectSpace::COUNT;
constexpr ObjectSpace_OS_methods ObjectSpace::OS_methods_MIN;
constexpr ObjectSpace_OS_methods ObjectSpace::OS_methods_MAX;
constexpr int ObjectSpace::OS_methods_ARRAYSIZE;

#endif  // (__cplusplus < 201703) &&
        // (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
const ::google::protobuf::EnumDescriptor* Time_T_methods_descriptor() {
  ::google::protobuf::internal::AssignDescriptors(&descriptor_table_ruby_2eproto);
  return file_level_enum_descriptors_ruby_2eproto[4];
}
PROTOBUF_CONSTINIT const uint32_t Time_T_methods_internal_data_[] = {
    131073u, 0u, };
bool Time_T_methods_IsValid(int value) {
  return 1 <= value && value <= 2;
}
#if (__cplusplus < 201703) && \
  (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))

constexpr Time_T_methods Time::AT;
constexpr Time_T_methods Time::GM;
constexpr Time_T_methods Time::T_methods_MIN;
constexpr Time_T_methods Time::T_methods_MAX;
constexpr int Time::T_methods_ARRAYSIZE;

#endif  // (__cplusplus < 201703) &&
        // (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
const ::google::protobuf::EnumDescriptor* Array_Arr_methods_descriptor() {
  ::google::protobuf::internal::AssignDescriptors(&descriptor_table_ruby_2eproto);
  return file_level_enum_descriptors_ruby_2eproto[5];
}
PROTOBUF_CONSTINIT const uint32_t Array_Arr_methods_internal_data_[] = {
    1245185u, 0u, };
bool Array_Arr_methods_IsValid(int value) {
  return 1 <= value && value <= 19;
}
#if (__cplusplus < 201703) && \
  (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))

constexpr Array_Arr_methods Array::FLATTEN;
constexpr Array_Arr_methods Array::COMPACT;
constexpr Array_Arr_methods Array::FETCH;
constexpr Array_Arr_methods Array::FILL;
constexpr Array_Arr_methods Array::ROTATE;
constexpr Array_Arr_methods Array::ROTATE_E;
constexpr Array_Arr_methods Array::DELETEIF;
constexpr Array_Arr_methods Array::INSERT;
constexpr Array_Arr_methods Array::BSEARCH;
constexpr Array_Arr_methods Array::KEEPIF;
constexpr Array_Arr_methods Array::SELECT;
constexpr Array_Arr_methods Array::VALUES_AT;
constexpr Array_Arr_methods Array::BLOCK;
constexpr Array_Arr_methods Array::DIG;
constexpr Array_Arr_methods Array::SLICE;
constexpr Array_Arr_methods Array::PERM;
constexpr Array_Arr_methods Array::COMB;
constexpr Array_Arr_methods Array::ASSOC;
constexpr Array_Arr_methods Array::RASSOC;
constexpr Array_Arr_methods Array::Arr_methods_MIN;
constexpr Array_Arr_methods Array::Arr_methods_MAX;
constexpr int Array::Arr_methods_ARRAYSIZE;

#endif  // (__cplusplus < 201703) &&
        // (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
const ::google::protobuf::EnumDescriptor* MathOps_Mops_descriptor() {
  ::google::protobuf::internal::AssignDescriptors(&descriptor_table_ruby_2eproto);
  return file_level_enum_descriptors_ruby_2eproto[6];
}
PROTOBUF_CONSTINIT const uint32_t MathOps_Mops_internal_data_[] = {
    655361u, 0u, };
bool MathOps_Mops_IsValid(int value) {
  return 1 <= value && value <= 10;
}
#if (__cplusplus < 201703) && \
  (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))

constexpr MathOps_Mops MathOps::CBRT;
constexpr MathOps_Mops MathOps::COS;
constexpr MathOps_Mops MathOps::ERF;
constexpr MathOps_Mops MathOps::ERFC;
constexpr MathOps_Mops MathOps::LOG;
constexpr MathOps_Mops MathOps::LOG10;
constexpr MathOps_Mops MathOps::LOG2;
constexpr MathOps_Mops MathOps::SIN;
constexpr MathOps_Mops MathOps::SQRT;
constexpr MathOps_Mops MathOps::TAN;
constexpr MathOps_Mops MathOps::Mops_MIN;
constexpr MathOps_Mops MathOps::Mops_MAX;
constexpr int MathOps::Mops_ARRAYSIZE;

#endif  // (__cplusplus < 201703) &&
        // (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
// ===================================================================

class VarRef::_Internal {
 public:
  using HasBits =
      decltype(std::declval<VarRef>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(VarRef, _impl_._has_bits_);
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0;
  }
};

VarRef::VarRef(::google::protobuf::Arena* arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, _class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:ruby_fuzzer.VarRef)
}
VarRef::VarRef(
    ::google::protobuf::Arena* arena, const VarRef& from)
    : VarRef(arena) {
  MergeFrom(from);
}
inline PROTOBUF_NDEBUG_INLINE VarRef::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility,
    ::google::protobuf::Arena* arena)
      : _cached_size_{0} {}

inline void VarRef::SharedCtor(::_pb::Arena* arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  _impl_.varnum_ = {};
}
VarRef::~VarRef() {
  // @@protoc_insertion_point(destructor:ruby_fuzzer.VarRef)
  SharedDtor(*this);
}
inline void VarRef::SharedDtor(MessageLite& self) {
  VarRef& this_ = static_cast<VarRef&>(self);
  this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  this_._impl_.~Impl_();
}

inline void* VarRef::PlacementNew_(const void*, void* mem,
                                        ::google::protobuf::Arena* arena) {
  return ::new (mem) VarRef(arena);
}
constexpr auto VarRef::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(VarRef),
                                            alignof(VarRef));
}
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataFull VarRef::_class_data_ = {
    ::google::protobuf::internal::ClassData{
        &_VarRef_default_instance_._instance,
        &_table_.header,
        nullptr,  // OnDemandRegisterArenaDtor
        VarRef::IsInitializedImpl,
        &VarRef::MergeImpl,
        ::google::protobuf::Message::GetNewImpl<VarRef>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
        &VarRef::SharedDtor,
        ::google::protobuf::Message::GetClearImpl<VarRef>(), &VarRef::ByteSizeLong,
            &VarRef::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
        PROTOBUF_FIELD_OFFSET(VarRef, _impl_._cached_size_),
        false,
    },
    &VarRef::kDescriptorMethods,
    &descriptor_table_ruby_2eproto,
    nullptr,  // tracker
};
const ::google::protobuf::internal::ClassData* VarRef::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_);
  ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table);
  return _class_data_.base();
}
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::_pbi::TcParseTable<0, 1, 0, 0, 2> VarRef::_table_ = {
  {
    PROTOBUF_FIELD_OFFSET(VarRef, _impl_._has_bits_),
    0, // no _extensions_
    1, 0,  // max_field_number, fast_idx_mask
    offsetof(decltype(_table_), field_lookup_table),
    4294967294,  // skipmap
    offsetof(decltype(_table_), field_entries),
    1,  // num_field_entries
    0,  // num_aux_entries
    offsetof(decltype(_table_), field_names),  // no aux_entries
    _class_data_.base(),
    nullptr,  // post_loop_handler
    ::_pbi::TcParser::GenericFallback,  // fallback
    #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
    ::_pbi::TcParser::GetTable<::ruby_fuzzer::VarRef>(),  // to_prefetch
    #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
  }, {{
    // required int32 varnum = 1;
    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(VarRef, _impl_.varnum_), 0>(),
     {8, 0, 0, PROTOBUF_FIELD_OFFSET(VarRef, _impl_.varnum_)}},
  }}, {{
    65535, 65535
  }}, {{
    // required int32 varnum = 1;
    {PROTOBUF_FIELD_OFFSET(VarRef, _impl_.varnum_), _Internal::kHasBitsOffset + 0, 0,
    (0 | ::_fl::kFcOptional | ::_fl::kInt32)},
  }},
  // no aux_entries
  {{
  }},
};

PROTOBUF_NOINLINE void VarRef::Clear() {
// @@protoc_insertion_point(message_clear_start:ruby_fuzzer.VarRef)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.varnum_ = 0;
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
        ::uint8_t* VarRef::_InternalSerialize(
            const MessageLite& base, ::uint8_t* target,
            ::google::protobuf::io::EpsCopyOutputStream* stream) {
          const VarRef& this_ = static_cast<const VarRef&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
        ::uint8_t* VarRef::_InternalSerialize(
            ::uint8_t* target,
            ::google::protobuf::io::EpsCopyOutputStream* stream) const {
          const VarRef& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
          // @@protoc_insertion_point(serialize_to_array_start:ruby_fuzzer.VarRef)
          ::uint32_t cached_has_bits = 0;
          (void)cached_has_bits;

          cached_has_bits = this_._impl_._has_bits_[0];
          // required int32 varnum = 1;
          if (cached_has_bits & 0x00000001u) {
            target = ::google::protobuf::internal::WireFormatLite::
                WriteInt32ToArrayWithField<1>(
                    stream, this_._internal_varnum(), target);
          }

          if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
            target =
                ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
                    this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
          }
          // @@protoc_insertion_point(serialize_to_array_end:ruby_fuzzer.VarRef)
          return target;
        }

#if defined(PROTOBUF_CUSTOM_VTABLE)
        ::size_t VarRef::ByteSizeLong(const MessageLite& base) {
          const VarRef& this_ = static_cast<const VarRef&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
        ::size_t VarRef::ByteSizeLong() const {
          const VarRef& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
          // @@protoc_insertion_point(message_byte_size_start:ruby_fuzzer.VarRef)
          ::size_t total_size = 0;

          ::uint32_t cached_has_bits = 0;
          // Prevent compiler warnings about cached_has_bits being unused
          (void)cached_has_bits;

           {
            // required int32 varnum = 1;
            cached_has_bits = this_._impl_._has_bits_[0];
            if (cached_has_bits & 0x00000001u) {
              total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
                  this_._internal_varnum());
            }
          }
          return this_.MaybeComputeUnknownFieldsSize(total_size,
                                                     &this_._impl_._cached_size_);
        }

void VarRef::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) {
  auto* const _this = static_cast<VarRef*>(&to_msg);
  auto& from = static_cast<const VarRef&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:ruby_fuzzer.VarRef)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    _this->_impl_.varnum_ = from._impl_.varnum_;
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_);
}

void VarRef::CopyFrom(const VarRef& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:ruby_fuzzer.VarRef)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

PROTOBUF_NOINLINE bool VarRef::IsInitializedImpl(
    const MessageLite& msg) {
  auto& this_ = static_cast<const VarRef&>(msg);
  if (_Internal::MissingRequiredFields(this_._impl_._has_bits_)) {
    return false;
  }
  return true;
}

void VarRef::InternalSwap(VarRef* PROTOBUF_RESTRICT other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
        swap(_impl_.varnum_, other->_impl_.varnum_);
}

::google::protobuf::Metadata VarRef::GetMetadata() const {
  return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full());
}
// ===================================================================

class ArrType::_Internal {
 public:
};

ArrType::ArrType(::google::protobuf::Arena* arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, _class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:ruby_fuzzer.ArrType)
}
inline PROTOBUF_NDEBUG_INLINE ArrType::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena,
    const Impl_& from, const ::ruby_fuzzer::ArrType& from_msg)
      : elements_{visibility, arena, from.elements_},
        _cached_size_{0} {}

ArrType::ArrType(
    ::google::protobuf::Arena* arena,
    const ArrType& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, _class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  ArrType* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);

  // @@protoc_insertion_point(copy_constructor:ruby_fuzzer.ArrType)
}
inline PROTOBUF_NDEBUG_INLINE ArrType::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility,
    ::google::protobuf::Arena* arena)
      : elements_{visibility, arena},
        _cached_size_{0} {}

inline void ArrType::SharedCtor(::_pb::Arena* arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
}
ArrType::~ArrType() {
  // @@protoc_insertion_point(destructor:ruby_fuzzer.ArrType)
  SharedDtor(*this);
}
inline void ArrType::SharedDtor(MessageLite& self) {
  ArrType& this_ = static_cast<ArrType&>(self);
  this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  this_._impl_.~Impl_();
}

inline void* ArrType::PlacementNew_(const void*, void* mem,
                                        ::google::protobuf::Arena* arena) {
  return ::new (mem) ArrType(arena);
}
constexpr auto ArrType::InternalNewImpl_() {
  constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({
      PROTOBUF_FIELD_OFFSET(ArrType, _impl_.elements_) +
          decltype(ArrType::_impl_.elements_)::
              InternalGetArenaOffset(
                  ::google::protobuf::Message::internal_visibility()),
  });
  if (arena_bits.has_value()) {
    return ::google::protobuf::internal::MessageCreator::ZeroInit(
        sizeof(ArrType), alignof(ArrType), *arena_bits);
  } else {
    return ::google::protobuf::internal::MessageCreator(&ArrType::PlacementNew_,
                                 sizeof(ArrType),
                                 alignof(ArrType));
  }
}
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataFull ArrType::_class_data_ = {
    ::google::protobuf::internal::ClassData{
        &_ArrType_default_instance_._instance,
        &_table_.header,
        nullptr,  // OnDemandRegisterArenaDtor
        nullptr,  // IsInitialized
        &ArrType::MergeImpl,
        ::google::protobuf::Message::GetNewImpl<ArrType>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
        &ArrType::SharedDtor,
        ::google::protobuf::Message::GetClearImpl<ArrType>(), &ArrType::ByteSizeLong,
            &ArrType::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
        PROTOBUF_FIELD_OFFSET(ArrType, _impl_._cached_size_),
        false,
    },
    &ArrType::kDescriptorMethods,
    &descriptor_table_ruby_2eproto,
    nullptr,  // tracker
};
const ::google::protobuf::internal::ClassData* ArrType::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_);
  ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table);
  return _class_data_.base();
}
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::_pbi::TcParseTable<0, 1, 1, 0, 2> ArrType::_table_ = {
  {
    0,  // no _has_bits_
    0, // no _extensions_
    1, 0,  // max_field_number, fast_idx_mask
    offsetof(decltype(_table_), field_lookup_table),
    4294967294,  // skipmap
    offsetof(decltype(_table_), field_entries),
    1,  // num_field_entries
    1,  // num_aux_entries
    offsetof(decltype(_table_), aux_entries),
    _class_data_.base(),
    nullptr,  // post_loop_handler
    ::_pbi::TcParser::GenericFallback,  // fallback
    #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
    ::_pbi::TcParser::GetTable<::ruby_fuzzer::ArrType>(),  // to_prefetch
    #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
  }, {{
    // repeated .ruby_fuzzer.Const elements = 1;
    {::_pbi::TcParser::FastMtR1,
     {10, 63, 0, PROTOBUF_FIELD_OFFSET(ArrType, _impl_.elements_)}},
  }}, {{
    65535, 65535
  }}, {{
    // repeated .ruby_fuzzer.Const elements = 1;
    {PROTOBUF_FIELD_OFFSET(ArrType, _impl_.elements_), 0, 0,
    (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)},
  }}, {{
    {::_pbi::TcParser::GetTable<::ruby_fuzzer::Const>()},
  }}, {{
  }},
};

PROTOBUF_NOINLINE void ArrType::Clear() {
// @@protoc_insertion_point(message_clear_start:ruby_fuzzer.ArrType)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.elements_.Clear();
  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
        ::uint8_t* ArrType::_InternalSerialize(
            const MessageLite& base, ::uint8_t* target,
            ::google::protobuf::io::EpsCopyOutputStream* stream) {
          const ArrType& this_ = static_cast<const ArrType&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
        ::uint8_t* ArrType::_InternalSerialize(
            ::uint8_t* target,
            ::google::protobuf::io::EpsCopyOutputStream* stream) const {
          const ArrType& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
          // @@protoc_insertion_point(serialize_to_array_start:ruby_fuzzer.ArrType)
          ::uint32_t cached_has_bits = 0;
          (void)cached_has_bits;

          // repeated .ruby_fuzzer.Const elements = 1;
          for (unsigned i = 0, n = static_cast<unsigned>(
                                   this_._internal_elements_size());
               i < n; i++) {
            const auto& repfield = this_._internal_elements().Get(i);
            target =
                ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
                    1, repfield, repfield.GetCachedSize(),
                    target, stream);
          }

          if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
            target =
                ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
                    this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
          }
          // @@protoc_insertion_point(serialize_to_array_end:ruby_fuzzer.ArrType)
          return target;
        }

#if defined(PROTOBUF_CUSTOM_VTABLE)
        ::size_t ArrType::ByteSizeLong(const MessageLite& base) {
          const ArrType& this_ = static_cast<const ArrType&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
        ::size_t ArrType::ByteSizeLong() const {
          const ArrType& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
          // @@protoc_insertion_point(message_byte_size_start:ruby_fuzzer.ArrType)
          ::size_t total_size = 0;

          ::uint32_t cached_has_bits = 0;
          // Prevent compiler warnings about cached_has_bits being unused
          (void)cached_has_bits;

          ::_pbi::Prefetch5LinesFrom7Lines(&this_);
           {
            // repeated .ruby_fuzzer.Const elements = 1;
            {
              total_size += 1UL * this_._internal_elements_size();
              for (const auto& msg : this_._internal_elements()) {
                total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg);
              }
            }
          }
          return this_.MaybeComputeUnknownFieldsSize(total_size,
                                                     &this_._impl_._cached_size_);
        }

void ArrType::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) {
  auto* const _this = static_cast<ArrType*>(&to_msg);
  auto& from = static_cast<const ArrType&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:ruby_fuzzer.ArrType)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_internal_mutable_elements()->MergeFrom(
      from._internal_elements());
  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_);
}

void ArrType::CopyFrom(const ArrType& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:ruby_fuzzer.ArrType)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}


void ArrType::InternalSwap(ArrType* PROTOBUF_RESTRICT other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  _impl_.elements_.InternalSwap(&other->_impl_.elements_);
}

::google::protobuf::Metadata ArrType::GetMetadata() const {
  return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full());
}
// ===================================================================

class KVPair::_Internal {
 public:
  using HasBits =
      decltype(std::declval<KVPair>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(KVPair, _impl_._has_bits_);
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000003) ^ 0x00000003) != 0;
  }
};

KVPair::KVPair(::google::protobuf::Arena* arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, _class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:ruby_fuzzer.KVPair)
}
inline PROTOBUF_NDEBUG_INLINE KVPair::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena,
    const Impl_& from, const ::ruby_fuzzer::KVPair& from_msg)
      : _has_bits_{from._has_bits_},
        _cached_size_{0},
        key_(arena, from.key_),
        val_(arena, from.val_) {}

KVPair::KVPair(
    ::google::protobuf::Arena* arena,
    const KVPair& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, _class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  KVPair* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);

  // @@protoc_insertion_point(copy_constructor:ruby_fuzzer.KVPair)
}
inline PROTOBUF_NDEBUG_INLINE KVPair::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility,
    ::google::protobuf::Arena* arena)
      : _cached_size_{0},
        key_(arena),
        val_(arena) {}

inline void KVPair::SharedCtor(::_pb::Arena* arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
}
KVPair::~KVPair() {
  // @@protoc_insertion_point(destructor:ruby_fuzzer.KVPair)
  SharedDtor(*this);
}
inline void KVPair::SharedDtor(MessageLite& self) {
  KVPair& this_ = static_cast<KVPair&>(self);
  this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  this_._impl_.key_.Destroy();
  this_._impl_.val_.Destroy();
  this_._impl_.~Impl_();
}

inline void* KVPair::PlacementNew_(const void*, void* mem,
                                        ::google::protobuf::Arena* arena) {
  return ::new (mem) KVPair(arena);
}
constexpr auto KVPair::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(KVPair),
                                            alignof(KVPair));
}
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataFull KVPair::_class_data_ = {
    ::google::protobuf::internal::ClassData{
        &_KVPair_default_instance_._instance,
        &_table_.header,
        nullptr,  // OnDemandRegisterArenaDtor
        KVPair::IsInitializedImpl,
        &KVPair::MergeImpl,
        ::google::protobuf::Message::GetNewImpl<KVPair>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
        &KVPair::SharedDtor,
        ::google::protobuf::Message::GetClearImpl<KVPair>(), &KVPair::ByteSizeLong,
            &KVPair::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
        PROTOBUF_FIELD_OFFSET(KVPair, _impl_._cached_size_),
        false,
    },
    &KVPair::kDescriptorMethods,
    &descriptor_table_ruby_2eproto,
    nullptr,  // tracker
};
const ::google::protobuf::internal::ClassData* KVPair::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_);
  ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table);
  return _class_data_.base();
}
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::_pbi::TcParseTable<1, 2, 0, 33, 2> KVPair::_table_ = {
  {
    PROTOBUF_FIELD_OFFSET(KVPair, _impl_._has_bits_),
    0, // no _extensions_
    2, 8,  // max_field_number, fast_idx_mask
    offsetof(decltype(_table_), field_lookup_table),
    4294967292,  // skipmap
    offsetof(decltype(_table_), field_entries),
    2,  // num_field_entries
    0,  // num_aux_entries
    offsetof(decltype(_table_), field_names),  // no aux_entries
    _class_data_.base(),
    nullptr,  // post_loop_handler
    ::_pbi::TcParser::GenericFallback,  // fallback
    #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
    ::_pbi::TcParser::GetTable<::ruby_fuzzer::KVPair>(),  // to_prefetch
    #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
  }, {{
    // required string val = 2;
    {::_pbi::TcParser::FastSS1,
     {18, 1, 0, PROTOBUF_FIELD_OFFSET(KVPair, _impl_.val_)}},
    // required string key = 1;
    {::_pbi::TcParser::FastSS1,
     {10, 0, 0, PROTOBUF_FIELD_OFFSET(KVPair, _impl_.key_)}},
  }}, {{
    65535, 65535
  }}, {{
    // required string key = 1;
    {PROTOBUF_FIELD_OFFSET(KVPair, _impl_.key_), _Internal::kHasBitsOffset + 0, 0,
    (0 | ::_fl::kFcOptional | ::_fl::kRawString | ::_fl::kRepAString)},
    // required string val = 2;
    {PROTOBUF_FIELD_OFFSET(KVPair, _impl_.val_), _Internal::kHasBitsOffset + 1, 0,
    (0 | ::_fl::kFcOptional | ::_fl::kRawString | ::_fl::kRepAString)},
  }},
  // no aux_entries
  {{
    "\22\3\3\0\0\0\0\0"
    "ruby_fuzzer.KVPair"
    "key"
    "val"
  }},
};

PROTOBUF_NOINLINE void KVPair::Clear() {
// @@protoc_insertion_point(message_clear_start:ruby_fuzzer.KVPair)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _impl_.key_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000002u) {
      _impl_.val_.ClearNonDefaultToEmpty();
    }
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
        ::uint8_t* KVPair::_InternalSerialize(
            const MessageLite& base, ::uint8_t* target,
            ::google::protobuf::io::EpsCopyOutputStream* stream) {
          const KVPair& this_ = static_cast<const KVPair&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
        ::uint8_t* KVPair::_InternalSerialize(
            ::uint8_t* target,
            ::google::protobuf::io::EpsCopyOutputStream* stream) const {
          const KVPair& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
          // @@protoc_insertion_point(serialize_to_array_start:ruby_fuzzer.KVPair)
          ::uint32_t cached_has_bits = 0;
          (void)cached_has_bits;

          cached_has_bits = this_._impl_._has_bits_[0];
          // required string key = 1;
          if (cached_has_bits & 0x00000001u) {
            const std::string& _s = this_._internal_key();
            ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(_s.data(), static_cast<int>(_s.length()), ::google::protobuf::internal::WireFormat::SERIALIZE,
                                        "ruby_fuzzer.KVPair.key");
            target = stream->WriteStringMaybeAliased(1, _s, target);
          }

          // required string val = 2;
          if (cached_has_bits & 0x00000002u) {
            const std::string& _s = this_._internal_val();
            ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(_s.data(), static_cast<int>(_s.length()), ::google::protobuf::internal::WireFormat::SERIALIZE,
                                        "ruby_fuzzer.KVPair.val");
            target = stream->WriteStringMaybeAliased(2, _s, target);
          }

          if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
            target =
                ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
                    this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
          }
          // @@protoc_insertion_point(serialize_to_array_end:ruby_fuzzer.KVPair)
          return target;
        }

#if defined(PROTOBUF_CUSTOM_VTABLE)
        ::size_t KVPair::ByteSizeLong(const MessageLite& base) {
          const KVPair& this_ = static_cast<const KVPair&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
        ::size_t KVPair::ByteSizeLong() const {
          const KVPair& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
          // @@protoc_insertion_point(message_byte_size_start:ruby_fuzzer.KVPair)
          ::size_t total_size = 0;

          ::uint32_t cached_has_bits = 0;
          // Prevent compiler warnings about cached_has_bits being unused
          (void)cached_has_bits;

          ::_pbi::Prefetch5LinesFrom7Lines(&this_);
          cached_has_bits = this_._impl_._has_bits_[0];
          if (cached_has_bits & 0x00000003u) {
            // required string key = 1;
            if (cached_has_bits & 0x00000001u) {
              total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize(
                                              this_._internal_key());
            }
            // required string val = 2;
            if (cached_has_bits & 0x00000002u) {
              total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize(
                                              this_._internal_val());
            }
          }
          return this_.MaybeComputeUnknownFieldsSize(total_size,
                                                     &this_._impl_._cached_size_);
        }

void KVPair::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) {
  auto* const _this = static_cast<KVPair*>(&to_msg);
  auto& from = static_cast<const KVPair&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:ruby_fuzzer.KVPair)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _this->_internal_set_key(from._internal_key());
    }
    if (cached_has_bits & 0x00000002u) {
      _this->_internal_set_val(from._internal_val());
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_);
}

void KVPair::CopyFrom(const KVPair& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:ruby_fuzzer.KVPair)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

PROTOBUF_NOINLINE bool KVPair::IsInitializedImpl(
    const MessageLite& msg) {
  auto& this_ = static_cast<const KVPair&>(msg);
  if (_Internal::MissingRequiredFields(this_._impl_._has_bits_)) {
    return false;
  }
  return true;
}

void KVPair::InternalSwap(KVPair* PROTOBUF_RESTRICT other) {
  using std::swap;
  auto* arena = GetArena();
  ABSL_DCHECK_EQ(arena, other->GetArena());
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.key_, &other->_impl_.key_, arena);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.val_, &other->_impl_.val_, arena);
}

::google::protobuf::Metadata KVPair::GetMetadata() const {
  return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full());
}
// ===================================================================

class HashType::_Internal {
 public:
};

HashType::HashType(::google::protobuf::Arena* arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, _class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:ruby_fuzzer.HashType)
}
inline PROTOBUF_NDEBUG_INLINE HashType::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena,
    const Impl_& from, const ::ruby_fuzzer::HashType& from_msg)
      : keyval_{visibility, arena, from.keyval_},
        _cached_size_{0} {}

HashType::HashType(
    ::google::protobuf::Arena* arena,
    const HashType& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, _class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  HashType* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);

  // @@protoc_insertion_point(copy_constructor:ruby_fuzzer.HashType)
}
inline PROTOBUF_NDEBUG_INLINE HashType::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility,
    ::google::protobuf::Arena* arena)
      : keyval_{visibility, arena},
        _cached_size_{0} {}

inline void HashType::SharedCtor(::_pb::Arena* arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
}
HashType::~HashType() {
  // @@protoc_insertion_point(destructor:ruby_fuzzer.HashType)
  SharedDtor(*this);
}
inline void HashType::SharedDtor(MessageLite& self) {
  HashType& this_ = static_cast<HashType&>(self);
  this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  this_._impl_.~Impl_();
}

inline void* HashType::PlacementNew_(const void*, void* mem,
                                        ::google::protobuf::Arena* arena) {
  return ::new (mem) HashType(arena);
}
constexpr auto HashType::InternalNewImpl_() {
  constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({
      PROTOBUF_FIELD_OFFSET(HashType, _impl_.keyval_) +
          decltype(HashType::_impl_.keyval_)::
              InternalGetArenaOffset(
                  ::google::protobuf::Message::internal_visibility()),
  });
  if (arena_bits.has_value()) {
    return ::google::protobuf::internal::MessageCreator::ZeroInit(
        sizeof(HashType), alignof(HashType), *arena_bits);
  } else {
    return ::google::protobuf::internal::MessageCreator(&HashType::PlacementNew_,
                                 sizeof(HashType),
                                 alignof(HashType));
  }
}
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataFull HashType::_class_data_ = {
    ::google::protobuf::internal::ClassData{
        &_HashType_default_instance_._instance,
        &_table_.header,
        nullptr,  // OnDemandRegisterArenaDtor
        HashType::IsInitializedImpl,
        &HashType::MergeImpl,
        ::google::protobuf::Message::GetNewImpl<HashType>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
        &HashType::SharedDtor,
        ::google::protobuf::Message::GetClearImpl<HashType>(), &HashType::ByteSizeLong,
            &HashType::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
        PROTOBUF_FIELD_OFFSET(HashType, _impl_._cached_size_),
        false,
    },
    &HashType::kDescriptorMethods,
    &descriptor_table_ruby_2eproto,
    nullptr,  // tracker
};
const ::google::protobuf::internal::ClassData* HashType::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_);
  ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table);
  return _class_data_.base();
}
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::_pbi::TcParseTable<0, 1, 1, 0, 2> HashType::_table_ = {
  {
    0,  // no _has_bits_
    0, // no _extensions_
    1, 0,  // max_field_number, fast_idx_mask
    offsetof(decltype(_table_), field_lookup_table),
    4294967294,  // skipmap
    offsetof(decltype(_table_), field_entries),
    1,  // num_field_entries
    1,  // num_aux_entries
    offsetof(decltype(_table_), aux_entries),
    _class_data_.base(),
    nullptr,  // post_loop_handler
    ::_pbi::TcParser::GenericFallback,  // fallback
    #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
    ::_pbi::TcParser::GetTable<::ruby_fuzzer::HashType>(),  // to_prefetch
    #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
  }, {{
    // repeated .ruby_fuzzer.KVPair keyval = 1;
    {::_pbi::TcParser::FastMtR1,
     {10, 63, 0, PROTOBUF_FIELD_OFFSET(HashType, _impl_.keyval_)}},
  }}, {{
    65535, 65535
  }}, {{
    // repeated .ruby_fuzzer.KVPair keyval = 1;
    {PROTOBUF_FIELD_OFFSET(HashType, _impl_.keyval_), 0, 0,
    (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)},
  }}, {{
    {::_pbi::TcParser::GetTable<::ruby_fuzzer::KVPair>()},
  }}, {{
  }},
};

PROTOBUF_NOINLINE void HashType::Clear() {
// @@protoc_insertion_point(message_clear_start:ruby_fuzzer.HashType)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.keyval_.Clear();
  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
        ::uint8_t* HashType::_InternalSerialize(
            const MessageLite& base, ::uint8_t* target,
            ::google::protobuf::io::EpsCopyOutputStream* stream) {
          const HashType& this_ = static_cast<const HashType&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
        ::uint8_t* HashType::_InternalSerialize(
            ::uint8_t* target,
            ::google::protobuf::io::EpsCopyOutputStream* stream) const {
          const HashType& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
          // @@protoc_insertion_point(serialize_to_array_start:ruby_fuzzer.HashType)
          ::uint32_t cached_has_bits = 0;
          (void)cached_has_bits;

          // repeated .ruby_fuzzer.KVPair keyval = 1;
          for (unsigned i = 0, n = static_cast<unsigned>(
                                   this_._internal_keyval_size());
               i < n; i++) {
            const auto& repfield = this_._internal_keyval().Get(i);
            target =
                ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
                    1, repfield, repfield.GetCachedSize(),
                    target, stream);
          }

          if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
            target =
                ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
                    this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
          }
          // @@protoc_insertion_point(serialize_to_array_end:ruby_fuzzer.HashType)
          return target;
        }

#if defined(PROTOBUF_CUSTOM_VTABLE)
        ::size_t HashType::ByteSizeLong(const MessageLite& base) {
          const HashType& this_ = static_cast<const HashType&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
        ::size_t HashType::ByteSizeLong() const {
          const HashType& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
          // @@protoc_insertion_point(message_byte_size_start:ruby_fuzzer.HashType)
          ::size_t total_size = 0;

          ::uint32_t cached_has_bits = 0;
          // Prevent compiler warnings about cached_has_bits being unused
          (void)cached_has_bits;

          ::_pbi::Prefetch5LinesFrom7Lines(&this_);
           {
            // repeated .ruby_fuzzer.KVPair keyval = 1;
            {
              total_size += 1UL * this_._internal_keyval_size();
              for (const auto& msg : this_._internal_keyval()) {
                total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg);
              }
            }
          }
          return this_.MaybeComputeUnknownFieldsSize(total_size,
                                                     &this_._impl_._cached_size_);
        }

void HashType::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) {
  auto* const _this = static_cast<HashType*>(&to_msg);
  auto& from = static_cast<const HashType&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:ruby_fuzzer.HashType)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_internal_mutable_keyval()->MergeFrom(
      from._internal_keyval());
  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_);
}

void HashType::CopyFrom(const HashType& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:ruby_fuzzer.HashType)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

PROTOBUF_NOINLINE bool HashType::IsInitializedImpl(
    const MessageLite& msg) {
  auto& this_ = static_cast<const HashType&>(msg);
  if (!::google::protobuf::internal::AllAreInitialized(this_._internal_keyval()))
    return false;
  return true;
}

void HashType::InternalSwap(HashType* PROTOBUF_RESTRICT other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  _impl_.keyval_.InternalSwap(&other->_impl_.keyval_);
}

::google::protobuf::Metadata HashType::GetMetadata() const {
  return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full());
}
// ===================================================================

class StringExtNoArg::_Internal {
 public:
  using HasBits =
      decltype(std::declval<StringExtNoArg>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(StringExtNoArg, _impl_._has_bits_);
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000003) ^ 0x00000003) != 0;
  }
};

StringExtNoArg::StringExtNoArg(::google::protobuf::Arena* arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, _class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:ruby_fuzzer.StringExtNoArg)
}
inline PROTOBUF_NDEBUG_INLINE StringExtNoArg::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena,
    const Impl_& from, const ::ruby_fuzzer::StringExtNoArg& from_msg)
      : _has_bits_{from._has_bits_},
        _cached_size_{0},
        str_arg_(arena, from.str_arg_) {}

StringExtNoArg::StringExtNoArg(
    ::google::protobuf::Arena* arena,
    const StringExtNoArg& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, _class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  StringExtNoArg* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);
  _impl_.str_op_ = from._impl_.str_op_;

  // @@protoc_insertion_point(copy_constructor:ruby_fuzzer.StringExtNoArg)
}
inline PROTOBUF_NDEBUG_INLINE StringExtNoArg::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility,
    ::google::protobuf::Arena* arena)
      : _cached_size_{0},
        str_arg_(arena) {}

inline void StringExtNoArg::SharedCtor(::_pb::Arena* arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  _impl_.str_op_ = {};
}
StringExtNoArg::~StringExtNoArg() {
  // @@protoc_insertion_point(destructor:ruby_fuzzer.StringExtNoArg)
  SharedDtor(*this);
}
inline void StringExtNoArg::SharedDtor(MessageLite& self) {
  StringExtNoArg& this_ = static_cast<StringExtNoArg&>(self);
  this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  this_._impl_.str_arg_.Destroy();
  this_._impl_.~Impl_();
}

inline void* StringExtNoArg::PlacementNew_(const void*, void* mem,
                                        ::google::protobuf::Arena* arena) {
  return ::new (mem) StringExtNoArg(arena);
}
constexpr auto StringExtNoArg::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(StringExtNoArg),
                                            alignof(StringExtNoArg));
}
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataFull StringExtNoArg::_class_data_ = {
    ::google::protobuf::internal::ClassData{
        &_StringExtNoArg_default_instance_._instance,
        &_table_.header,
        nullptr,  // OnDemandRegisterArenaDtor
        StringExtNoArg::IsInitializedImpl,
        &StringExtNoArg::MergeImpl,
        ::google::protobuf::Message::GetNewImpl<StringExtNoArg>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
        &StringExtNoArg::SharedDtor,
        ::google::protobuf::Message::GetClearImpl<StringExtNoArg>(), &StringExtNoArg::ByteSizeLong,
            &StringExtNoArg::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
        PROTOBUF_FIELD_OFFSET(StringExtNoArg, _impl_._cached_size_),
        false,
    },
    &StringExtNoArg::kDescriptorMethods,
    &descriptor_table_ruby_2eproto,
    nullptr,  // tracker
};
const ::google::protobuf::internal::ClassData* StringExtNoArg::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_);
  ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table);
  return _class_data_.base();
}
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::_pbi::TcParseTable<1, 2, 1, 42, 2> StringExtNoArg::_table_ = {
  {
    PROTOBUF_FIELD_OFFSET(StringExtNoArg, _impl_._has_bits_),
    0, // no _extensions_
    2, 8,  // max_field_number, fast_idx_mask
    offsetof(decltype(_table_), field_lookup_table),
    4294967292,  // skipmap
    offsetof(decltype(_table_), field_entries),
    2,  // num_field_entries
    1,  // num_aux_entries
    offsetof(decltype(_table_), aux_entries),
    _class_data_.base(),
    nullptr,  // post_loop_handler
    ::_pbi::TcParser::GenericFallback,  // fallback
    #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
    ::_pbi::TcParser::GetTable<::ruby_fuzzer::StringExtNoArg>(),  // to_prefetch
    #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
  }, {{
    // required string str_arg = 2;
    {::_pbi::TcParser::FastSS1,
     {18, 0, 0, PROTOBUF_FIELD_OFFSET(StringExtNoArg, _impl_.str_arg_)}},
    // required .ruby_fuzzer.StringExtNoArg.StrExtOp str_op = 1;
    {::_pbi::TcParser::FastEr0S1,
     {8, 1, 9, PROTOBUF_FIELD_OFFSET(StringExtNoArg, _impl_.str_op_)}},
  }}, {{
    65535, 65535
  }}, {{
    // required .ruby_fuzzer.StringExtNoArg.StrExtOp str_op = 1;
    {PROTOBUF_FIELD_OFFSET(StringExtNoArg, _impl_.str_op_), _Internal::kHasBitsOffset + 1, 0,
    (0 | ::_fl::kFcOptional | ::_fl::kEnumRange)},
    // required string str_arg = 2;
    {PROTOBUF_FIELD_OFFSET(StringExtNoArg, _impl_.str_arg_), _Internal::kHasBitsOffset + 0, 0,
    (0 | ::_fl::kFcOptional | ::_fl::kRawString | ::_fl::kRepAString)},
  }}, {{
    {0, 10},
  }}, {{
    "\32\0\7\0\0\0\0\0"
    "ruby_fuzzer.StringExtNoArg"
    "str_arg"
  }},
};

PROTOBUF_NOINLINE void StringExtNoArg::Clear() {
// @@protoc_insertion_point(message_clear_start:ruby_fuzzer.StringExtNoArg)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    _impl_.str_arg_.ClearNonDefaultToEmpty();
  }
  _impl_.str_op_ = 0;
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
        ::uint8_t* StringExtNoArg::_InternalSerialize(
            const MessageLite& base, ::uint8_t* target,
            ::google::protobuf::io::EpsCopyOutputStream* stream) {
          const StringExtNoArg& this_ = static_cast<const StringExtNoArg&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
        ::uint8_t* StringExtNoArg::_InternalSerialize(
            ::uint8_t* target,
            ::google::protobuf::io::EpsCopyOutputStream* stream) const {
          const StringExtNoArg& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
          // @@protoc_insertion_point(serialize_to_array_start:ruby_fuzzer.StringExtNoArg)
          ::uint32_t cached_has_bits = 0;
          (void)cached_has_bits;

          cached_has_bits = this_._impl_._has_bits_[0];
          // required .ruby_fuzzer.StringExtNoArg.StrExtOp str_op = 1;
          if (cached_has_bits & 0x00000002u) {
            target = stream->EnsureSpace(target);
            target = ::_pbi::WireFormatLite::WriteEnumToArray(
                1, this_._internal_str_op(), target);
          }

          // required string str_arg = 2;
          if (cached_has_bits & 0x00000001u) {
            const std::string& _s = this_._internal_str_arg();
            ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(_s.data(), static_cast<int>(_s.length()), ::google::protobuf::internal::WireFormat::SERIALIZE,
                                        "ruby_fuzzer.StringExtNoArg.str_arg");
            target = stream->WriteStringMaybeAliased(2, _s, target);
          }

          if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
            target =
                ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
                    this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
          }
          // @@protoc_insertion_point(serialize_to_array_end:ruby_fuzzer.StringExtNoArg)
          return target;
        }

#if defined(PROTOBUF_CUSTOM_VTABLE)
        ::size_t StringExtNoArg::ByteSizeLong(const MessageLite& base) {
          const StringExtNoArg& this_ = static_cast<const StringExtNoArg&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
        ::size_t StringExtNoArg::ByteSizeLong() const {
          const StringExtNoArg& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
          // @@protoc_insertion_point(message_byte_size_start:ruby_fuzzer.StringExtNoArg)
          ::size_t total_size = 0;

          ::uint32_t cached_has_bits = 0;
          // Prevent compiler warnings about cached_has_bits being unused
          (void)cached_has_bits;

          ::_pbi::Prefetch5LinesFrom7Lines(&this_);
          cached_has_bits = this_._impl_._has_bits_[0];
          if (cached_has_bits & 0x00000003u) {
            // required string str_arg = 2;
            if (cached_has_bits & 0x00000001u) {
              total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize(
                                              this_._internal_str_arg());
            }
            // required .ruby_fuzzer.StringExtNoArg.StrExtOp str_op = 1;
            if (cached_has_bits & 0x00000002u) {
              total_size += 1 +
                            ::_pbi::WireFormatLite::EnumSize(this_._internal_str_op());
            }
          }
          return this_.MaybeComputeUnknownFieldsSize(total_size,
                                                     &this_._impl_._cached_size_);
        }

void StringExtNoArg::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) {
  auto* const _this = static_cast<StringExtNoArg*>(&to_msg);
  auto& from = static_cast<const StringExtNoArg&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:ruby_fuzzer.StringExtNoArg)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _this->_internal_set_str_arg(from._internal_str_arg());
    }
    if (cached_has_bits & 0x00000002u) {
      _this->_impl_.str_op_ = from._impl_.str_op_;
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_);
}

void StringExtNoArg::CopyFrom(const StringExtNoArg& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:ruby_fuzzer.StringExtNoArg)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

PROTOBUF_NOINLINE bool StringExtNoArg::IsInitializedImpl(
    const MessageLite& msg) {
  auto& this_ = static_cast<const StringExtNoArg&>(msg);
  if (_Internal::MissingRequiredFields(this_._impl_._has_bits_)) {
    return false;
  }
  return true;
}

void StringExtNoArg::InternalSwap(StringExtNoArg* PROTOBUF_RESTRICT other) {
  using std::swap;
  auto* arena = GetArena();
  ABSL_DCHECK_EQ(arena, other->GetArena());
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.str_arg_, &other->_impl_.str_arg_, arena);
  swap(_impl_.str_op_, other->_impl_.str_op_);
}

::google::protobuf::Metadata StringExtNoArg::GetMetadata() const {
  return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full());
}
// ===================================================================

class MathConst::_Internal {
 public:
  using HasBits =
      decltype(std::declval<MathConst>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(MathConst, _impl_._has_bits_);
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0;
  }
};

MathConst::MathConst(::google::protobuf::Arena* arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, _class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:ruby_fuzzer.MathConst)
}
MathConst::MathConst(
    ::google::protobuf::Arena* arena, const MathConst& from)
    : MathConst(arena) {
  MergeFrom(from);
}
inline PROTOBUF_NDEBUG_INLINE MathConst::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility,
    ::google::protobuf::Arena* arena)
      : _cached_size_{0} {}

inline void MathConst::SharedCtor(::_pb::Arena* arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  _impl_.math_const_ = {};
}
MathConst::~MathConst() {
  // @@protoc_insertion_point(destructor:ruby_fuzzer.MathConst)
  SharedDtor(*this);
}
inline void MathConst::SharedDtor(MessageLite& self) {
  MathConst& this_ = static_cast<MathConst&>(self);
  this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  this_._impl_.~Impl_();
}

inline void* MathConst::PlacementNew_(const void*, void* mem,
                                        ::google::protobuf::Arena* arena) {
  return ::new (mem) MathConst(arena);
}
constexpr auto MathConst::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(MathConst),
                                            alignof(MathConst));
}
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataFull MathConst::_class_data_ = {
    ::google::protobuf::internal::ClassData{
        &_MathConst_default_instance_._instance,
        &_table_.header,
        nullptr,  // OnDemandRegisterArenaDtor
        MathConst::IsInitializedImpl,
        &MathConst::MergeImpl,
        ::google::protobuf::Message::GetNewImpl<MathConst>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
        &MathConst::SharedDtor,
        ::google::protobuf::Message::GetClearImpl<MathConst>(), &MathConst::ByteSizeLong,
            &MathConst::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
        PROTOBUF_FIELD_OFFSET(MathConst, _impl_._cached_size_),
        false,
    },
    &MathConst::kDescriptorMethods,
    &descriptor_table_ruby_2eproto,
    nullptr,  // tracker
};
const ::google::protobuf::internal::ClassData* MathConst::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_);
  ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table);
  return _class_data_.base();
}
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::_pbi::TcParseTable<0, 1, 1, 0, 2> MathConst::_table_ = {
  {
    PROTOBUF_FIELD_OFFSET(MathConst, _impl_._has_bits_),
    0, // no _extensions_
    1, 0,  // max_field_number, fast_idx_mask
    offsetof(decltype(_table_), field_lookup_table),
    4294967294,  // skipmap
    offsetof(decltype(_table_), field_entries),
    1,  // num_field_entries
    1,  // num_aux_entries
    offsetof(decltype(_table_), aux_entries),
    _class_data_.base(),
    nullptr,  // post_loop_handler
    ::_pbi::TcParser::GenericFallback,  // fallback
    #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
    ::_pbi::TcParser::GetTable<::ruby_fuzzer::MathConst>(),  // to_prefetch
    #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
  }, {{
    // required .ruby_fuzzer.MathConst.MathConstLit math_const = 1;
    {::_pbi::TcParser::FastEr0S1,
     {8, 0, 1, PROTOBUF_FIELD_OFFSET(MathConst, _impl_.math_const_)}},
  }}, {{
    65535, 65535
  }}, {{
    // required .ruby_fuzzer.MathConst.MathConstLit math_const = 1;
    {PROTOBUF_FIELD_OFFSET(MathConst, _impl_.math_const_), _Internal::kHasBitsOffset + 0, 0,
    (0 | ::_fl::kFcOptional | ::_fl::kEnumRange)},
  }}, {{
    {0, 2},
  }}, {{
  }},
};

PROTOBUF_NOINLINE void MathConst::Clear() {
// @@protoc_insertion_point(message_clear_start:ruby_fuzzer.MathConst)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.math_const_ = 0;
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
        ::uint8_t* MathConst::_InternalSerialize(
            const MessageLite& base, ::uint8_t* target,
            ::google::protobuf::io::EpsCopyOutputStream* stream) {
          const MathConst& this_ = static_cast<const MathConst&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
        ::uint8_t* MathConst::_InternalSerialize(
            ::uint8_t* target,
            ::google::protobuf::io::EpsCopyOutputStream* stream) const {
          const MathConst& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
          // @@protoc_insertion_point(serialize_to_array_start:ruby_fuzzer.MathConst)
          ::uint32_t cached_has_bits = 0;
          (void)cached_has_bits;

          cached_has_bits = this_._impl_._has_bits_[0];
          // required .ruby_fuzzer.MathConst.MathConstLit math_const = 1;
          if (cached_has_bits & 0x00000001u) {
            target = stream->EnsureSpace(target);
            target = ::_pbi::WireFormatLite::WriteEnumToArray(
                1, this_._internal_math_const(), target);
          }

          if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
            target =
                ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
                    this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
          }
          // @@protoc_insertion_point(serialize_to_array_end:ruby_fuzzer.MathConst)
          return target;
        }

#if defined(PROTOBUF_CUSTOM_VTABLE)
        ::size_t MathConst::ByteSizeLong(const MessageLite& base) {
          const MathConst& this_ = static_cast<const MathConst&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
        ::size_t MathConst::ByteSizeLong() const {
          const MathConst& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
          // @@protoc_insertion_point(message_byte_size_start:ruby_fuzzer.MathConst)
          ::size_t total_size = 0;

          ::uint32_t cached_has_bits = 0;
          // Prevent compiler warnings about cached_has_bits being unused
          (void)cached_has_bits;

           {
            // required .ruby_fuzzer.MathConst.MathConstLit math_const = 1;
            cached_has_bits = this_._impl_._has_bits_[0];
            if (cached_has_bits & 0x00000001u) {
              total_size += 1 +
                            ::_pbi::WireFormatLite::EnumSize(this_._internal_math_const());
            }
          }
          return this_.MaybeComputeUnknownFieldsSize(total_size,
                                                     &this_._impl_._cached_size_);
        }

void MathConst::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) {
  auto* const _this = static_cast<MathConst*>(&to_msg);
  auto& from = static_cast<const MathConst&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:ruby_fuzzer.MathConst)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    _this->_impl_.math_const_ = from._impl_.math_const_;
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_);
}

void MathConst::CopyFrom(const MathConst& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:ruby_fuzzer.MathConst)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

PROTOBUF_NOINLINE bool MathConst::IsInitializedImpl(
    const MessageLite& msg) {
  auto& this_ = static_cast<const MathConst&>(msg);
  if (_Internal::MissingRequiredFields(this_._impl_._has_bits_)) {
    return false;
  }
  return true;
}

void MathConst::InternalSwap(MathConst* PROTOBUF_RESTRICT other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  swap(_impl_.math_const_, other->_impl_.math_const_);
}

::google::protobuf::Metadata MathConst::GetMetadata() const {
  return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full());
}
// ===================================================================

class Const::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
      PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::Const, _impl_._oneof_case_);
};

Const::Const(::google::protobuf::Arena* arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, _class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:ruby_fuzzer.Const)
}
inline PROTOBUF_NDEBUG_INLINE Const::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena,
    const Impl_& from, const ::ruby_fuzzer::Const& from_msg)
      : const_oneof_{},
        _cached_size_{0},
        _oneof_case_{from._oneof_case_[0]} {}

Const::Const(
    ::google::protobuf::Arena* arena,
    const Const& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, _class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  Const* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);
  switch (const_oneof_case()) {
    case CONST_ONEOF_NOT_SET:
      break;
      case kIntLit:
        _impl_.const_oneof_.int_lit_ = from._impl_.const_oneof_.int_lit_;
        break;
      case kBoolVal:
        _impl_.const_oneof_.bool_val_ = from._impl_.const_oneof_.bool_val_;
        break;
  }

  // @@protoc_insertion_point(copy_constructor:ruby_fuzzer.Const)
}
inline PROTOBUF_NDEBUG_INLINE Const::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility,
    ::google::protobuf::Arena* arena)
      : const_oneof_{},
        _cached_size_{0},
        _oneof_case_{} {}

inline void Const::SharedCtor(::_pb::Arena* arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
}
Const::~Const() {
  // @@protoc_insertion_point(destructor:ruby_fuzzer.Const)
  SharedDtor(*this);
}
inline void Const::SharedDtor(MessageLite& self) {
  Const& this_ = static_cast<Const&>(self);
  this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  if (this_.has_const_oneof()) {
    this_.clear_const_oneof();
  }
  this_._impl_.~Impl_();
}

void Const::clear_const_oneof() {
// @@protoc_insertion_point(one_of_clear_start:ruby_fuzzer.Const)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  switch (const_oneof_case()) {
    case kIntLit: {
      // No need to clear
      break;
    }
    case kBoolVal: {
      // No need to clear
      break;
    }
    case CONST_ONEOF_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = CONST_ONEOF_NOT_SET;
}


inline void* Const::PlacementNew_(const void*, void* mem,
                                        ::google::protobuf::Arena* arena) {
  return ::new (mem) Const(arena);
}
constexpr auto Const::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(Const),
                                            alignof(Const));
}
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataFull Const::_class_data_ = {
    ::google::protobuf::internal::ClassData{
        &_Const_default_instance_._instance,
        &_table_.header,
        nullptr,  // OnDemandRegisterArenaDtor
        nullptr,  // IsInitialized
        &Const::MergeImpl,
        ::google::protobuf::Message::GetNewImpl<Const>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
        &Const::SharedDtor,
        ::google::protobuf::Message::GetClearImpl<Const>(), &Const::ByteSizeLong,
            &Const::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
        PROTOBUF_FIELD_OFFSET(Const, _impl_._cached_size_),
        false,
    },
    &Const::kDescriptorMethods,
    &descriptor_table_ruby_2eproto,
    nullptr,  // tracker
};
const ::google::protobuf::internal::ClassData* Const::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_);
  ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table);
  return _class_data_.base();
}
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::_pbi::TcParseTable<0, 2, 0, 0, 2> Const::_table_ = {
  {
    0,  // no _has_bits_
    0, // no _extensions_
    4, 0,  // max_field_number, fast_idx_mask
    offsetof(decltype(_table_), field_lookup_table),
    4294967286,  // skipmap
    offsetof(decltype(_table_), field_entries),
    2,  // num_field_entries
    0,  // num_aux_entries
    offsetof(decltype(_table_), field_names),  // no aux_entries
    _class_data_.base(),
    nullptr,  // post_loop_handler
    ::_pbi::TcParser::GenericFallback,  // fallback
    #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
    ::_pbi::TcParser::GetTable<::ruby_fuzzer::Const>(),  // to_prefetch
    #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
  }, {{
    {::_pbi::TcParser::MiniParse, {}},
  }}, {{
    65535, 65535
  }}, {{
    // uint32 int_lit = 1;
    {PROTOBUF_FIELD_OFFSET(Const, _impl_.const_oneof_.int_lit_), _Internal::kOneofCaseOffset + 0, 0,
    (0 | ::_fl::kFcOneof | ::_fl::kUInt32)},
    // bool bool_val = 4;
    {PROTOBUF_FIELD_OFFSET(Const, _impl_.const_oneof_.bool_val_), _Internal::kOneofCaseOffset + 0, 0,
    (0 | ::_fl::kFcOneof | ::_fl::kBool)},
  }},
  // no aux_entries
  {{
  }},
};

PROTOBUF_NOINLINE void Const::Clear() {
// @@protoc_insertion_point(message_clear_start:ruby_fuzzer.Const)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_const_oneof();
  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
        ::uint8_t* Const::_InternalSerialize(
            const MessageLite& base, ::uint8_t* target,
            ::google::protobuf::io::EpsCopyOutputStream* stream) {
          const Const& this_ = static_cast<const Const&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
        ::uint8_t* Const::_InternalSerialize(
            ::uint8_t* target,
            ::google::protobuf::io::EpsCopyOutputStream* stream) const {
          const Const& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
          // @@protoc_insertion_point(serialize_to_array_start:ruby_fuzzer.Const)
          ::uint32_t cached_has_bits = 0;
          (void)cached_has_bits;

          switch (this_.const_oneof_case()) {
            case kIntLit: {
              target = stream->EnsureSpace(target);
              target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
                  1, this_._internal_int_lit(), target);
              break;
            }
            case kBoolVal: {
              target = stream->EnsureSpace(target);
              target = ::_pbi::WireFormatLite::WriteBoolToArray(
                  4, this_._internal_bool_val(), target);
              break;
            }
            default:
              break;
          }
          if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
            target =
                ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
                    this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
          }
          // @@protoc_insertion_point(serialize_to_array_end:ruby_fuzzer.Const)
          return target;
        }

#if defined(PROTOBUF_CUSTOM_VTABLE)
        ::size_t Const::ByteSizeLong(const MessageLite& base) {
          const Const& this_ = static_cast<const Const&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
        ::size_t Const::ByteSizeLong() const {
          const Const& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
          // @@protoc_insertion_point(message_byte_size_start:ruby_fuzzer.Const)
          ::size_t total_size = 0;

          ::uint32_t cached_has_bits = 0;
          // Prevent compiler warnings about cached_has_bits being unused
          (void)cached_has_bits;

          switch (this_.const_oneof_case()) {
            // uint32 int_lit = 1;
            case kIntLit: {
              total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
                  this_._internal_int_lit());
              break;
            }
            // bool bool_val = 4;
            case kBoolVal: {
              total_size += 2;
              break;
            }
            case CONST_ONEOF_NOT_SET: {
              break;
            }
          }
          return this_.MaybeComputeUnknownFieldsSize(total_size,
                                                     &this_._impl_._cached_size_);
        }

void Const::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) {
  auto* const _this = static_cast<Const*>(&to_msg);
  auto& from = static_cast<const Const&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:ruby_fuzzer.Const)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (const uint32_t oneof_from_case = from._impl_._oneof_case_[0]) {
    const uint32_t oneof_to_case = _this->_impl_._oneof_case_[0];
    const bool oneof_needs_init = oneof_to_case != oneof_from_case;
    if (oneof_needs_init) {
      if (oneof_to_case != 0) {
        _this->clear_const_oneof();
      }
      _this->_impl_._oneof_case_[0] = oneof_from_case;
    }

    switch (oneof_from_case) {
      case kIntLit: {
        _this->_impl_.const_oneof_.int_lit_ = from._impl_.const_oneof_.int_lit_;
        break;
      }
      case kBoolVal: {
        _this->_impl_.const_oneof_.bool_val_ = from._impl_.const_oneof_.bool_val_;
        break;
      }
      case CONST_ONEOF_NOT_SET:
        break;
    }
  }
  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_);
}

void Const::CopyFrom(const Const& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:ruby_fuzzer.Const)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}


void Const::InternalSwap(Const* PROTOBUF_RESTRICT other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.const_oneof_, other->_impl_.const_oneof_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
}

::google::protobuf::Metadata Const::GetMetadata() const {
  return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full());
}
// ===================================================================

class BinaryOp::_Internal {
 public:
  using HasBits =
      decltype(std::declval<BinaryOp>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(BinaryOp, _impl_._has_bits_);
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000007) ^ 0x00000007) != 0;
  }
};

BinaryOp::BinaryOp(::google::protobuf::Arena* arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, _class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:ruby_fuzzer.BinaryOp)
}
inline PROTOBUF_NDEBUG_INLINE BinaryOp::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena,
    const Impl_& from, const ::ruby_fuzzer::BinaryOp& from_msg)
      : _has_bits_{from._has_bits_},
        _cached_size_{0} {}

BinaryOp::BinaryOp(
    ::google::protobuf::Arena* arena,
    const BinaryOp& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, _class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  BinaryOp* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);
  ::uint32_t cached_has_bits = _impl_._has_bits_[0];
  _impl_.left_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::Rvalue>(
                              arena, *from._impl_.left_)
                        : nullptr;
  _impl_.right_ = (cached_has_bits & 0x00000002u) ? ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::Rvalue>(
                              arena, *from._impl_.right_)
                        : nullptr;
  _impl_.op_ = from._impl_.op_;

  // @@protoc_insertion_point(copy_constructor:ruby_fuzzer.BinaryOp)
}
inline PROTOBUF_NDEBUG_INLINE BinaryOp::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility,
    ::google::protobuf::Arena* arena)
      : _cached_size_{0} {}

inline void BinaryOp::SharedCtor(::_pb::Arena* arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  ::memset(reinterpret_cast<char *>(&_impl_) +
               offsetof(Impl_, left_),
           0,
           offsetof(Impl_, op_) -
               offsetof(Impl_, left_) +
               sizeof(Impl_::op_));
}
BinaryOp::~BinaryOp() {
  // @@protoc_insertion_point(destructor:ruby_fuzzer.BinaryOp)
  SharedDtor(*this);
}
inline void BinaryOp::SharedDtor(MessageLite& self) {
  BinaryOp& this_ = static_cast<BinaryOp&>(self);
  this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  delete this_._impl_.left_;
  delete this_._impl_.right_;
  this_._impl_.~Impl_();
}

inline void* BinaryOp::PlacementNew_(const void*, void* mem,
                                        ::google::protobuf::Arena* arena) {
  return ::new (mem) BinaryOp(arena);
}
constexpr auto BinaryOp::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(BinaryOp),
                                            alignof(BinaryOp));
}
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataFull BinaryOp::_class_data_ = {
    ::google::protobuf::internal::ClassData{
        &_BinaryOp_default_instance_._instance,
        &_table_.header,
        nullptr,  // OnDemandRegisterArenaDtor
        BinaryOp::IsInitializedImpl,
        &BinaryOp::MergeImpl,
        ::google::protobuf::Message::GetNewImpl<BinaryOp>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
        &BinaryOp::SharedDtor,
        ::google::protobuf::Message::GetClearImpl<BinaryOp>(), &BinaryOp::ByteSizeLong,
            &BinaryOp::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
        PROTOBUF_FIELD_OFFSET(BinaryOp, _impl_._cached_size_),
        false,
    },
    &BinaryOp::kDescriptorMethods,
    &descriptor_table_ruby_2eproto,
    nullptr,  // tracker
};
const ::google::protobuf::internal::ClassData* BinaryOp::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_);
  ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table);
  return _class_data_.base();
}
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::_pbi::TcParseTable<2, 3, 3, 0, 2> BinaryOp::_table_ = {
  {
    PROTOBUF_FIELD_OFFSET(BinaryOp, _impl_._has_bits_),
    0, // no _extensions_
    3, 24,  // max_field_number, fast_idx_mask
    offsetof(decltype(_table_), field_lookup_table),
    4294967288,  // skipmap
    offsetof(decltype(_table_), field_entries),
    3,  // num_field_entries
    3,  // num_aux_entries
    offsetof(decltype(_table_), aux_entries),
    _class_data_.base(),
    nullptr,  // post_loop_handler
    ::_pbi::TcParser::GenericFallback,  // fallback
    #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
    ::_pbi::TcParser::GetTable<::ruby_fuzzer::BinaryOp>(),  // to_prefetch
    #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
  }, {{
    {::_pbi::TcParser::MiniParse, {}},
    // required .ruby_fuzzer.BinaryOp.Op op = 1;
    {::_pbi::TcParser::FastEr0S1,
     {8, 2, 14, PROTOBUF_FIELD_OFFSET(BinaryOp, _impl_.op_)}},
    // required .ruby_fuzzer.Rvalue left = 2;
    {::_pbi::TcParser::FastMtS1,
     {18, 0, 0, PROTOBUF_FIELD_OFFSET(BinaryOp, _impl_.left_)}},
    // required .ruby_fuzzer.Rvalue right = 3;
    {::_pbi::TcParser::FastMtS1,
     {26, 1, 1, PROTOBUF_FIELD_OFFSET(BinaryOp, _impl_.right_)}},
  }}, {{
    65535, 65535
  }}, {{
    // required .ruby_fuzzer.BinaryOp.Op op = 1;
    {PROTOBUF_FIELD_OFFSET(BinaryOp, _impl_.op_), _Internal::kHasBitsOffset + 2, 2,
    (0 | ::_fl::kFcOptional | ::_fl::kEnumRange)},
    // required .ruby_fuzzer.Rvalue left = 2;
    {PROTOBUF_FIELD_OFFSET(BinaryOp, _impl_.left_), _Internal::kHasBitsOffset + 0, 0,
    (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
    // required .ruby_fuzzer.Rvalue right = 3;
    {PROTOBUF_FIELD_OFFSET(BinaryOp, _impl_.right_), _Internal::kHasBitsOffset + 1, 1,
    (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
  }}, {{
    {::_pbi::TcParser::GetTable<::ruby_fuzzer::Rvalue>()},
    {::_pbi::TcParser::GetTable<::ruby_fuzzer::Rvalue>()},
    {0, 15},
  }}, {{
  }},
};

PROTOBUF_NOINLINE void BinaryOp::Clear() {
// @@protoc_insertion_point(message_clear_start:ruby_fuzzer.BinaryOp)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      ABSL_DCHECK(_impl_.left_ != nullptr);
      _impl_.left_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      ABSL_DCHECK(_impl_.right_ != nullptr);
      _impl_.right_->Clear();
    }
  }
  _impl_.op_ = 0;
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
        ::uint8_t* BinaryOp::_InternalSerialize(
            const MessageLite& base, ::uint8_t* target,
            ::google::protobuf::io::EpsCopyOutputStream* stream) {
          const BinaryOp& this_ = static_cast<const BinaryOp&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
        ::uint8_t* BinaryOp::_InternalSerialize(
            ::uint8_t* target,
            ::google::protobuf::io::EpsCopyOutputStream* stream) const {
          const BinaryOp& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
          // @@protoc_insertion_point(serialize_to_array_start:ruby_fuzzer.BinaryOp)
          ::uint32_t cached_has_bits = 0;
          (void)cached_has_bits;

          cached_has_bits = this_._impl_._has_bits_[0];
          // required .ruby_fuzzer.BinaryOp.Op op = 1;
          if (cached_has_bits & 0x00000004u) {
            target = stream->EnsureSpace(target);
            target = ::_pbi::WireFormatLite::WriteEnumToArray(
                1, this_._internal_op(), target);
          }

          // required .ruby_fuzzer.Rvalue left = 2;
          if (cached_has_bits & 0x00000001u) {
            target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
                2, *this_._impl_.left_, this_._impl_.left_->GetCachedSize(), target,
                stream);
          }

          // required .ruby_fuzzer.Rvalue right = 3;
          if (cached_has_bits & 0x00000002u) {
            target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
                3, *this_._impl_.right_, this_._impl_.right_->GetCachedSize(), target,
                stream);
          }

          if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
            target =
                ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
                    this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
          }
          // @@protoc_insertion_point(serialize_to_array_end:ruby_fuzzer.BinaryOp)
          return target;
        }

#if defined(PROTOBUF_CUSTOM_VTABLE)
        ::size_t BinaryOp::ByteSizeLong(const MessageLite& base) {
          const BinaryOp& this_ = static_cast<const BinaryOp&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
        ::size_t BinaryOp::ByteSizeLong() const {
          const BinaryOp& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
          // @@protoc_insertion_point(message_byte_size_start:ruby_fuzzer.BinaryOp)
          ::size_t total_size = 0;

          ::uint32_t cached_has_bits = 0;
          // Prevent compiler warnings about cached_has_bits being unused
          (void)cached_has_bits;

          ::_pbi::Prefetch5LinesFrom7Lines(&this_);
          cached_has_bits = this_._impl_._has_bits_[0];
          if (cached_has_bits & 0x00000007u) {
            // required .ruby_fuzzer.Rvalue left = 2;
            if (cached_has_bits & 0x00000001u) {
              total_size += 1 +
                            ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.left_);
            }
            // required .ruby_fuzzer.Rvalue right = 3;
            if (cached_has_bits & 0x00000002u) {
              total_size += 1 +
                            ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.right_);
            }
            // required .ruby_fuzzer.BinaryOp.Op op = 1;
            if (cached_has_bits & 0x00000004u) {
              total_size += 1 +
                            ::_pbi::WireFormatLite::EnumSize(this_._internal_op());
            }
          }
          return this_.MaybeComputeUnknownFieldsSize(total_size,
                                                     &this_._impl_._cached_size_);
        }

void BinaryOp::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) {
  auto* const _this = static_cast<BinaryOp*>(&to_msg);
  auto& from = static_cast<const BinaryOp&>(from_msg);
  ::google::protobuf::Arena* arena = _this->GetArena();
  // @@protoc_insertion_point(class_specific_merge_from_start:ruby_fuzzer.BinaryOp)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      ABSL_DCHECK(from._impl_.left_ != nullptr);
      if (_this->_impl_.left_ == nullptr) {
        _this->_impl_.left_ =
            ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::Rvalue>(arena, *from._impl_.left_);
      } else {
        _this->_impl_.left_->MergeFrom(*from._impl_.left_);
      }
    }
    if (cached_has_bits & 0x00000002u) {
      ABSL_DCHECK(from._impl_.right_ != nullptr);
      if (_this->_impl_.right_ == nullptr) {
        _this->_impl_.right_ =
            ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::Rvalue>(arena, *from._impl_.right_);
      } else {
        _this->_impl_.right_->MergeFrom(*from._impl_.right_);
      }
    }
    if (cached_has_bits & 0x00000004u) {
      _this->_impl_.op_ = from._impl_.op_;
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_);
}

void BinaryOp::CopyFrom(const BinaryOp& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:ruby_fuzzer.BinaryOp)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

PROTOBUF_NOINLINE bool BinaryOp::IsInitializedImpl(
    const MessageLite& msg) {
  auto& this_ = static_cast<const BinaryOp&>(msg);
  if (_Internal::MissingRequiredFields(this_._impl_._has_bits_)) {
    return false;
  }
  if ((this_._impl_._has_bits_[0] & 0x00000001u) != 0) {
    if (!this_._impl_.left_->IsInitialized()) return false;
  }
  if ((this_._impl_._has_bits_[0] & 0x00000002u) != 0) {
    if (!this_._impl_.right_->IsInitialized()) return false;
  }
  return true;
}

void BinaryOp::InternalSwap(BinaryOp* PROTOBUF_RESTRICT other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(BinaryOp, _impl_.op_)
      + sizeof(BinaryOp::_impl_.op_)
      - PROTOBUF_FIELD_OFFSET(BinaryOp, _impl_.left_)>(
          reinterpret_cast<char*>(&_impl_.left_),
          reinterpret_cast<char*>(&other->_impl_.left_));
}

::google::protobuf::Metadata BinaryOp::GetMetadata() const {
  return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full());
}
// ===================================================================

class Rvalue::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
      PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::Rvalue, _impl_._oneof_case_);
};

void Rvalue::set_allocated_varref(::ruby_fuzzer::VarRef* varref) {
  ::google::protobuf::Arena* message_arena = GetArena();
  clear_rvalue_oneof();
  if (varref) {
    ::google::protobuf::Arena* submessage_arena = varref->GetArena();
    if (message_arena != submessage_arena) {
      varref = ::google::protobuf::internal::GetOwnedMessage(message_arena, varref, submessage_arena);
    }
    set_has_varref();
    _impl_.rvalue_oneof_.varref_ = varref;
  }
  // @@protoc_insertion_point(field_set_allocated:ruby_fuzzer.Rvalue.varref)
}
void Rvalue::set_allocated_cons(::ruby_fuzzer::Const* cons) {
  ::google::protobuf::Arena* message_arena = GetArena();
  clear_rvalue_oneof();
  if (cons) {
    ::google::protobuf::Arena* submessage_arena = cons->GetArena();
    if (message_arena != submessage_arena) {
      cons = ::google::protobuf::internal::GetOwnedMessage(message_arena, cons, submessage_arena);
    }
    set_has_cons();
    _impl_.rvalue_oneof_.cons_ = cons;
  }
  // @@protoc_insertion_point(field_set_allocated:ruby_fuzzer.Rvalue.cons)
}
void Rvalue::set_allocated_binop(::ruby_fuzzer::BinaryOp* binop) {
  ::google::protobuf::Arena* message_arena = GetArena();
  clear_rvalue_oneof();
  if (binop) {
    ::google::protobuf::Arena* submessage_arena = binop->GetArena();
    if (message_arena != submessage_arena) {
      binop = ::google::protobuf::internal::GetOwnedMessage(message_arena, binop, submessage_arena);
    }
    set_has_binop();
    _impl_.rvalue_oneof_.binop_ = binop;
  }
  // @@protoc_insertion_point(field_set_allocated:ruby_fuzzer.Rvalue.binop)
}
Rvalue::Rvalue(::google::protobuf::Arena* arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, _class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:ruby_fuzzer.Rvalue)
}
inline PROTOBUF_NDEBUG_INLINE Rvalue::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena,
    const Impl_& from, const ::ruby_fuzzer::Rvalue& from_msg)
      : rvalue_oneof_{},
        _cached_size_{0},
        _oneof_case_{from._oneof_case_[0]} {}

Rvalue::Rvalue(
    ::google::protobuf::Arena* arena,
    const Rvalue& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, _class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  Rvalue* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);
  switch (rvalue_oneof_case()) {
    case RVALUE_ONEOF_NOT_SET:
      break;
      case kVarref:
        _impl_.rvalue_oneof_.varref_ = ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::VarRef>(arena, *from._impl_.rvalue_oneof_.varref_);
        break;
      case kCons:
        _impl_.rvalue_oneof_.cons_ = ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::Const>(arena, *from._impl_.rvalue_oneof_.cons_);
        break;
      case kBinop:
        _impl_.rvalue_oneof_.binop_ = ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::BinaryOp>(arena, *from._impl_.rvalue_oneof_.binop_);
        break;
  }

  // @@protoc_insertion_point(copy_constructor:ruby_fuzzer.Rvalue)
}
inline PROTOBUF_NDEBUG_INLINE Rvalue::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility,
    ::google::protobuf::Arena* arena)
      : rvalue_oneof_{},
        _cached_size_{0},
        _oneof_case_{} {}

inline void Rvalue::SharedCtor(::_pb::Arena* arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
}
Rvalue::~Rvalue() {
  // @@protoc_insertion_point(destructor:ruby_fuzzer.Rvalue)
  SharedDtor(*this);
}
inline void Rvalue::SharedDtor(MessageLite& self) {
  Rvalue& this_ = static_cast<Rvalue&>(self);
  this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  if (this_.has_rvalue_oneof()) {
    this_.clear_rvalue_oneof();
  }
  this_._impl_.~Impl_();
}

void Rvalue::clear_rvalue_oneof() {
// @@protoc_insertion_point(one_of_clear_start:ruby_fuzzer.Rvalue)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  switch (rvalue_oneof_case()) {
    case kVarref: {
      if (GetArena() == nullptr) {
        delete _impl_.rvalue_oneof_.varref_;
      } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
        ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.rvalue_oneof_.varref_);
      }
      break;
    }
    case kCons: {
      if (GetArena() == nullptr) {
        delete _impl_.rvalue_oneof_.cons_;
      } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
        ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.rvalue_oneof_.cons_);
      }
      break;
    }
    case kBinop: {
      if (GetArena() == nullptr) {
        delete _impl_.rvalue_oneof_.binop_;
      } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
        ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.rvalue_oneof_.binop_);
      }
      break;
    }
    case RVALUE_ONEOF_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = RVALUE_ONEOF_NOT_SET;
}


inline void* Rvalue::PlacementNew_(const void*, void* mem,
                                        ::google::protobuf::Arena* arena) {
  return ::new (mem) Rvalue(arena);
}
constexpr auto Rvalue::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(Rvalue),
                                            alignof(Rvalue));
}
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataFull Rvalue::_class_data_ = {
    ::google::protobuf::internal::ClassData{
        &_Rvalue_default_instance_._instance,
        &_table_.header,
        nullptr,  // OnDemandRegisterArenaDtor
        Rvalue::IsInitializedImpl,
        &Rvalue::MergeImpl,
        ::google::protobuf::Message::GetNewImpl<Rvalue>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
        &Rvalue::SharedDtor,
        ::google::protobuf::Message::GetClearImpl<Rvalue>(), &Rvalue::ByteSizeLong,
            &Rvalue::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
        PROTOBUF_FIELD_OFFSET(Rvalue, _impl_._cached_size_),
        false,
    },
    &Rvalue::kDescriptorMethods,
    &descriptor_table_ruby_2eproto,
    nullptr,  // tracker
};
const ::google::protobuf::internal::ClassData* Rvalue::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_);
  ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table);
  return _class_data_.base();
}
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::_pbi::TcParseTable<0, 3, 3, 0, 2> Rvalue::_table_ = {
  {
    0,  // no _has_bits_
    0, // no _extensions_
    3, 0,  // max_field_number, fast_idx_mask
    offsetof(decltype(_table_), field_lookup_table),
    4294967288,  // skipmap
    offsetof(decltype(_table_), field_entries),
    3,  // num_field_entries
    3,  // num_aux_entries
    offsetof(decltype(_table_), aux_entries),
    _class_data_.base(),
    nullptr,  // post_loop_handler
    ::_pbi::TcParser::GenericFallback,  // fallback
    #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
    ::_pbi::TcParser::GetTable<::ruby_fuzzer::Rvalue>(),  // to_prefetch
    #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
  }, {{
    {::_pbi::TcParser::MiniParse, {}},
  }}, {{
    65535, 65535
  }}, {{
    // .ruby_fuzzer.VarRef varref = 1;
    {PROTOBUF_FIELD_OFFSET(Rvalue, _impl_.rvalue_oneof_.varref_), _Internal::kOneofCaseOffset + 0, 0,
    (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)},
    // .ruby_fuzzer.Const cons = 2;
    {PROTOBUF_FIELD_OFFSET(Rvalue, _impl_.rvalue_oneof_.cons_), _Internal::kOneofCaseOffset + 0, 1,
    (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)},
    // .ruby_fuzzer.BinaryOp binop = 3;
    {PROTOBUF_FIELD_OFFSET(Rvalue, _impl_.rvalue_oneof_.binop_), _Internal::kOneofCaseOffset + 0, 2,
    (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)},
  }}, {{
    {::_pbi::TcParser::GetTable<::ruby_fuzzer::VarRef>()},
    {::_pbi::TcParser::GetTable<::ruby_fuzzer::Const>()},
    {::_pbi::TcParser::GetTable<::ruby_fuzzer::BinaryOp>()},
  }}, {{
  }},
};

PROTOBUF_NOINLINE void Rvalue::Clear() {
// @@protoc_insertion_point(message_clear_start:ruby_fuzzer.Rvalue)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_rvalue_oneof();
  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
        ::uint8_t* Rvalue::_InternalSerialize(
            const MessageLite& base, ::uint8_t* target,
            ::google::protobuf::io::EpsCopyOutputStream* stream) {
          const Rvalue& this_ = static_cast<const Rvalue&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
        ::uint8_t* Rvalue::_InternalSerialize(
            ::uint8_t* target,
            ::google::protobuf::io::EpsCopyOutputStream* stream) const {
          const Rvalue& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
          // @@protoc_insertion_point(serialize_to_array_start:ruby_fuzzer.Rvalue)
          ::uint32_t cached_has_bits = 0;
          (void)cached_has_bits;

          switch (this_.rvalue_oneof_case()) {
            case kVarref: {
              target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
                  1, *this_._impl_.rvalue_oneof_.varref_, this_._impl_.rvalue_oneof_.varref_->GetCachedSize(), target,
                  stream);
              break;
            }
            case kCons: {
              target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
                  2, *this_._impl_.rvalue_oneof_.cons_, this_._impl_.rvalue_oneof_.cons_->GetCachedSize(), target,
                  stream);
              break;
            }
            case kBinop: {
              target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
                  3, *this_._impl_.rvalue_oneof_.binop_, this_._impl_.rvalue_oneof_.binop_->GetCachedSize(), target,
                  stream);
              break;
            }
            default:
              break;
          }
          if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
            target =
                ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
                    this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
          }
          // @@protoc_insertion_point(serialize_to_array_end:ruby_fuzzer.Rvalue)
          return target;
        }

#if defined(PROTOBUF_CUSTOM_VTABLE)
        ::size_t Rvalue::ByteSizeLong(const MessageLite& base) {
          const Rvalue& this_ = static_cast<const Rvalue&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
        ::size_t Rvalue::ByteSizeLong() const {
          const Rvalue& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
          // @@protoc_insertion_point(message_byte_size_start:ruby_fuzzer.Rvalue)
          ::size_t total_size = 0;

          ::uint32_t cached_has_bits = 0;
          // Prevent compiler warnings about cached_has_bits being unused
          (void)cached_has_bits;

          switch (this_.rvalue_oneof_case()) {
            // .ruby_fuzzer.VarRef varref = 1;
            case kVarref: {
              total_size += 1 +
                            ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.rvalue_oneof_.varref_);
              break;
            }
            // .ruby_fuzzer.Const cons = 2;
            case kCons: {
              total_size += 1 +
                            ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.rvalue_oneof_.cons_);
              break;
            }
            // .ruby_fuzzer.BinaryOp binop = 3;
            case kBinop: {
              total_size += 1 +
                            ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.rvalue_oneof_.binop_);
              break;
            }
            case RVALUE_ONEOF_NOT_SET: {
              break;
            }
          }
          return this_.MaybeComputeUnknownFieldsSize(total_size,
                                                     &this_._impl_._cached_size_);
        }

void Rvalue::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) {
  auto* const _this = static_cast<Rvalue*>(&to_msg);
  auto& from = static_cast<const Rvalue&>(from_msg);
  ::google::protobuf::Arena* arena = _this->GetArena();
  // @@protoc_insertion_point(class_specific_merge_from_start:ruby_fuzzer.Rvalue)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (const uint32_t oneof_from_case = from._impl_._oneof_case_[0]) {
    const uint32_t oneof_to_case = _this->_impl_._oneof_case_[0];
    const bool oneof_needs_init = oneof_to_case != oneof_from_case;
    if (oneof_needs_init) {
      if (oneof_to_case != 0) {
        _this->clear_rvalue_oneof();
      }
      _this->_impl_._oneof_case_[0] = oneof_from_case;
    }

    switch (oneof_from_case) {
      case kVarref: {
        if (oneof_needs_init) {
          _this->_impl_.rvalue_oneof_.varref_ =
              ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::VarRef>(arena, *from._impl_.rvalue_oneof_.varref_);
        } else {
          _this->_impl_.rvalue_oneof_.varref_->MergeFrom(from._internal_varref());
        }
        break;
      }
      case kCons: {
        if (oneof_needs_init) {
          _this->_impl_.rvalue_oneof_.cons_ =
              ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::Const>(arena, *from._impl_.rvalue_oneof_.cons_);
        } else {
          _this->_impl_.rvalue_oneof_.cons_->MergeFrom(from._internal_cons());
        }
        break;
      }
      case kBinop: {
        if (oneof_needs_init) {
          _this->_impl_.rvalue_oneof_.binop_ =
              ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::BinaryOp>(arena, *from._impl_.rvalue_oneof_.binop_);
        } else {
          _this->_impl_.rvalue_oneof_.binop_->MergeFrom(from._internal_binop());
        }
        break;
      }
      case RVALUE_ONEOF_NOT_SET:
        break;
    }
  }
  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_);
}

void Rvalue::CopyFrom(const Rvalue& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:ruby_fuzzer.Rvalue)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

PROTOBUF_NOINLINE bool Rvalue::IsInitializedImpl(
    const MessageLite& msg) {
  auto& this_ = static_cast<const Rvalue&>(msg);
  switch (this_.rvalue_oneof_case()) {
    case kVarref: {
      if (this_.rvalue_oneof_case() == kVarref && !this_._impl_.rvalue_oneof_.varref_->IsInitialized())
        return false;
      break;
    }
    case kCons: {
      break;
    }
    case kBinop: {
      if (this_.rvalue_oneof_case() == kBinop && !this_._impl_.rvalue_oneof_.binop_->IsInitialized())
        return false;
      break;
    }
    case RVALUE_ONEOF_NOT_SET: {
      break;
    }
  }
  return true;
}

void Rvalue::InternalSwap(Rvalue* PROTOBUF_RESTRICT other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.rvalue_oneof_, other->_impl_.rvalue_oneof_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
}

::google::protobuf::Metadata Rvalue::GetMetadata() const {
  return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full());
}
// ===================================================================

class AssignmentStatement::_Internal {
 public:
  using HasBits =
      decltype(std::declval<AssignmentStatement>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(AssignmentStatement, _impl_._has_bits_);
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0;
  }
};

AssignmentStatement::AssignmentStatement(::google::protobuf::Arena* arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, _class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:ruby_fuzzer.AssignmentStatement)
}
inline PROTOBUF_NDEBUG_INLINE AssignmentStatement::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena,
    const Impl_& from, const ::ruby_fuzzer::AssignmentStatement& from_msg)
      : _has_bits_{from._has_bits_},
        _cached_size_{0} {}

AssignmentStatement::AssignmentStatement(
    ::google::protobuf::Arena* arena,
    const AssignmentStatement& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, _class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  AssignmentStatement* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);
  ::uint32_t cached_has_bits = _impl_._has_bits_[0];
  _impl_.rvalue_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::Rvalue>(
                              arena, *from._impl_.rvalue_)
                        : nullptr;

  // @@protoc_insertion_point(copy_constructor:ruby_fuzzer.AssignmentStatement)
}
inline PROTOBUF_NDEBUG_INLINE AssignmentStatement::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility,
    ::google::protobuf::Arena* arena)
      : _cached_size_{0} {}

inline void AssignmentStatement::SharedCtor(::_pb::Arena* arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  _impl_.rvalue_ = {};
}
AssignmentStatement::~AssignmentStatement() {
  // @@protoc_insertion_point(destructor:ruby_fuzzer.AssignmentStatement)
  SharedDtor(*this);
}
inline void AssignmentStatement::SharedDtor(MessageLite& self) {
  AssignmentStatement& this_ = static_cast<AssignmentStatement&>(self);
  this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  delete this_._impl_.rvalue_;
  this_._impl_.~Impl_();
}

inline void* AssignmentStatement::PlacementNew_(const void*, void* mem,
                                        ::google::protobuf::Arena* arena) {
  return ::new (mem) AssignmentStatement(arena);
}
constexpr auto AssignmentStatement::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(AssignmentStatement),
                                            alignof(AssignmentStatement));
}
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataFull AssignmentStatement::_class_data_ = {
    ::google::protobuf::internal::ClassData{
        &_AssignmentStatement_default_instance_._instance,
        &_table_.header,
        nullptr,  // OnDemandRegisterArenaDtor
        AssignmentStatement::IsInitializedImpl,
        &AssignmentStatement::MergeImpl,
        ::google::protobuf::Message::GetNewImpl<AssignmentStatement>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
        &AssignmentStatement::SharedDtor,
        ::google::protobuf::Message::GetClearImpl<AssignmentStatement>(), &AssignmentStatement::ByteSizeLong,
            &AssignmentStatement::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
        PROTOBUF_FIELD_OFFSET(AssignmentStatement, _impl_._cached_size_),
        false,
    },
    &AssignmentStatement::kDescriptorMethods,
    &descriptor_table_ruby_2eproto,
    nullptr,  // tracker
};
const ::google::protobuf::internal::ClassData* AssignmentStatement::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_);
  ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table);
  return _class_data_.base();
}
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::_pbi::TcParseTable<0, 1, 1, 0, 2> AssignmentStatement::_table_ = {
  {
    PROTOBUF_FIELD_OFFSET(AssignmentStatement, _impl_._has_bits_),
    0, // no _extensions_
    2, 0,  // max_field_number, fast_idx_mask
    offsetof(decltype(_table_), field_lookup_table),
    4294967293,  // skipmap
    offsetof(decltype(_table_), field_entries),
    1,  // num_field_entries
    1,  // num_aux_entries
    offsetof(decltype(_table_), aux_entries),
    _class_data_.base(),
    nullptr,  // post_loop_handler
    ::_pbi::TcParser::GenericFallback,  // fallback
    #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
    ::_pbi::TcParser::GetTable<::ruby_fuzzer::AssignmentStatement>(),  // to_prefetch
    #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
  }, {{
    // required .ruby_fuzzer.Rvalue rvalue = 2;
    {::_pbi::TcParser::FastMtS1,
     {18, 0, 0, PROTOBUF_FIELD_OFFSET(AssignmentStatement, _impl_.rvalue_)}},
  }}, {{
    65535, 65535
  }}, {{
    // required .ruby_fuzzer.Rvalue rvalue = 2;
    {PROTOBUF_FIELD_OFFSET(AssignmentStatement, _impl_.rvalue_), _Internal::kHasBitsOffset + 0, 0,
    (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
  }}, {{
    {::_pbi::TcParser::GetTable<::ruby_fuzzer::Rvalue>()},
  }}, {{
  }},
};

PROTOBUF_NOINLINE void AssignmentStatement::Clear() {
// @@protoc_insertion_point(message_clear_start:ruby_fuzzer.AssignmentStatement)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    ABSL_DCHECK(_impl_.rvalue_ != nullptr);
    _impl_.rvalue_->Clear();
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
        ::uint8_t* AssignmentStatement::_InternalSerialize(
            const MessageLite& base, ::uint8_t* target,
            ::google::protobuf::io::EpsCopyOutputStream* stream) {
          const AssignmentStatement& this_ = static_cast<const AssignmentStatement&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
        ::uint8_t* AssignmentStatement::_InternalSerialize(
            ::uint8_t* target,
            ::google::protobuf::io::EpsCopyOutputStream* stream) const {
          const AssignmentStatement& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
          // @@protoc_insertion_point(serialize_to_array_start:ruby_fuzzer.AssignmentStatement)
          ::uint32_t cached_has_bits = 0;
          (void)cached_has_bits;

          cached_has_bits = this_._impl_._has_bits_[0];
          // required .ruby_fuzzer.Rvalue rvalue = 2;
          if (cached_has_bits & 0x00000001u) {
            target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
                2, *this_._impl_.rvalue_, this_._impl_.rvalue_->GetCachedSize(), target,
                stream);
          }

          if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
            target =
                ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
                    this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
          }
          // @@protoc_insertion_point(serialize_to_array_end:ruby_fuzzer.AssignmentStatement)
          return target;
        }

#if defined(PROTOBUF_CUSTOM_VTABLE)
        ::size_t AssignmentStatement::ByteSizeLong(const MessageLite& base) {
          const AssignmentStatement& this_ = static_cast<const AssignmentStatement&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
        ::size_t AssignmentStatement::ByteSizeLong() const {
          const AssignmentStatement& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
          // @@protoc_insertion_point(message_byte_size_start:ruby_fuzzer.AssignmentStatement)
          ::size_t total_size = 0;

          ::uint32_t cached_has_bits = 0;
          // Prevent compiler warnings about cached_has_bits being unused
          (void)cached_has_bits;

           {
            // required .ruby_fuzzer.Rvalue rvalue = 2;
            cached_has_bits = this_._impl_._has_bits_[0];
            if (cached_has_bits & 0x00000001u) {
              total_size += 1 +
                            ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.rvalue_);
            }
          }
          return this_.MaybeComputeUnknownFieldsSize(total_size,
                                                     &this_._impl_._cached_size_);
        }

void AssignmentStatement::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) {
  auto* const _this = static_cast<AssignmentStatement*>(&to_msg);
  auto& from = static_cast<const AssignmentStatement&>(from_msg);
  ::google::protobuf::Arena* arena = _this->GetArena();
  // @@protoc_insertion_point(class_specific_merge_from_start:ruby_fuzzer.AssignmentStatement)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    ABSL_DCHECK(from._impl_.rvalue_ != nullptr);
    if (_this->_impl_.rvalue_ == nullptr) {
      _this->_impl_.rvalue_ =
          ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::Rvalue>(arena, *from._impl_.rvalue_);
    } else {
      _this->_impl_.rvalue_->MergeFrom(*from._impl_.rvalue_);
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_);
}

void AssignmentStatement::CopyFrom(const AssignmentStatement& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:ruby_fuzzer.AssignmentStatement)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

PROTOBUF_NOINLINE bool AssignmentStatement::IsInitializedImpl(
    const MessageLite& msg) {
  auto& this_ = static_cast<const AssignmentStatement&>(msg);
  if (_Internal::MissingRequiredFields(this_._impl_._has_bits_)) {
    return false;
  }
  if ((this_._impl_._has_bits_[0] & 0x00000001u) != 0) {
    if (!this_._impl_.rvalue_->IsInitialized()) return false;
  }
  return true;
}

void AssignmentStatement::InternalSwap(AssignmentStatement* PROTOBUF_RESTRICT other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  swap(_impl_.rvalue_, other->_impl_.rvalue_);
}

::google::protobuf::Metadata AssignmentStatement::GetMetadata() const {
  return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full());
}
// ===================================================================

class IfElse::_Internal {
 public:
  using HasBits =
      decltype(std::declval<IfElse>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(IfElse, _impl_._has_bits_);
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000007) ^ 0x00000007) != 0;
  }
};

IfElse::IfElse(::google::protobuf::Arena* arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, _class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:ruby_fuzzer.IfElse)
}
inline PROTOBUF_NDEBUG_INLINE IfElse::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena,
    const Impl_& from, const ::ruby_fuzzer::IfElse& from_msg)
      : _has_bits_{from._has_bits_},
        _cached_size_{0} {}

IfElse::IfElse(
    ::google::protobuf::Arena* arena,
    const IfElse& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, _class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  IfElse* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);
  ::uint32_t cached_has_bits = _impl_._has_bits_[0];
  _impl_.cond_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::Rvalue>(
                              arena, *from._impl_.cond_)
                        : nullptr;
  _impl_.if_body_ = (cached_has_bits & 0x00000002u) ? ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::StatementSeq>(
                              arena, *from._impl_.if_body_)
                        : nullptr;
  _impl_.else_body_ = (cached_has_bits & 0x00000004u) ? ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::StatementSeq>(
                              arena, *from._impl_.else_body_)
                        : nullptr;

  // @@protoc_insertion_point(copy_constructor:ruby_fuzzer.IfElse)
}
inline PROTOBUF_NDEBUG_INLINE IfElse::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility,
    ::google::protobuf::Arena* arena)
      : _cached_size_{0} {}

inline void IfElse::SharedCtor(::_pb::Arena* arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  ::memset(reinterpret_cast<char *>(&_impl_) +
               offsetof(Impl_, cond_),
           0,
           offsetof(Impl_, else_body_) -
               offsetof(Impl_, cond_) +
               sizeof(Impl_::else_body_));
}
IfElse::~IfElse() {
  // @@protoc_insertion_point(destructor:ruby_fuzzer.IfElse)
  SharedDtor(*this);
}
inline void IfElse::SharedDtor(MessageLite& self) {
  IfElse& this_ = static_cast<IfElse&>(self);
  this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  delete this_._impl_.cond_;
  delete this_._impl_.if_body_;
  delete this_._impl_.else_body_;
  this_._impl_.~Impl_();
}

inline void* IfElse::PlacementNew_(const void*, void* mem,
                                        ::google::protobuf::Arena* arena) {
  return ::new (mem) IfElse(arena);
}
constexpr auto IfElse::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(IfElse),
                                            alignof(IfElse));
}
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataFull IfElse::_class_data_ = {
    ::google::protobuf::internal::ClassData{
        &_IfElse_default_instance_._instance,
        &_table_.header,
        nullptr,  // OnDemandRegisterArenaDtor
        IfElse::IsInitializedImpl,
        &IfElse::MergeImpl,
        ::google::protobuf::Message::GetNewImpl<IfElse>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
        &IfElse::SharedDtor,
        ::google::protobuf::Message::GetClearImpl<IfElse>(), &IfElse::ByteSizeLong,
            &IfElse::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
        PROTOBUF_FIELD_OFFSET(IfElse, _impl_._cached_size_),
        false,
    },
    &IfElse::kDescriptorMethods,
    &descriptor_table_ruby_2eproto,
    nullptr,  // tracker
};
const ::google::protobuf::internal::ClassData* IfElse::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_);
  ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table);
  return _class_data_.base();
}
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::_pbi::TcParseTable<2, 3, 3, 0, 2> IfElse::_table_ = {
  {
    PROTOBUF_FIELD_OFFSET(IfElse, _impl_._has_bits_),
    0, // no _extensions_
    3, 24,  // max_field_number, fast_idx_mask
    offsetof(decltype(_table_), field_lookup_table),
    4294967288,  // skipmap
    offsetof(decltype(_table_), field_entries),
    3,  // num_field_entries
    3,  // num_aux_entries
    offsetof(decltype(_table_), aux_entries),
    _class_data_.base(),
    nullptr,  // post_loop_handler
    ::_pbi::TcParser::GenericFallback,  // fallback
    #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
    ::_pbi::TcParser::GetTable<::ruby_fuzzer::IfElse>(),  // to_prefetch
    #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
  }, {{
    {::_pbi::TcParser::MiniParse, {}},
    // required .ruby_fuzzer.Rvalue cond = 1;
    {::_pbi::TcParser::FastMtS1,
     {10, 0, 0, PROTOBUF_FIELD_OFFSET(IfElse, _impl_.cond_)}},
    // required .ruby_fuzzer.StatementSeq if_body = 2;
    {::_pbi::TcParser::FastMtS1,
     {18, 1, 1, PROTOBUF_FIELD_OFFSET(IfElse, _impl_.if_body_)}},
    // required .ruby_fuzzer.StatementSeq else_body = 3;
    {::_pbi::TcParser::FastMtS1,
     {26, 2, 2, PROTOBUF_FIELD_OFFSET(IfElse, _impl_.else_body_)}},
  }}, {{
    65535, 65535
  }}, {{
    // required .ruby_fuzzer.Rvalue cond = 1;
    {PROTOBUF_FIELD_OFFSET(IfElse, _impl_.cond_), _Internal::kHasBitsOffset + 0, 0,
    (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
    // required .ruby_fuzzer.StatementSeq if_body = 2;
    {PROTOBUF_FIELD_OFFSET(IfElse, _impl_.if_body_), _Internal::kHasBitsOffset + 1, 1,
    (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
    // required .ruby_fuzzer.StatementSeq else_body = 3;
    {PROTOBUF_FIELD_OFFSET(IfElse, _impl_.else_body_), _Internal::kHasBitsOffset + 2, 2,
    (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
  }}, {{
    {::_pbi::TcParser::GetTable<::ruby_fuzzer::Rvalue>()},
    {::_pbi::TcParser::GetTable<::ruby_fuzzer::StatementSeq>()},
    {::_pbi::TcParser::GetTable<::ruby_fuzzer::StatementSeq>()},
  }}, {{
  }},
};

PROTOBUF_NOINLINE void IfElse::Clear() {
// @@protoc_insertion_point(message_clear_start:ruby_fuzzer.IfElse)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      ABSL_DCHECK(_impl_.cond_ != nullptr);
      _impl_.cond_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      ABSL_DCHECK(_impl_.if_body_ != nullptr);
      _impl_.if_body_->Clear();
    }
    if (cached_has_bits & 0x00000004u) {
      ABSL_DCHECK(_impl_.else_body_ != nullptr);
      _impl_.else_body_->Clear();
    }
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
        ::uint8_t* IfElse::_InternalSerialize(
            const MessageLite& base, ::uint8_t* target,
            ::google::protobuf::io::EpsCopyOutputStream* stream) {
          const IfElse& this_ = static_cast<const IfElse&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
        ::uint8_t* IfElse::_InternalSerialize(
            ::uint8_t* target,
            ::google::protobuf::io::EpsCopyOutputStream* stream) const {
          const IfElse& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
          // @@protoc_insertion_point(serialize_to_array_start:ruby_fuzzer.IfElse)
          ::uint32_t cached_has_bits = 0;
          (void)cached_has_bits;

          cached_has_bits = this_._impl_._has_bits_[0];
          // required .ruby_fuzzer.Rvalue cond = 1;
          if (cached_has_bits & 0x00000001u) {
            target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
                1, *this_._impl_.cond_, this_._impl_.cond_->GetCachedSize(), target,
                stream);
          }

          // required .ruby_fuzzer.StatementSeq if_body = 2;
          if (cached_has_bits & 0x00000002u) {
            target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
                2, *this_._impl_.if_body_, this_._impl_.if_body_->GetCachedSize(), target,
                stream);
          }

          // required .ruby_fuzzer.StatementSeq else_body = 3;
          if (cached_has_bits & 0x00000004u) {
            target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
                3, *this_._impl_.else_body_, this_._impl_.else_body_->GetCachedSize(), target,
                stream);
          }

          if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
            target =
                ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
                    this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
          }
          // @@protoc_insertion_point(serialize_to_array_end:ruby_fuzzer.IfElse)
          return target;
        }

#if defined(PROTOBUF_CUSTOM_VTABLE)
        ::size_t IfElse::ByteSizeLong(const MessageLite& base) {
          const IfElse& this_ = static_cast<const IfElse&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
        ::size_t IfElse::ByteSizeLong() const {
          const IfElse& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
          // @@protoc_insertion_point(message_byte_size_start:ruby_fuzzer.IfElse)
          ::size_t total_size = 0;

          ::uint32_t cached_has_bits = 0;
          // Prevent compiler warnings about cached_has_bits being unused
          (void)cached_has_bits;

          ::_pbi::Prefetch5LinesFrom7Lines(&this_);
          cached_has_bits = this_._impl_._has_bits_[0];
          if (cached_has_bits & 0x00000007u) {
            // required .ruby_fuzzer.Rvalue cond = 1;
            if (cached_has_bits & 0x00000001u) {
              total_size += 1 +
                            ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.cond_);
            }
            // required .ruby_fuzzer.StatementSeq if_body = 2;
            if (cached_has_bits & 0x00000002u) {
              total_size += 1 +
                            ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.if_body_);
            }
            // required .ruby_fuzzer.StatementSeq else_body = 3;
            if (cached_has_bits & 0x00000004u) {
              total_size += 1 +
                            ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.else_body_);
            }
          }
          return this_.MaybeComputeUnknownFieldsSize(total_size,
                                                     &this_._impl_._cached_size_);
        }

void IfElse::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) {
  auto* const _this = static_cast<IfElse*>(&to_msg);
  auto& from = static_cast<const IfElse&>(from_msg);
  ::google::protobuf::Arena* arena = _this->GetArena();
  // @@protoc_insertion_point(class_specific_merge_from_start:ruby_fuzzer.IfElse)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      ABSL_DCHECK(from._impl_.cond_ != nullptr);
      if (_this->_impl_.cond_ == nullptr) {
        _this->_impl_.cond_ =
            ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::Rvalue>(arena, *from._impl_.cond_);
      } else {
        _this->_impl_.cond_->MergeFrom(*from._impl_.cond_);
      }
    }
    if (cached_has_bits & 0x00000002u) {
      ABSL_DCHECK(from._impl_.if_body_ != nullptr);
      if (_this->_impl_.if_body_ == nullptr) {
        _this->_impl_.if_body_ =
            ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::StatementSeq>(arena, *from._impl_.if_body_);
      } else {
        _this->_impl_.if_body_->MergeFrom(*from._impl_.if_body_);
      }
    }
    if (cached_has_bits & 0x00000004u) {
      ABSL_DCHECK(from._impl_.else_body_ != nullptr);
      if (_this->_impl_.else_body_ == nullptr) {
        _this->_impl_.else_body_ =
            ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::StatementSeq>(arena, *from._impl_.else_body_);
      } else {
        _this->_impl_.else_body_->MergeFrom(*from._impl_.else_body_);
      }
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_);
}

void IfElse::CopyFrom(const IfElse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:ruby_fuzzer.IfElse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

PROTOBUF_NOINLINE bool IfElse::IsInitializedImpl(
    const MessageLite& msg) {
  auto& this_ = static_cast<const IfElse&>(msg);
  if (_Internal::MissingRequiredFields(this_._impl_._has_bits_)) {
    return false;
  }
  if ((this_._impl_._has_bits_[0] & 0x00000001u) != 0) {
    if (!this_._impl_.cond_->IsInitialized()) return false;
  }
  if ((this_._impl_._has_bits_[0] & 0x00000002u) != 0) {
    if (!this_._impl_.if_body_->IsInitialized()) return false;
  }
  if ((this_._impl_._has_bits_[0] & 0x00000004u) != 0) {
    if (!this_._impl_.else_body_->IsInitialized()) return false;
  }
  return true;
}

void IfElse::InternalSwap(IfElse* PROTOBUF_RESTRICT other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(IfElse, _impl_.else_body_)
      + sizeof(IfElse::_impl_.else_body_)
      - PROTOBUF_FIELD_OFFSET(IfElse, _impl_.cond_)>(
          reinterpret_cast<char*>(&_impl_.cond_),
          reinterpret_cast<char*>(&other->_impl_.cond_));
}

::google::protobuf::Metadata IfElse::GetMetadata() const {
  return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full());
}
// ===================================================================

class Ternary::_Internal {
 public:
  using HasBits =
      decltype(std::declval<Ternary>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(Ternary, _impl_._has_bits_);
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000007) ^ 0x00000007) != 0;
  }
};

Ternary::Ternary(::google::protobuf::Arena* arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, _class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:ruby_fuzzer.Ternary)
}
inline PROTOBUF_NDEBUG_INLINE Ternary::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena,
    const Impl_& from, const ::ruby_fuzzer::Ternary& from_msg)
      : _has_bits_{from._has_bits_},
        _cached_size_{0} {}

Ternary::Ternary(
    ::google::protobuf::Arena* arena,
    const Ternary& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, _class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  Ternary* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);
  ::uint32_t cached_has_bits = _impl_._has_bits_[0];
  _impl_.tern_cond_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::Rvalue>(
                              arena, *from._impl_.tern_cond_)
                        : nullptr;
  _impl_.t_branch_ = (cached_has_bits & 0x00000002u) ? ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::Rvalue>(
                              arena, *from._impl_.t_branch_)
                        : nullptr;
  _impl_.f_branch_ = (cached_has_bits & 0x00000004u) ? ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::Rvalue>(
                              arena, *from._impl_.f_branch_)
                        : nullptr;

  // @@protoc_insertion_point(copy_constructor:ruby_fuzzer.Ternary)
}
inline PROTOBUF_NDEBUG_INLINE Ternary::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility,
    ::google::protobuf::Arena* arena)
      : _cached_size_{0} {}

inline void Ternary::SharedCtor(::_pb::Arena* arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  ::memset(reinterpret_cast<char *>(&_impl_) +
               offsetof(Impl_, tern_cond_),
           0,
           offsetof(Impl_, f_branch_) -
               offsetof(Impl_, tern_cond_) +
               sizeof(Impl_::f_branch_));
}
Ternary::~Ternary() {
  // @@protoc_insertion_point(destructor:ruby_fuzzer.Ternary)
  SharedDtor(*this);
}
inline void Ternary::SharedDtor(MessageLite& self) {
  Ternary& this_ = static_cast<Ternary&>(self);
  this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  delete this_._impl_.tern_cond_;
  delete this_._impl_.t_branch_;
  delete this_._impl_.f_branch_;
  this_._impl_.~Impl_();
}

inline void* Ternary::PlacementNew_(const void*, void* mem,
                                        ::google::protobuf::Arena* arena) {
  return ::new (mem) Ternary(arena);
}
constexpr auto Ternary::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(Ternary),
                                            alignof(Ternary));
}
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataFull Ternary::_class_data_ = {
    ::google::protobuf::internal::ClassData{
        &_Ternary_default_instance_._instance,
        &_table_.header,
        nullptr,  // OnDemandRegisterArenaDtor
        Ternary::IsInitializedImpl,
        &Ternary::MergeImpl,
        ::google::protobuf::Message::GetNewImpl<Ternary>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
        &Ternary::SharedDtor,
        ::google::protobuf::Message::GetClearImpl<Ternary>(), &Ternary::ByteSizeLong,
            &Ternary::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
        PROTOBUF_FIELD_OFFSET(Ternary, _impl_._cached_size_),
        false,
    },
    &Ternary::kDescriptorMethods,
    &descriptor_table_ruby_2eproto,
    nullptr,  // tracker
};
const ::google::protobuf::internal::ClassData* Ternary::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_);
  ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table);
  return _class_data_.base();
}
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::_pbi::TcParseTable<2, 3, 3, 0, 2> Ternary::_table_ = {
  {
    PROTOBUF_FIELD_OFFSET(Ternary, _impl_._has_bits_),
    0, // no _extensions_
    3, 24,  // max_field_number, fast_idx_mask
    offsetof(decltype(_table_), field_lookup_table),
    4294967288,  // skipmap
    offsetof(decltype(_table_), field_entries),
    3,  // num_field_entries
    3,  // num_aux_entries
    offsetof(decltype(_table_), aux_entries),
    _class_data_.base(),
    nullptr,  // post_loop_handler
    ::_pbi::TcParser::GenericFallback,  // fallback
    #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
    ::_pbi::TcParser::GetTable<::ruby_fuzzer::Ternary>(),  // to_prefetch
    #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
  }, {{
    {::_pbi::TcParser::MiniParse, {}},
    // required .ruby_fuzzer.Rvalue tern_cond = 1;
    {::_pbi::TcParser::FastMtS1,
     {10, 0, 0, PROTOBUF_FIELD_OFFSET(Ternary, _impl_.tern_cond_)}},
    // required .ruby_fuzzer.Rvalue t_branch = 2;
    {::_pbi::TcParser::FastMtS1,
     {18, 1, 1, PROTOBUF_FIELD_OFFSET(Ternary, _impl_.t_branch_)}},
    // required .ruby_fuzzer.Rvalue f_branch = 3;
    {::_pbi::TcParser::FastMtS1,
     {26, 2, 2, PROTOBUF_FIELD_OFFSET(Ternary, _impl_.f_branch_)}},
  }}, {{
    65535, 65535
  }}, {{
    // required .ruby_fuzzer.Rvalue tern_cond = 1;
    {PROTOBUF_FIELD_OFFSET(Ternary, _impl_.tern_cond_), _Internal::kHasBitsOffset + 0, 0,
    (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
    // required .ruby_fuzzer.Rvalue t_branch = 2;
    {PROTOBUF_FIELD_OFFSET(Ternary, _impl_.t_branch_), _Internal::kHasBitsOffset + 1, 1,
    (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
    // required .ruby_fuzzer.Rvalue f_branch = 3;
    {PROTOBUF_FIELD_OFFSET(Ternary, _impl_.f_branch_), _Internal::kHasBitsOffset + 2, 2,
    (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
  }}, {{
    {::_pbi::TcParser::GetTable<::ruby_fuzzer::Rvalue>()},
    {::_pbi::TcParser::GetTable<::ruby_fuzzer::Rvalue>()},
    {::_pbi::TcParser::GetTable<::ruby_fuzzer::Rvalue>()},
  }}, {{
  }},
};

PROTOBUF_NOINLINE void Ternary::Clear() {
// @@protoc_insertion_point(message_clear_start:ruby_fuzzer.Ternary)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      ABSL_DCHECK(_impl_.tern_cond_ != nullptr);
      _impl_.tern_cond_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      ABSL_DCHECK(_impl_.t_branch_ != nullptr);
      _impl_.t_branch_->Clear();
    }
    if (cached_has_bits & 0x00000004u) {
      ABSL_DCHECK(_impl_.f_branch_ != nullptr);
      _impl_.f_branch_->Clear();
    }
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
        ::uint8_t* Ternary::_InternalSerialize(
            const MessageLite& base, ::uint8_t* target,
            ::google::protobuf::io::EpsCopyOutputStream* stream) {
          const Ternary& this_ = static_cast<const Ternary&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
        ::uint8_t* Ternary::_InternalSerialize(
            ::uint8_t* target,
            ::google::protobuf::io::EpsCopyOutputStream* stream) const {
          const Ternary& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
          // @@protoc_insertion_point(serialize_to_array_start:ruby_fuzzer.Ternary)
          ::uint32_t cached_has_bits = 0;
          (void)cached_has_bits;

          cached_has_bits = this_._impl_._has_bits_[0];
          // required .ruby_fuzzer.Rvalue tern_cond = 1;
          if (cached_has_bits & 0x00000001u) {
            target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
                1, *this_._impl_.tern_cond_, this_._impl_.tern_cond_->GetCachedSize(), target,
                stream);
          }

          // required .ruby_fuzzer.Rvalue t_branch = 2;
          if (cached_has_bits & 0x00000002u) {
            target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
                2, *this_._impl_.t_branch_, this_._impl_.t_branch_->GetCachedSize(), target,
                stream);
          }

          // required .ruby_fuzzer.Rvalue f_branch = 3;
          if (cached_has_bits & 0x00000004u) {
            target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
                3, *this_._impl_.f_branch_, this_._impl_.f_branch_->GetCachedSize(), target,
                stream);
          }

          if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
            target =
                ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
                    this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
          }
          // @@protoc_insertion_point(serialize_to_array_end:ruby_fuzzer.Ternary)
          return target;
        }

#if defined(PROTOBUF_CUSTOM_VTABLE)
        ::size_t Ternary::ByteSizeLong(const MessageLite& base) {
          const Ternary& this_ = static_cast<const Ternary&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
        ::size_t Ternary::ByteSizeLong() const {
          const Ternary& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
          // @@protoc_insertion_point(message_byte_size_start:ruby_fuzzer.Ternary)
          ::size_t total_size = 0;

          ::uint32_t cached_has_bits = 0;
          // Prevent compiler warnings about cached_has_bits being unused
          (void)cached_has_bits;

          ::_pbi::Prefetch5LinesFrom7Lines(&this_);
          cached_has_bits = this_._impl_._has_bits_[0];
          if (cached_has_bits & 0x00000007u) {
            // required .ruby_fuzzer.Rvalue tern_cond = 1;
            if (cached_has_bits & 0x00000001u) {
              total_size += 1 +
                            ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.tern_cond_);
            }
            // required .ruby_fuzzer.Rvalue t_branch = 2;
            if (cached_has_bits & 0x00000002u) {
              total_size += 1 +
                            ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.t_branch_);
            }
            // required .ruby_fuzzer.Rvalue f_branch = 3;
            if (cached_has_bits & 0x00000004u) {
              total_size += 1 +
                            ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.f_branch_);
            }
          }
          return this_.MaybeComputeUnknownFieldsSize(total_size,
                                                     &this_._impl_._cached_size_);
        }

void Ternary::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) {
  auto* const _this = static_cast<Ternary*>(&to_msg);
  auto& from = static_cast<const Ternary&>(from_msg);
  ::google::protobuf::Arena* arena = _this->GetArena();
  // @@protoc_insertion_point(class_specific_merge_from_start:ruby_fuzzer.Ternary)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      ABSL_DCHECK(from._impl_.tern_cond_ != nullptr);
      if (_this->_impl_.tern_cond_ == nullptr) {
        _this->_impl_.tern_cond_ =
            ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::Rvalue>(arena, *from._impl_.tern_cond_);
      } else {
        _this->_impl_.tern_cond_->MergeFrom(*from._impl_.tern_cond_);
      }
    }
    if (cached_has_bits & 0x00000002u) {
      ABSL_DCHECK(from._impl_.t_branch_ != nullptr);
      if (_this->_impl_.t_branch_ == nullptr) {
        _this->_impl_.t_branch_ =
            ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::Rvalue>(arena, *from._impl_.t_branch_);
      } else {
        _this->_impl_.t_branch_->MergeFrom(*from._impl_.t_branch_);
      }
    }
    if (cached_has_bits & 0x00000004u) {
      ABSL_DCHECK(from._impl_.f_branch_ != nullptr);
      if (_this->_impl_.f_branch_ == nullptr) {
        _this->_impl_.f_branch_ =
            ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::Rvalue>(arena, *from._impl_.f_branch_);
      } else {
        _this->_impl_.f_branch_->MergeFrom(*from._impl_.f_branch_);
      }
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_);
}

void Ternary::CopyFrom(const Ternary& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:ruby_fuzzer.Ternary)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

PROTOBUF_NOINLINE bool Ternary::IsInitializedImpl(
    const MessageLite& msg) {
  auto& this_ = static_cast<const Ternary&>(msg);
  if (_Internal::MissingRequiredFields(this_._impl_._has_bits_)) {
    return false;
  }
  if ((this_._impl_._has_bits_[0] & 0x00000001u) != 0) {
    if (!this_._impl_.tern_cond_->IsInitialized()) return false;
  }
  if ((this_._impl_._has_bits_[0] & 0x00000002u) != 0) {
    if (!this_._impl_.t_branch_->IsInitialized()) return false;
  }
  if ((this_._impl_._has_bits_[0] & 0x00000004u) != 0) {
    if (!this_._impl_.f_branch_->IsInitialized()) return false;
  }
  return true;
}

void Ternary::InternalSwap(Ternary* PROTOBUF_RESTRICT other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Ternary, _impl_.f_branch_)
      + sizeof(Ternary::_impl_.f_branch_)
      - PROTOBUF_FIELD_OFFSET(Ternary, _impl_.tern_cond_)>(
          reinterpret_cast<char*>(&_impl_.tern_cond_),
          reinterpret_cast<char*>(&other->_impl_.tern_cond_));
}

::google::protobuf::Metadata Ternary::GetMetadata() const {
  return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full());
}
// ===================================================================

class ObjectSpace::_Internal {
 public:
  using HasBits =
      decltype(std::declval<ObjectSpace>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(ObjectSpace, _impl_._has_bits_);
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000003) ^ 0x00000003) != 0;
  }
};

ObjectSpace::ObjectSpace(::google::protobuf::Arena* arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, _class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:ruby_fuzzer.ObjectSpace)
}
inline PROTOBUF_NDEBUG_INLINE ObjectSpace::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena,
    const Impl_& from, const ::ruby_fuzzer::ObjectSpace& from_msg)
      : _has_bits_{from._has_bits_},
        _cached_size_{0} {}

ObjectSpace::ObjectSpace(
    ::google::protobuf::Arena* arena,
    const ObjectSpace& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, _class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  ObjectSpace* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);
  ::uint32_t cached_has_bits = _impl_._has_bits_[0];
  _impl_.os_arg_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::HashType>(
                              arena, *from._impl_.os_arg_)
                        : nullptr;
  _impl_.os_func_ = from._impl_.os_func_;

  // @@protoc_insertion_point(copy_constructor:ruby_fuzzer.ObjectSpace)
}
inline PROTOBUF_NDEBUG_INLINE ObjectSpace::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility,
    ::google::protobuf::Arena* arena)
      : _cached_size_{0},
        os_func_{static_cast< ::ruby_fuzzer::ObjectSpace_OS_methods >(1)} {}

inline void ObjectSpace::SharedCtor(::_pb::Arena* arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  _impl_.os_arg_ = {};
}
ObjectSpace::~ObjectSpace() {
  // @@protoc_insertion_point(destructor:ruby_fuzzer.ObjectSpace)
  SharedDtor(*this);
}
inline void ObjectSpace::SharedDtor(MessageLite& self) {
  ObjectSpace& this_ = static_cast<ObjectSpace&>(self);
  this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  delete this_._impl_.os_arg_;
  this_._impl_.~Impl_();
}

inline void* ObjectSpace::PlacementNew_(const void*, void* mem,
                                        ::google::protobuf::Arena* arena) {
  return ::new (mem) ObjectSpace(arena);
}
constexpr auto ObjectSpace::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(ObjectSpace),
                                            alignof(ObjectSpace));
}
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataFull ObjectSpace::_class_data_ = {
    ::google::protobuf::internal::ClassData{
        &_ObjectSpace_default_instance_._instance,
        &_table_.header,
        nullptr,  // OnDemandRegisterArenaDtor
        ObjectSpace::IsInitializedImpl,
        &ObjectSpace::MergeImpl,
        ::google::protobuf::Message::GetNewImpl<ObjectSpace>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
        &ObjectSpace::SharedDtor,
        ::google::protobuf::Message::GetClearImpl<ObjectSpace>(), &ObjectSpace::ByteSizeLong,
            &ObjectSpace::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
        PROTOBUF_FIELD_OFFSET(ObjectSpace, _impl_._cached_size_),
        false,
    },
    &ObjectSpace::kDescriptorMethods,
    &descriptor_table_ruby_2eproto,
    nullptr,  // tracker
};
const ::google::protobuf::internal::ClassData* ObjectSpace::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_);
  ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table);
  return _class_data_.base();
}
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::_pbi::TcParseTable<1, 2, 2, 0, 2> ObjectSpace::_table_ = {
  {
    PROTOBUF_FIELD_OFFSET(ObjectSpace, _impl_._has_bits_),
    0, // no _extensions_
    2, 8,  // max_field_number, fast_idx_mask
    offsetof(decltype(_table_), field_lookup_table),
    4294967292,  // skipmap
    offsetof(decltype(_table_), field_entries),
    2,  // num_field_entries
    2,  // num_aux_entries
    offsetof(decltype(_table_), aux_entries),
    _class_data_.base(),
    nullptr,  // post_loop_handler
    ::_pbi::TcParser::GenericFallback,  // fallback
    #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
    ::_pbi::TcParser::GetTable<::ruby_fuzzer::ObjectSpace>(),  // to_prefetch
    #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
  }, {{
    // required .ruby_fuzzer.HashType os_arg = 2;
    {::_pbi::TcParser::FastMtS1,
     {18, 0, 0, PROTOBUF_FIELD_OFFSET(ObjectSpace, _impl_.os_arg_)}},
    // required .ruby_fuzzer.ObjectSpace.OS_methods os_func = 1;
    {::_pbi::TcParser::FastEr1S1,
     {8, 1, 1, PROTOBUF_FIELD_OFFSET(ObjectSpace, _impl_.os_func_)}},
  }}, {{
    65535, 65535
  }}, {{
    // required .ruby_fuzzer.ObjectSpace.OS_methods os_func = 1;
    {PROTOBUF_FIELD_OFFSET(ObjectSpace, _impl_.os_func_), _Internal::kHasBitsOffset + 1, 1,
    (0 | ::_fl::kFcOptional | ::_fl::kEnumRange)},
    // required .ruby_fuzzer.HashType os_arg = 2;
    {PROTOBUF_FIELD_OFFSET(ObjectSpace, _impl_.os_arg_), _Internal::kHasBitsOffset + 0, 0,
    (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
  }}, {{
    {::_pbi::TcParser::GetTable<::ruby_fuzzer::HashType>()},
    {1, 1},
  }}, {{
  }},
};

PROTOBUF_NOINLINE void ObjectSpace::Clear() {
// @@protoc_insertion_point(message_clear_start:ruby_fuzzer.ObjectSpace)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      ABSL_DCHECK(_impl_.os_arg_ != nullptr);
      _impl_.os_arg_->Clear();
    }
    _impl_.os_func_ = 1;
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
        ::uint8_t* ObjectSpace::_InternalSerialize(
            const MessageLite& base, ::uint8_t* target,
            ::google::protobuf::io::EpsCopyOutputStream* stream) {
          const ObjectSpace& this_ = static_cast<const ObjectSpace&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
        ::uint8_t* ObjectSpace::_InternalSerialize(
            ::uint8_t* target,
            ::google::protobuf::io::EpsCopyOutputStream* stream) const {
          const ObjectSpace& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
          // @@protoc_insertion_point(serialize_to_array_start:ruby_fuzzer.ObjectSpace)
          ::uint32_t cached_has_bits = 0;
          (void)cached_has_bits;

          cached_has_bits = this_._impl_._has_bits_[0];
          // required .ruby_fuzzer.ObjectSpace.OS_methods os_func = 1;
          if (cached_has_bits & 0x00000002u) {
            target = stream->EnsureSpace(target);
            target = ::_pbi::WireFormatLite::WriteEnumToArray(
                1, this_._internal_os_func(), target);
          }

          // required .ruby_fuzzer.HashType os_arg = 2;
          if (cached_has_bits & 0x00000001u) {
            target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
                2, *this_._impl_.os_arg_, this_._impl_.os_arg_->GetCachedSize(), target,
                stream);
          }

          if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
            target =
                ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
                    this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
          }
          // @@protoc_insertion_point(serialize_to_array_end:ruby_fuzzer.ObjectSpace)
          return target;
        }

#if defined(PROTOBUF_CUSTOM_VTABLE)
        ::size_t ObjectSpace::ByteSizeLong(const MessageLite& base) {
          const ObjectSpace& this_ = static_cast<const ObjectSpace&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
        ::size_t ObjectSpace::ByteSizeLong() const {
          const ObjectSpace& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
          // @@protoc_insertion_point(message_byte_size_start:ruby_fuzzer.ObjectSpace)
          ::size_t total_size = 0;

          ::uint32_t cached_has_bits = 0;
          // Prevent compiler warnings about cached_has_bits being unused
          (void)cached_has_bits;

          ::_pbi::Prefetch5LinesFrom7Lines(&this_);
          cached_has_bits = this_._impl_._has_bits_[0];
          if (cached_has_bits & 0x00000003u) {
            // required .ruby_fuzzer.HashType os_arg = 2;
            if (cached_has_bits & 0x00000001u) {
              total_size += 1 +
                            ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.os_arg_);
            }
            // required .ruby_fuzzer.ObjectSpace.OS_methods os_func = 1;
            if (cached_has_bits & 0x00000002u) {
              total_size += 1 +
                            ::_pbi::WireFormatLite::EnumSize(this_._internal_os_func());
            }
          }
          return this_.MaybeComputeUnknownFieldsSize(total_size,
                                                     &this_._impl_._cached_size_);
        }

void ObjectSpace::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) {
  auto* const _this = static_cast<ObjectSpace*>(&to_msg);
  auto& from = static_cast<const ObjectSpace&>(from_msg);
  ::google::protobuf::Arena* arena = _this->GetArena();
  // @@protoc_insertion_point(class_specific_merge_from_start:ruby_fuzzer.ObjectSpace)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      ABSL_DCHECK(from._impl_.os_arg_ != nullptr);
      if (_this->_impl_.os_arg_ == nullptr) {
        _this->_impl_.os_arg_ =
            ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::HashType>(arena, *from._impl_.os_arg_);
      } else {
        _this->_impl_.os_arg_->MergeFrom(*from._impl_.os_arg_);
      }
    }
    if (cached_has_bits & 0x00000002u) {
      _this->_impl_.os_func_ = from._impl_.os_func_;
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_);
}

void ObjectSpace::CopyFrom(const ObjectSpace& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:ruby_fuzzer.ObjectSpace)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

PROTOBUF_NOINLINE bool ObjectSpace::IsInitializedImpl(
    const MessageLite& msg) {
  auto& this_ = static_cast<const ObjectSpace&>(msg);
  if (_Internal::MissingRequiredFields(this_._impl_._has_bits_)) {
    return false;
  }
  if ((this_._impl_._has_bits_[0] & 0x00000001u) != 0) {
    if (!this_._impl_.os_arg_->IsInitialized()) return false;
  }
  return true;
}

void ObjectSpace::InternalSwap(ObjectSpace* PROTOBUF_RESTRICT other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(ObjectSpace, _impl_.os_func_)
      + sizeof(ObjectSpace::_impl_.os_func_)
      - PROTOBUF_FIELD_OFFSET(ObjectSpace, _impl_.os_arg_)>(
          reinterpret_cast<char*>(&_impl_.os_arg_),
          reinterpret_cast<char*>(&other->_impl_.os_arg_));
}

::google::protobuf::Metadata ObjectSpace::GetMetadata() const {
  return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full());
}
// ===================================================================

class Time::_Internal {
 public:
  using HasBits =
      decltype(std::declval<Time>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(Time, _impl_._has_bits_);
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000003) ^ 0x00000003) != 0;
  }
};

Time::Time(::google::protobuf::Arena* arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, _class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:ruby_fuzzer.Time)
}
Time::Time(
    ::google::protobuf::Arena* arena, const Time& from)
    : Time(arena) {
  MergeFrom(from);
}
inline PROTOBUF_NDEBUG_INLINE Time::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility,
    ::google::protobuf::Arena* arena)
      : _cached_size_{0},
        t_func_{static_cast< ::ruby_fuzzer::Time_T_methods >(1)} {}

inline void Time::SharedCtor(::_pb::Arena* arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  _impl_.t_arg_ = {};
}
Time::~Time() {
  // @@protoc_insertion_point(destructor:ruby_fuzzer.Time)
  SharedDtor(*this);
}
inline void Time::SharedDtor(MessageLite& self) {
  Time& this_ = static_cast<Time&>(self);
  this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  this_._impl_.~Impl_();
}

inline void* Time::PlacementNew_(const void*, void* mem,
                                        ::google::protobuf::Arena* arena) {
  return ::new (mem) Time(arena);
}
constexpr auto Time::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(Time),
                                            alignof(Time));
}
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataFull Time::_class_data_ = {
    ::google::protobuf::internal::ClassData{
        &_Time_default_instance_._instance,
        &_table_.header,
        nullptr,  // OnDemandRegisterArenaDtor
        Time::IsInitializedImpl,
        &Time::MergeImpl,
        ::google::protobuf::Message::GetNewImpl<Time>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
        &Time::SharedDtor,
        ::google::protobuf::Message::GetClearImpl<Time>(), &Time::ByteSizeLong,
            &Time::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
        PROTOBUF_FIELD_OFFSET(Time, _impl_._cached_size_),
        false,
    },
    &Time::kDescriptorMethods,
    &descriptor_table_ruby_2eproto,
    nullptr,  // tracker
};
const ::google::protobuf::internal::ClassData* Time::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_);
  ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table);
  return _class_data_.base();
}
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::_pbi::TcParseTable<1, 2, 1, 0, 2> Time::_table_ = {
  {
    PROTOBUF_FIELD_OFFSET(Time, _impl_._has_bits_),
    0, // no _extensions_
    2, 8,  // max_field_number, fast_idx_mask
    offsetof(decltype(_table_), field_lookup_table),
    4294967292,  // skipmap
    offsetof(decltype(_table_), field_entries),
    2,  // num_field_entries
    1,  // num_aux_entries
    offsetof(decltype(_table_), aux_entries),
    _class_data_.base(),
    nullptr,  // post_loop_handler
    ::_pbi::TcParser::GenericFallback,  // fallback
    #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
    ::_pbi::TcParser::GetTable<::ruby_fuzzer::Time>(),  // to_prefetch
    #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
  }, {{
    // required uint32 t_arg = 2;
    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(Time, _impl_.t_arg_), 0>(),
     {16, 0, 0, PROTOBUF_FIELD_OFFSET(Time, _impl_.t_arg_)}},
    // required .ruby_fuzzer.Time.T_methods t_func = 1;
    {::_pbi::TcParser::FastEr1S1,
     {8, 1, 2, PROTOBUF_FIELD_OFFSET(Time, _impl_.t_func_)}},
  }}, {{
    65535, 65535
  }}, {{
    // required .ruby_fuzzer.Time.T_methods t_func = 1;
    {PROTOBUF_FIELD_OFFSET(Time, _impl_.t_func_), _Internal::kHasBitsOffset + 1, 0,
    (0 | ::_fl::kFcOptional | ::_fl::kEnumRange)},
    // required uint32 t_arg = 2;
    {PROTOBUF_FIELD_OFFSET(Time, _impl_.t_arg_), _Internal::kHasBitsOffset + 0, 0,
    (0 | ::_fl::kFcOptional | ::_fl::kUInt32)},
  }}, {{
    {1, 2},
  }}, {{
  }},
};

PROTOBUF_NOINLINE void Time::Clear() {
// @@protoc_insertion_point(message_clear_start:ruby_fuzzer.Time)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    _impl_.t_arg_ = 0u;
    _impl_.t_func_ = 1;
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
        ::uint8_t* Time::_InternalSerialize(
            const MessageLite& base, ::uint8_t* target,
            ::google::protobuf::io::EpsCopyOutputStream* stream) {
          const Time& this_ = static_cast<const Time&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
        ::uint8_t* Time::_InternalSerialize(
            ::uint8_t* target,
            ::google::protobuf::io::EpsCopyOutputStream* stream) const {
          const Time& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
          // @@protoc_insertion_point(serialize_to_array_start:ruby_fuzzer.Time)
          ::uint32_t cached_has_bits = 0;
          (void)cached_has_bits;

          cached_has_bits = this_._impl_._has_bits_[0];
          // required .ruby_fuzzer.Time.T_methods t_func = 1;
          if (cached_has_bits & 0x00000002u) {
            target = stream->EnsureSpace(target);
            target = ::_pbi::WireFormatLite::WriteEnumToArray(
                1, this_._internal_t_func(), target);
          }

          // required uint32 t_arg = 2;
          if (cached_has_bits & 0x00000001u) {
            target = stream->EnsureSpace(target);
            target = ::_pbi::WireFormatLite::WriteUInt32ToArray(
                2, this_._internal_t_arg(), target);
          }

          if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
            target =
                ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
                    this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
          }
          // @@protoc_insertion_point(serialize_to_array_end:ruby_fuzzer.Time)
          return target;
        }

#if defined(PROTOBUF_CUSTOM_VTABLE)
        ::size_t Time::ByteSizeLong(const MessageLite& base) {
          const Time& this_ = static_cast<const Time&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
        ::size_t Time::ByteSizeLong() const {
          const Time& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
          // @@protoc_insertion_point(message_byte_size_start:ruby_fuzzer.Time)
          ::size_t total_size = 0;

          ::uint32_t cached_has_bits = 0;
          // Prevent compiler warnings about cached_has_bits being unused
          (void)cached_has_bits;

          ::_pbi::Prefetch5LinesFrom7Lines(&this_);
          cached_has_bits = this_._impl_._has_bits_[0];
          if (cached_has_bits & 0x00000003u) {
            // required uint32 t_arg = 2;
            if (cached_has_bits & 0x00000001u) {
              total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(
                  this_._internal_t_arg());
            }
            // required .ruby_fuzzer.Time.T_methods t_func = 1;
            if (cached_has_bits & 0x00000002u) {
              total_size += 1 +
                            ::_pbi::WireFormatLite::EnumSize(this_._internal_t_func());
            }
          }
          return this_.MaybeComputeUnknownFieldsSize(total_size,
                                                     &this_._impl_._cached_size_);
        }

void Time::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) {
  auto* const _this = static_cast<Time*>(&to_msg);
  auto& from = static_cast<const Time&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:ruby_fuzzer.Time)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _this->_impl_.t_arg_ = from._impl_.t_arg_;
    }
    if (cached_has_bits & 0x00000002u) {
      _this->_impl_.t_func_ = from._impl_.t_func_;
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_);
}

void Time::CopyFrom(const Time& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:ruby_fuzzer.Time)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

PROTOBUF_NOINLINE bool Time::IsInitializedImpl(
    const MessageLite& msg) {
  auto& this_ = static_cast<const Time&>(msg);
  if (_Internal::MissingRequiredFields(this_._impl_._has_bits_)) {
    return false;
  }
  return true;
}

void Time::InternalSwap(Time* PROTOBUF_RESTRICT other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Time, _impl_.t_func_)
      + sizeof(Time::_impl_.t_func_)
      - PROTOBUF_FIELD_OFFSET(Time, _impl_.t_arg_)>(
          reinterpret_cast<char*>(&_impl_.t_arg_),
          reinterpret_cast<char*>(&other->_impl_.t_arg_));
}

::google::protobuf::Metadata Time::GetMetadata() const {
  return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full());
}
// ===================================================================

class Array::_Internal {
 public:
  using HasBits =
      decltype(std::declval<Array>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(Array, _impl_._has_bits_);
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000007) ^ 0x00000007) != 0;
  }
};

Array::Array(::google::protobuf::Arena* arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, _class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:ruby_fuzzer.Array)
}
inline PROTOBUF_NDEBUG_INLINE Array::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena,
    const Impl_& from, const ::ruby_fuzzer::Array& from_msg)
      : _has_bits_{from._has_bits_},
        _cached_size_{0} {}

Array::Array(
    ::google::protobuf::Arena* arena,
    const Array& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, _class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  Array* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);
  ::uint32_t cached_has_bits = _impl_._has_bits_[0];
  _impl_.arr_arg_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::ArrType>(
                              arena, *from._impl_.arr_arg_)
                        : nullptr;
  _impl_.val_arg_ = (cached_has_bits & 0x00000002u) ? ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::Rvalue>(
                              arena, *from._impl_.val_arg_)
                        : nullptr;
  _impl_.arr_func_ = from._impl_.arr_func_;

  // @@protoc_insertion_point(copy_constructor:ruby_fuzzer.Array)
}
inline PROTOBUF_NDEBUG_INLINE Array::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility,
    ::google::protobuf::Arena* arena)
      : _cached_size_{0},
        arr_func_{static_cast< ::ruby_fuzzer::Array_Arr_methods >(1)} {}

inline void Array::SharedCtor(::_pb::Arena* arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  ::memset(reinterpret_cast<char *>(&_impl_) +
               offsetof(Impl_, arr_arg_),
           0,
           offsetof(Impl_, val_arg_) -
               offsetof(Impl_, arr_arg_) +
               sizeof(Impl_::val_arg_));
}
Array::~Array() {
  // @@protoc_insertion_point(destructor:ruby_fuzzer.Array)
  SharedDtor(*this);
}
inline void Array::SharedDtor(MessageLite& self) {
  Array& this_ = static_cast<Array&>(self);
  this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  delete this_._impl_.arr_arg_;
  delete this_._impl_.val_arg_;
  this_._impl_.~Impl_();
}

inline void* Array::PlacementNew_(const void*, void* mem,
                                        ::google::protobuf::Arena* arena) {
  return ::new (mem) Array(arena);
}
constexpr auto Array::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(Array),
                                            alignof(Array));
}
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataFull Array::_class_data_ = {
    ::google::protobuf::internal::ClassData{
        &_Array_default_instance_._instance,
        &_table_.header,
        nullptr,  // OnDemandRegisterArenaDtor
        Array::IsInitializedImpl,
        &Array::MergeImpl,
        ::google::protobuf::Message::GetNewImpl<Array>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
        &Array::SharedDtor,
        ::google::protobuf::Message::GetClearImpl<Array>(), &Array::ByteSizeLong,
            &Array::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
        PROTOBUF_FIELD_OFFSET(Array, _impl_._cached_size_),
        false,
    },
    &Array::kDescriptorMethods,
    &descriptor_table_ruby_2eproto,
    nullptr,  // tracker
};
const ::google::protobuf::internal::ClassData* Array::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_);
  ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table);
  return _class_data_.base();
}
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::_pbi::TcParseTable<2, 3, 3, 0, 2> Array::_table_ = {
  {
    PROTOBUF_FIELD_OFFSET(Array, _impl_._has_bits_),
    0, // no _extensions_
    3, 24,  // max_field_number, fast_idx_mask
    offsetof(decltype(_table_), field_lookup_table),
    4294967288,  // skipmap
    offsetof(decltype(_table_), field_entries),
    3,  // num_field_entries
    3,  // num_aux_entries
    offsetof(decltype(_table_), aux_entries),
    _class_data_.base(),
    nullptr,  // post_loop_handler
    ::_pbi::TcParser::GenericFallback,  // fallback
    #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
    ::_pbi::TcParser::GetTable<::ruby_fuzzer::Array>(),  // to_prefetch
    #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
  }, {{
    {::_pbi::TcParser::MiniParse, {}},
    // required .ruby_fuzzer.Array.Arr_methods arr_func = 1;
    {::_pbi::TcParser::FastEr1S1,
     {8, 2, 19, PROTOBUF_FIELD_OFFSET(Array, _impl_.arr_func_)}},
    // required .ruby_fuzzer.ArrType arr_arg = 2;
    {::_pbi::TcParser::FastMtS1,
     {18, 0, 0, PROTOBUF_FIELD_OFFSET(Array, _impl_.arr_arg_)}},
    // required .ruby_fuzzer.Rvalue val_arg = 3;
    {::_pbi::TcParser::FastMtS1,
     {26, 1, 1, PROTOBUF_FIELD_OFFSET(Array, _impl_.val_arg_)}},
  }}, {{
    65535, 65535
  }}, {{
    // required .ruby_fuzzer.Array.Arr_methods arr_func = 1;
    {PROTOBUF_FIELD_OFFSET(Array, _impl_.arr_func_), _Internal::kHasBitsOffset + 2, 2,
    (0 | ::_fl::kFcOptional | ::_fl::kEnumRange)},
    // required .ruby_fuzzer.ArrType arr_arg = 2;
    {PROTOBUF_FIELD_OFFSET(Array, _impl_.arr_arg_), _Internal::kHasBitsOffset + 0, 0,
    (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
    // required .ruby_fuzzer.Rvalue val_arg = 3;
    {PROTOBUF_FIELD_OFFSET(Array, _impl_.val_arg_), _Internal::kHasBitsOffset + 1, 1,
    (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
  }}, {{
    {::_pbi::TcParser::GetTable<::ruby_fuzzer::ArrType>()},
    {::_pbi::TcParser::GetTable<::ruby_fuzzer::Rvalue>()},
    {1, 19},
  }}, {{
  }},
};

PROTOBUF_NOINLINE void Array::Clear() {
// @@protoc_insertion_point(message_clear_start:ruby_fuzzer.Array)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      ABSL_DCHECK(_impl_.arr_arg_ != nullptr);
      _impl_.arr_arg_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      ABSL_DCHECK(_impl_.val_arg_ != nullptr);
      _impl_.val_arg_->Clear();
    }
    _impl_.arr_func_ = 1;
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
        ::uint8_t* Array::_InternalSerialize(
            const MessageLite& base, ::uint8_t* target,
            ::google::protobuf::io::EpsCopyOutputStream* stream) {
          const Array& this_ = static_cast<const Array&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
        ::uint8_t* Array::_InternalSerialize(
            ::uint8_t* target,
            ::google::protobuf::io::EpsCopyOutputStream* stream) const {
          const Array& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
          // @@protoc_insertion_point(serialize_to_array_start:ruby_fuzzer.Array)
          ::uint32_t cached_has_bits = 0;
          (void)cached_has_bits;

          cached_has_bits = this_._impl_._has_bits_[0];
          // required .ruby_fuzzer.Array.Arr_methods arr_func = 1;
          if (cached_has_bits & 0x00000004u) {
            target = stream->EnsureSpace(target);
            target = ::_pbi::WireFormatLite::WriteEnumToArray(
                1, this_._internal_arr_func(), target);
          }

          // required .ruby_fuzzer.ArrType arr_arg = 2;
          if (cached_has_bits & 0x00000001u) {
            target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
                2, *this_._impl_.arr_arg_, this_._impl_.arr_arg_->GetCachedSize(), target,
                stream);
          }

          // required .ruby_fuzzer.Rvalue val_arg = 3;
          if (cached_has_bits & 0x00000002u) {
            target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
                3, *this_._impl_.val_arg_, this_._impl_.val_arg_->GetCachedSize(), target,
                stream);
          }

          if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
            target =
                ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
                    this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
          }
          // @@protoc_insertion_point(serialize_to_array_end:ruby_fuzzer.Array)
          return target;
        }

#if defined(PROTOBUF_CUSTOM_VTABLE)
        ::size_t Array::ByteSizeLong(const MessageLite& base) {
          const Array& this_ = static_cast<const Array&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
        ::size_t Array::ByteSizeLong() const {
          const Array& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
          // @@protoc_insertion_point(message_byte_size_start:ruby_fuzzer.Array)
          ::size_t total_size = 0;

          ::uint32_t cached_has_bits = 0;
          // Prevent compiler warnings about cached_has_bits being unused
          (void)cached_has_bits;

          ::_pbi::Prefetch5LinesFrom7Lines(&this_);
          cached_has_bits = this_._impl_._has_bits_[0];
          if (cached_has_bits & 0x00000007u) {
            // required .ruby_fuzzer.ArrType arr_arg = 2;
            if (cached_has_bits & 0x00000001u) {
              total_size += 1 +
                            ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.arr_arg_);
            }
            // required .ruby_fuzzer.Rvalue val_arg = 3;
            if (cached_has_bits & 0x00000002u) {
              total_size += 1 +
                            ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.val_arg_);
            }
            // required .ruby_fuzzer.Array.Arr_methods arr_func = 1;
            if (cached_has_bits & 0x00000004u) {
              total_size += 1 +
                            ::_pbi::WireFormatLite::EnumSize(this_._internal_arr_func());
            }
          }
          return this_.MaybeComputeUnknownFieldsSize(total_size,
                                                     &this_._impl_._cached_size_);
        }

void Array::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) {
  auto* const _this = static_cast<Array*>(&to_msg);
  auto& from = static_cast<const Array&>(from_msg);
  ::google::protobuf::Arena* arena = _this->GetArena();
  // @@protoc_insertion_point(class_specific_merge_from_start:ruby_fuzzer.Array)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      ABSL_DCHECK(from._impl_.arr_arg_ != nullptr);
      if (_this->_impl_.arr_arg_ == nullptr) {
        _this->_impl_.arr_arg_ =
            ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::ArrType>(arena, *from._impl_.arr_arg_);
      } else {
        _this->_impl_.arr_arg_->MergeFrom(*from._impl_.arr_arg_);
      }
    }
    if (cached_has_bits & 0x00000002u) {
      ABSL_DCHECK(from._impl_.val_arg_ != nullptr);
      if (_this->_impl_.val_arg_ == nullptr) {
        _this->_impl_.val_arg_ =
            ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::Rvalue>(arena, *from._impl_.val_arg_);
      } else {
        _this->_impl_.val_arg_->MergeFrom(*from._impl_.val_arg_);
      }
    }
    if (cached_has_bits & 0x00000004u) {
      _this->_impl_.arr_func_ = from._impl_.arr_func_;
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_);
}

void Array::CopyFrom(const Array& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:ruby_fuzzer.Array)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

PROTOBUF_NOINLINE bool Array::IsInitializedImpl(
    const MessageLite& msg) {
  auto& this_ = static_cast<const Array&>(msg);
  if (_Internal::MissingRequiredFields(this_._impl_._has_bits_)) {
    return false;
  }
  if ((this_._impl_._has_bits_[0] & 0x00000002u) != 0) {
    if (!this_._impl_.val_arg_->IsInitialized()) return false;
  }
  return true;
}

void Array::InternalSwap(Array* PROTOBUF_RESTRICT other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Array, _impl_.arr_func_)
      + sizeof(Array::_impl_.arr_func_)
      - PROTOBUF_FIELD_OFFSET(Array, _impl_.arr_arg_)>(
          reinterpret_cast<char*>(&_impl_.arr_arg_),
          reinterpret_cast<char*>(&other->_impl_.arr_arg_));
}

::google::protobuf::Metadata Array::GetMetadata() const {
  return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full());
}
// ===================================================================

class MathType::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
      PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::MathType, _impl_._oneof_case_);
};

void MathType::set_allocated_math_rval(::ruby_fuzzer::Rvalue* math_rval) {
  ::google::protobuf::Arena* message_arena = GetArena();
  clear_math_arg_oneof();
  if (math_rval) {
    ::google::protobuf::Arena* submessage_arena = math_rval->GetArena();
    if (message_arena != submessage_arena) {
      math_rval = ::google::protobuf::internal::GetOwnedMessage(message_arena, math_rval, submessage_arena);
    }
    set_has_math_rval();
    _impl_.math_arg_oneof_.math_rval_ = math_rval;
  }
  // @@protoc_insertion_point(field_set_allocated:ruby_fuzzer.MathType.math_rval)
}
void MathType::set_allocated_math_const(::ruby_fuzzer::MathConst* math_const) {
  ::google::protobuf::Arena* message_arena = GetArena();
  clear_math_arg_oneof();
  if (math_const) {
    ::google::protobuf::Arena* submessage_arena = math_const->GetArena();
    if (message_arena != submessage_arena) {
      math_const = ::google::protobuf::internal::GetOwnedMessage(message_arena, math_const, submessage_arena);
    }
    set_has_math_const();
    _impl_.math_arg_oneof_.math_const_ = math_const;
  }
  // @@protoc_insertion_point(field_set_allocated:ruby_fuzzer.MathType.math_const)
}
MathType::MathType(::google::protobuf::Arena* arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, _class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:ruby_fuzzer.MathType)
}
inline PROTOBUF_NDEBUG_INLINE MathType::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena,
    const Impl_& from, const ::ruby_fuzzer::MathType& from_msg)
      : math_arg_oneof_{},
        _cached_size_{0},
        _oneof_case_{from._oneof_case_[0]} {}

MathType::MathType(
    ::google::protobuf::Arena* arena,
    const MathType& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, _class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  MathType* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);
  switch (math_arg_oneof_case()) {
    case MATH_ARG_ONEOF_NOT_SET:
      break;
      case kMathRval:
        _impl_.math_arg_oneof_.math_rval_ = ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::Rvalue>(arena, *from._impl_.math_arg_oneof_.math_rval_);
        break;
      case kMathConst:
        _impl_.math_arg_oneof_.math_const_ = ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::MathConst>(arena, *from._impl_.math_arg_oneof_.math_const_);
        break;
  }

  // @@protoc_insertion_point(copy_constructor:ruby_fuzzer.MathType)
}
inline PROTOBUF_NDEBUG_INLINE MathType::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility,
    ::google::protobuf::Arena* arena)
      : math_arg_oneof_{},
        _cached_size_{0},
        _oneof_case_{} {}

inline void MathType::SharedCtor(::_pb::Arena* arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
}
MathType::~MathType() {
  // @@protoc_insertion_point(destructor:ruby_fuzzer.MathType)
  SharedDtor(*this);
}
inline void MathType::SharedDtor(MessageLite& self) {
  MathType& this_ = static_cast<MathType&>(self);
  this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  if (this_.has_math_arg_oneof()) {
    this_.clear_math_arg_oneof();
  }
  this_._impl_.~Impl_();
}

void MathType::clear_math_arg_oneof() {
// @@protoc_insertion_point(one_of_clear_start:ruby_fuzzer.MathType)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  switch (math_arg_oneof_case()) {
    case kMathRval: {
      if (GetArena() == nullptr) {
        delete _impl_.math_arg_oneof_.math_rval_;
      } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
        ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.math_arg_oneof_.math_rval_);
      }
      break;
    }
    case kMathConst: {
      if (GetArena() == nullptr) {
        delete _impl_.math_arg_oneof_.math_const_;
      } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
        ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.math_arg_oneof_.math_const_);
      }
      break;
    }
    case MATH_ARG_ONEOF_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = MATH_ARG_ONEOF_NOT_SET;
}


inline void* MathType::PlacementNew_(const void*, void* mem,
                                        ::google::protobuf::Arena* arena) {
  return ::new (mem) MathType(arena);
}
constexpr auto MathType::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(MathType),
                                            alignof(MathType));
}
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataFull MathType::_class_data_ = {
    ::google::protobuf::internal::ClassData{
        &_MathType_default_instance_._instance,
        &_table_.header,
        nullptr,  // OnDemandRegisterArenaDtor
        MathType::IsInitializedImpl,
        &MathType::MergeImpl,
        ::google::protobuf::Message::GetNewImpl<MathType>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
        &MathType::SharedDtor,
        ::google::protobuf::Message::GetClearImpl<MathType>(), &MathType::ByteSizeLong,
            &MathType::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
        PROTOBUF_FIELD_OFFSET(MathType, _impl_._cached_size_),
        false,
    },
    &MathType::kDescriptorMethods,
    &descriptor_table_ruby_2eproto,
    nullptr,  // tracker
};
const ::google::protobuf::internal::ClassData* MathType::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_);
  ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table);
  return _class_data_.base();
}
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::_pbi::TcParseTable<0, 2, 2, 0, 2> MathType::_table_ = {
  {
    0,  // no _has_bits_
    0, // no _extensions_
    3, 0,  // max_field_number, fast_idx_mask
    offsetof(decltype(_table_), field_lookup_table),
    4294967289,  // skipmap
    offsetof(decltype(_table_), field_entries),
    2,  // num_field_entries
    2,  // num_aux_entries
    offsetof(decltype(_table_), aux_entries),
    _class_data_.base(),
    nullptr,  // post_loop_handler
    ::_pbi::TcParser::GenericFallback,  // fallback
    #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
    ::_pbi::TcParser::GetTable<::ruby_fuzzer::MathType>(),  // to_prefetch
    #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
  }, {{
    {::_pbi::TcParser::MiniParse, {}},
  }}, {{
    65535, 65535
  }}, {{
    // .ruby_fuzzer.Rvalue math_rval = 2;
    {PROTOBUF_FIELD_OFFSET(MathType, _impl_.math_arg_oneof_.math_rval_), _Internal::kOneofCaseOffset + 0, 0,
    (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)},
    // .ruby_fuzzer.MathConst math_const = 3;
    {PROTOBUF_FIELD_OFFSET(MathType, _impl_.math_arg_oneof_.math_const_), _Internal::kOneofCaseOffset + 0, 1,
    (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)},
  }}, {{
    {::_pbi::TcParser::GetTable<::ruby_fuzzer::Rvalue>()},
    {::_pbi::TcParser::GetTable<::ruby_fuzzer::MathConst>()},
  }}, {{
  }},
};

PROTOBUF_NOINLINE void MathType::Clear() {
// @@protoc_insertion_point(message_clear_start:ruby_fuzzer.MathType)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_math_arg_oneof();
  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
        ::uint8_t* MathType::_InternalSerialize(
            const MessageLite& base, ::uint8_t* target,
            ::google::protobuf::io::EpsCopyOutputStream* stream) {
          const MathType& this_ = static_cast<const MathType&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
        ::uint8_t* MathType::_InternalSerialize(
            ::uint8_t* target,
            ::google::protobuf::io::EpsCopyOutputStream* stream) const {
          const MathType& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
          // @@protoc_insertion_point(serialize_to_array_start:ruby_fuzzer.MathType)
          ::uint32_t cached_has_bits = 0;
          (void)cached_has_bits;

          switch (this_.math_arg_oneof_case()) {
            case kMathRval: {
              target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
                  2, *this_._impl_.math_arg_oneof_.math_rval_, this_._impl_.math_arg_oneof_.math_rval_->GetCachedSize(), target,
                  stream);
              break;
            }
            case kMathConst: {
              target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
                  3, *this_._impl_.math_arg_oneof_.math_const_, this_._impl_.math_arg_oneof_.math_const_->GetCachedSize(), target,
                  stream);
              break;
            }
            default:
              break;
          }
          if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
            target =
                ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
                    this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
          }
          // @@protoc_insertion_point(serialize_to_array_end:ruby_fuzzer.MathType)
          return target;
        }

#if defined(PROTOBUF_CUSTOM_VTABLE)
        ::size_t MathType::ByteSizeLong(const MessageLite& base) {
          const MathType& this_ = static_cast<const MathType&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
        ::size_t MathType::ByteSizeLong() const {
          const MathType& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
          // @@protoc_insertion_point(message_byte_size_start:ruby_fuzzer.MathType)
          ::size_t total_size = 0;

          ::uint32_t cached_has_bits = 0;
          // Prevent compiler warnings about cached_has_bits being unused
          (void)cached_has_bits;

          switch (this_.math_arg_oneof_case()) {
            // .ruby_fuzzer.Rvalue math_rval = 2;
            case kMathRval: {
              total_size += 1 +
                            ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.math_arg_oneof_.math_rval_);
              break;
            }
            // .ruby_fuzzer.MathConst math_const = 3;
            case kMathConst: {
              total_size += 1 +
                            ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.math_arg_oneof_.math_const_);
              break;
            }
            case MATH_ARG_ONEOF_NOT_SET: {
              break;
            }
          }
          return this_.MaybeComputeUnknownFieldsSize(total_size,
                                                     &this_._impl_._cached_size_);
        }

void MathType::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) {
  auto* const _this = static_cast<MathType*>(&to_msg);
  auto& from = static_cast<const MathType&>(from_msg);
  ::google::protobuf::Arena* arena = _this->GetArena();
  // @@protoc_insertion_point(class_specific_merge_from_start:ruby_fuzzer.MathType)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (const uint32_t oneof_from_case = from._impl_._oneof_case_[0]) {
    const uint32_t oneof_to_case = _this->_impl_._oneof_case_[0];
    const bool oneof_needs_init = oneof_to_case != oneof_from_case;
    if (oneof_needs_init) {
      if (oneof_to_case != 0) {
        _this->clear_math_arg_oneof();
      }
      _this->_impl_._oneof_case_[0] = oneof_from_case;
    }

    switch (oneof_from_case) {
      case kMathRval: {
        if (oneof_needs_init) {
          _this->_impl_.math_arg_oneof_.math_rval_ =
              ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::Rvalue>(arena, *from._impl_.math_arg_oneof_.math_rval_);
        } else {
          _this->_impl_.math_arg_oneof_.math_rval_->MergeFrom(from._internal_math_rval());
        }
        break;
      }
      case kMathConst: {
        if (oneof_needs_init) {
          _this->_impl_.math_arg_oneof_.math_const_ =
              ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::MathConst>(arena, *from._impl_.math_arg_oneof_.math_const_);
        } else {
          _this->_impl_.math_arg_oneof_.math_const_->MergeFrom(from._internal_math_const());
        }
        break;
      }
      case MATH_ARG_ONEOF_NOT_SET:
        break;
    }
  }
  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_);
}

void MathType::CopyFrom(const MathType& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:ruby_fuzzer.MathType)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

PROTOBUF_NOINLINE bool MathType::IsInitializedImpl(
    const MessageLite& msg) {
  auto& this_ = static_cast<const MathType&>(msg);
  switch (this_.math_arg_oneof_case()) {
    case kMathRval: {
      if (this_.math_arg_oneof_case() == kMathRval && !this_._impl_.math_arg_oneof_.math_rval_->IsInitialized())
        return false;
      break;
    }
    case kMathConst: {
      if (this_.math_arg_oneof_case() == kMathConst && !this_._impl_.math_arg_oneof_.math_const_->IsInitialized())
        return false;
      break;
    }
    case MATH_ARG_ONEOF_NOT_SET: {
      break;
    }
  }
  return true;
}

void MathType::InternalSwap(MathType* PROTOBUF_RESTRICT other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.math_arg_oneof_, other->_impl_.math_arg_oneof_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
}

::google::protobuf::Metadata MathType::GetMetadata() const {
  return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full());
}
// ===================================================================

class MathOps::_Internal {
 public:
  using HasBits =
      decltype(std::declval<MathOps>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(MathOps, _impl_._has_bits_);
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000003) ^ 0x00000003) != 0;
  }
};

MathOps::MathOps(::google::protobuf::Arena* arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, _class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:ruby_fuzzer.MathOps)
}
inline PROTOBUF_NDEBUG_INLINE MathOps::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena,
    const Impl_& from, const ::ruby_fuzzer::MathOps& from_msg)
      : _has_bits_{from._has_bits_},
        _cached_size_{0} {}

MathOps::MathOps(
    ::google::protobuf::Arena* arena,
    const MathOps& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, _class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  MathOps* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);
  ::uint32_t cached_has_bits = _impl_._has_bits_[0];
  _impl_.math_arg_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::MathType>(
                              arena, *from._impl_.math_arg_)
                        : nullptr;
  _impl_.math_op_ = from._impl_.math_op_;

  // @@protoc_insertion_point(copy_constructor:ruby_fuzzer.MathOps)
}
inline PROTOBUF_NDEBUG_INLINE MathOps::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility,
    ::google::protobuf::Arena* arena)
      : _cached_size_{0},
        math_op_{static_cast< ::ruby_fuzzer::MathOps_Mops >(1)} {}

inline void MathOps::SharedCtor(::_pb::Arena* arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  _impl_.math_arg_ = {};
}
MathOps::~MathOps() {
  // @@protoc_insertion_point(destructor:ruby_fuzzer.MathOps)
  SharedDtor(*this);
}
inline void MathOps::SharedDtor(MessageLite& self) {
  MathOps& this_ = static_cast<MathOps&>(self);
  this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  delete this_._impl_.math_arg_;
  this_._impl_.~Impl_();
}

inline void* MathOps::PlacementNew_(const void*, void* mem,
                                        ::google::protobuf::Arena* arena) {
  return ::new (mem) MathOps(arena);
}
constexpr auto MathOps::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(MathOps),
                                            alignof(MathOps));
}
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataFull MathOps::_class_data_ = {
    ::google::protobuf::internal::ClassData{
        &_MathOps_default_instance_._instance,
        &_table_.header,
        nullptr,  // OnDemandRegisterArenaDtor
        MathOps::IsInitializedImpl,
        &MathOps::MergeImpl,
        ::google::protobuf::Message::GetNewImpl<MathOps>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
        &MathOps::SharedDtor,
        ::google::protobuf::Message::GetClearImpl<MathOps>(), &MathOps::ByteSizeLong,
            &MathOps::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
        PROTOBUF_FIELD_OFFSET(MathOps, _impl_._cached_size_),
        false,
    },
    &MathOps::kDescriptorMethods,
    &descriptor_table_ruby_2eproto,
    nullptr,  // tracker
};
const ::google::protobuf::internal::ClassData* MathOps::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_);
  ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table);
  return _class_data_.base();
}
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::_pbi::TcParseTable<1, 2, 2, 0, 2> MathOps::_table_ = {
  {
    PROTOBUF_FIELD_OFFSET(MathOps, _impl_._has_bits_),
    0, // no _extensions_
    2, 8,  // max_field_number, fast_idx_mask
    offsetof(decltype(_table_), field_lookup_table),
    4294967292,  // skipmap
    offsetof(decltype(_table_), field_entries),
    2,  // num_field_entries
    2,  // num_aux_entries
    offsetof(decltype(_table_), aux_entries),
    _class_data_.base(),
    nullptr,  // post_loop_handler
    ::_pbi::TcParser::GenericFallback,  // fallback
    #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
    ::_pbi::TcParser::GetTable<::ruby_fuzzer::MathOps>(),  // to_prefetch
    #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
  }, {{
    // required .ruby_fuzzer.MathType math_arg = 2;
    {::_pbi::TcParser::FastMtS1,
     {18, 0, 0, PROTOBUF_FIELD_OFFSET(MathOps, _impl_.math_arg_)}},
    // required .ruby_fuzzer.MathOps.Mops math_op = 1;
    {::_pbi::TcParser::FastEr1S1,
     {8, 1, 10, PROTOBUF_FIELD_OFFSET(MathOps, _impl_.math_op_)}},
  }}, {{
    65535, 65535
  }}, {{
    // required .ruby_fuzzer.MathOps.Mops math_op = 1;
    {PROTOBUF_FIELD_OFFSET(MathOps, _impl_.math_op_), _Internal::kHasBitsOffset + 1, 1,
    (0 | ::_fl::kFcOptional | ::_fl::kEnumRange)},
    // required .ruby_fuzzer.MathType math_arg = 2;
    {PROTOBUF_FIELD_OFFSET(MathOps, _impl_.math_arg_), _Internal::kHasBitsOffset + 0, 0,
    (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
  }}, {{
    {::_pbi::TcParser::GetTable<::ruby_fuzzer::MathType>()},
    {1, 10},
  }}, {{
  }},
};

PROTOBUF_NOINLINE void MathOps::Clear() {
// @@protoc_insertion_point(message_clear_start:ruby_fuzzer.MathOps)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      ABSL_DCHECK(_impl_.math_arg_ != nullptr);
      _impl_.math_arg_->Clear();
    }
    _impl_.math_op_ = 1;
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
        ::uint8_t* MathOps::_InternalSerialize(
            const MessageLite& base, ::uint8_t* target,
            ::google::protobuf::io::EpsCopyOutputStream* stream) {
          const MathOps& this_ = static_cast<const MathOps&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
        ::uint8_t* MathOps::_InternalSerialize(
            ::uint8_t* target,
            ::google::protobuf::io::EpsCopyOutputStream* stream) const {
          const MathOps& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
          // @@protoc_insertion_point(serialize_to_array_start:ruby_fuzzer.MathOps)
          ::uint32_t cached_has_bits = 0;
          (void)cached_has_bits;

          cached_has_bits = this_._impl_._has_bits_[0];
          // required .ruby_fuzzer.MathOps.Mops math_op = 1;
          if (cached_has_bits & 0x00000002u) {
            target = stream->EnsureSpace(target);
            target = ::_pbi::WireFormatLite::WriteEnumToArray(
                1, this_._internal_math_op(), target);
          }

          // required .ruby_fuzzer.MathType math_arg = 2;
          if (cached_has_bits & 0x00000001u) {
            target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
                2, *this_._impl_.math_arg_, this_._impl_.math_arg_->GetCachedSize(), target,
                stream);
          }

          if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
            target =
                ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
                    this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
          }
          // @@protoc_insertion_point(serialize_to_array_end:ruby_fuzzer.MathOps)
          return target;
        }

#if defined(PROTOBUF_CUSTOM_VTABLE)
        ::size_t MathOps::ByteSizeLong(const MessageLite& base) {
          const MathOps& this_ = static_cast<const MathOps&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
        ::size_t MathOps::ByteSizeLong() const {
          const MathOps& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
          // @@protoc_insertion_point(message_byte_size_start:ruby_fuzzer.MathOps)
          ::size_t total_size = 0;

          ::uint32_t cached_has_bits = 0;
          // Prevent compiler warnings about cached_has_bits being unused
          (void)cached_has_bits;

          ::_pbi::Prefetch5LinesFrom7Lines(&this_);
          cached_has_bits = this_._impl_._has_bits_[0];
          if (cached_has_bits & 0x00000003u) {
            // required .ruby_fuzzer.MathType math_arg = 2;
            if (cached_has_bits & 0x00000001u) {
              total_size += 1 +
                            ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.math_arg_);
            }
            // required .ruby_fuzzer.MathOps.Mops math_op = 1;
            if (cached_has_bits & 0x00000002u) {
              total_size += 1 +
                            ::_pbi::WireFormatLite::EnumSize(this_._internal_math_op());
            }
          }
          return this_.MaybeComputeUnknownFieldsSize(total_size,
                                                     &this_._impl_._cached_size_);
        }

void MathOps::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) {
  auto* const _this = static_cast<MathOps*>(&to_msg);
  auto& from = static_cast<const MathOps&>(from_msg);
  ::google::protobuf::Arena* arena = _this->GetArena();
  // @@protoc_insertion_point(class_specific_merge_from_start:ruby_fuzzer.MathOps)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      ABSL_DCHECK(from._impl_.math_arg_ != nullptr);
      if (_this->_impl_.math_arg_ == nullptr) {
        _this->_impl_.math_arg_ =
            ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::MathType>(arena, *from._impl_.math_arg_);
      } else {
        _this->_impl_.math_arg_->MergeFrom(*from._impl_.math_arg_);
      }
    }
    if (cached_has_bits & 0x00000002u) {
      _this->_impl_.math_op_ = from._impl_.math_op_;
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_);
}

void MathOps::CopyFrom(const MathOps& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:ruby_fuzzer.MathOps)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

PROTOBUF_NOINLINE bool MathOps::IsInitializedImpl(
    const MessageLite& msg) {
  auto& this_ = static_cast<const MathOps&>(msg);
  if (_Internal::MissingRequiredFields(this_._impl_._has_bits_)) {
    return false;
  }
  if ((this_._impl_._has_bits_[0] & 0x00000001u) != 0) {
    if (!this_._impl_.math_arg_->IsInitialized()) return false;
  }
  return true;
}

void MathOps::InternalSwap(MathOps* PROTOBUF_RESTRICT other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(MathOps, _impl_.math_op_)
      + sizeof(MathOps::_impl_.math_op_)
      - PROTOBUF_FIELD_OFFSET(MathOps, _impl_.math_arg_)>(
          reinterpret_cast<char*>(&_impl_.math_arg_),
          reinterpret_cast<char*>(&other->_impl_.math_arg_));
}

::google::protobuf::Metadata MathOps::GetMetadata() const {
  return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full());
}
// ===================================================================

class BuiltinFuncs::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
      PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::BuiltinFuncs, _impl_._oneof_case_);
};

void BuiltinFuncs::set_allocated_os(::ruby_fuzzer::ObjectSpace* os) {
  ::google::protobuf::Arena* message_arena = GetArena();
  clear_bifunc_oneof();
  if (os) {
    ::google::protobuf::Arena* submessage_arena = os->GetArena();
    if (message_arena != submessage_arena) {
      os = ::google::protobuf::internal::GetOwnedMessage(message_arena, os, submessage_arena);
    }
    set_has_os();
    _impl_.bifunc_oneof_.os_ = os;
  }
  // @@protoc_insertion_point(field_set_allocated:ruby_fuzzer.BuiltinFuncs.os)
}
void BuiltinFuncs::set_allocated_time(::ruby_fuzzer::Time* time) {
  ::google::protobuf::Arena* message_arena = GetArena();
  clear_bifunc_oneof();
  if (time) {
    ::google::protobuf::Arena* submessage_arena = time->GetArena();
    if (message_arena != submessage_arena) {
      time = ::google::protobuf::internal::GetOwnedMessage(message_arena, time, submessage_arena);
    }
    set_has_time();
    _impl_.bifunc_oneof_.time_ = time;
  }
  // @@protoc_insertion_point(field_set_allocated:ruby_fuzzer.BuiltinFuncs.time)
}
void BuiltinFuncs::set_allocated_arr(::ruby_fuzzer::Array* arr) {
  ::google::protobuf::Arena* message_arena = GetArena();
  clear_bifunc_oneof();
  if (arr) {
    ::google::protobuf::Arena* submessage_arena = arr->GetArena();
    if (message_arena != submessage_arena) {
      arr = ::google::protobuf::internal::GetOwnedMessage(message_arena, arr, submessage_arena);
    }
    set_has_arr();
    _impl_.bifunc_oneof_.arr_ = arr;
  }
  // @@protoc_insertion_point(field_set_allocated:ruby_fuzzer.BuiltinFuncs.arr)
}
void BuiltinFuncs::set_allocated_mops(::ruby_fuzzer::MathOps* mops) {
  ::google::protobuf::Arena* message_arena = GetArena();
  clear_bifunc_oneof();
  if (mops) {
    ::google::protobuf::Arena* submessage_arena = mops->GetArena();
    if (message_arena != submessage_arena) {
      mops = ::google::protobuf::internal::GetOwnedMessage(message_arena, mops, submessage_arena);
    }
    set_has_mops();
    _impl_.bifunc_oneof_.mops_ = mops;
  }
  // @@protoc_insertion_point(field_set_allocated:ruby_fuzzer.BuiltinFuncs.mops)
}
BuiltinFuncs::BuiltinFuncs(::google::protobuf::Arena* arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, _class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:ruby_fuzzer.BuiltinFuncs)
}
inline PROTOBUF_NDEBUG_INLINE BuiltinFuncs::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena,
    const Impl_& from, const ::ruby_fuzzer::BuiltinFuncs& from_msg)
      : bifunc_oneof_{},
        _cached_size_{0},
        _oneof_case_{from._oneof_case_[0]} {}

BuiltinFuncs::BuiltinFuncs(
    ::google::protobuf::Arena* arena,
    const BuiltinFuncs& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, _class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  BuiltinFuncs* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);
  switch (bifunc_oneof_case()) {
    case BIFUNC_ONEOF_NOT_SET:
      break;
      case kOs:
        _impl_.bifunc_oneof_.os_ = ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::ObjectSpace>(arena, *from._impl_.bifunc_oneof_.os_);
        break;
      case kTime:
        _impl_.bifunc_oneof_.time_ = ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::Time>(arena, *from._impl_.bifunc_oneof_.time_);
        break;
      case kArr:
        _impl_.bifunc_oneof_.arr_ = ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::Array>(arena, *from._impl_.bifunc_oneof_.arr_);
        break;
      case kMops:
        _impl_.bifunc_oneof_.mops_ = ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::MathOps>(arena, *from._impl_.bifunc_oneof_.mops_);
        break;
  }

  // @@protoc_insertion_point(copy_constructor:ruby_fuzzer.BuiltinFuncs)
}
inline PROTOBUF_NDEBUG_INLINE BuiltinFuncs::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility,
    ::google::protobuf::Arena* arena)
      : bifunc_oneof_{},
        _cached_size_{0},
        _oneof_case_{} {}

inline void BuiltinFuncs::SharedCtor(::_pb::Arena* arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
}
BuiltinFuncs::~BuiltinFuncs() {
  // @@protoc_insertion_point(destructor:ruby_fuzzer.BuiltinFuncs)
  SharedDtor(*this);
}
inline void BuiltinFuncs::SharedDtor(MessageLite& self) {
  BuiltinFuncs& this_ = static_cast<BuiltinFuncs&>(self);
  this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  if (this_.has_bifunc_oneof()) {
    this_.clear_bifunc_oneof();
  }
  this_._impl_.~Impl_();
}

void BuiltinFuncs::clear_bifunc_oneof() {
// @@protoc_insertion_point(one_of_clear_start:ruby_fuzzer.BuiltinFuncs)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  switch (bifunc_oneof_case()) {
    case kOs: {
      if (GetArena() == nullptr) {
        delete _impl_.bifunc_oneof_.os_;
      } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
        ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.bifunc_oneof_.os_);
      }
      break;
    }
    case kTime: {
      if (GetArena() == nullptr) {
        delete _impl_.bifunc_oneof_.time_;
      } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
        ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.bifunc_oneof_.time_);
      }
      break;
    }
    case kArr: {
      if (GetArena() == nullptr) {
        delete _impl_.bifunc_oneof_.arr_;
      } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
        ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.bifunc_oneof_.arr_);
      }
      break;
    }
    case kMops: {
      if (GetArena() == nullptr) {
        delete _impl_.bifunc_oneof_.mops_;
      } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
        ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.bifunc_oneof_.mops_);
      }
      break;
    }
    case BIFUNC_ONEOF_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = BIFUNC_ONEOF_NOT_SET;
}


inline void* BuiltinFuncs::PlacementNew_(const void*, void* mem,
                                        ::google::protobuf::Arena* arena) {
  return ::new (mem) BuiltinFuncs(arena);
}
constexpr auto BuiltinFuncs::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(BuiltinFuncs),
                                            alignof(BuiltinFuncs));
}
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataFull BuiltinFuncs::_class_data_ = {
    ::google::protobuf::internal::ClassData{
        &_BuiltinFuncs_default_instance_._instance,
        &_table_.header,
        nullptr,  // OnDemandRegisterArenaDtor
        BuiltinFuncs::IsInitializedImpl,
        &BuiltinFuncs::MergeImpl,
        ::google::protobuf::Message::GetNewImpl<BuiltinFuncs>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
        &BuiltinFuncs::SharedDtor,
        ::google::protobuf::Message::GetClearImpl<BuiltinFuncs>(), &BuiltinFuncs::ByteSizeLong,
            &BuiltinFuncs::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
        PROTOBUF_FIELD_OFFSET(BuiltinFuncs, _impl_._cached_size_),
        false,
    },
    &BuiltinFuncs::kDescriptorMethods,
    &descriptor_table_ruby_2eproto,
    nullptr,  // tracker
};
const ::google::protobuf::internal::ClassData* BuiltinFuncs::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_);
  ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table);
  return _class_data_.base();
}
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::_pbi::TcParseTable<0, 4, 4, 0, 2> BuiltinFuncs::_table_ = {
  {
    0,  // no _has_bits_
    0, // no _extensions_
    4, 0,  // max_field_number, fast_idx_mask
    offsetof(decltype(_table_), field_lookup_table),
    4294967280,  // skipmap
    offsetof(decltype(_table_), field_entries),
    4,  // num_field_entries
    4,  // num_aux_entries
    offsetof(decltype(_table_), aux_entries),
    _class_data_.base(),
    nullptr,  // post_loop_handler
    ::_pbi::TcParser::GenericFallback,  // fallback
    #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
    ::_pbi::TcParser::GetTable<::ruby_fuzzer::BuiltinFuncs>(),  // to_prefetch
    #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
  }, {{
    {::_pbi::TcParser::MiniParse, {}},
  }}, {{
    65535, 65535
  }}, {{
    // .ruby_fuzzer.ObjectSpace os = 1;
    {PROTOBUF_FIELD_OFFSET(BuiltinFuncs, _impl_.bifunc_oneof_.os_), _Internal::kOneofCaseOffset + 0, 0,
    (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)},
    // .ruby_fuzzer.Time time = 2;
    {PROTOBUF_FIELD_OFFSET(BuiltinFuncs, _impl_.bifunc_oneof_.time_), _Internal::kOneofCaseOffset + 0, 1,
    (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)},
    // .ruby_fuzzer.Array arr = 3;
    {PROTOBUF_FIELD_OFFSET(BuiltinFuncs, _impl_.bifunc_oneof_.arr_), _Internal::kOneofCaseOffset + 0, 2,
    (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)},
    // .ruby_fuzzer.MathOps mops = 4;
    {PROTOBUF_FIELD_OFFSET(BuiltinFuncs, _impl_.bifunc_oneof_.mops_), _Internal::kOneofCaseOffset + 0, 3,
    (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)},
  }}, {{
    {::_pbi::TcParser::GetTable<::ruby_fuzzer::ObjectSpace>()},
    {::_pbi::TcParser::GetTable<::ruby_fuzzer::Time>()},
    {::_pbi::TcParser::GetTable<::ruby_fuzzer::Array>()},
    {::_pbi::TcParser::GetTable<::ruby_fuzzer::MathOps>()},
  }}, {{
  }},
};

PROTOBUF_NOINLINE void BuiltinFuncs::Clear() {
// @@protoc_insertion_point(message_clear_start:ruby_fuzzer.BuiltinFuncs)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_bifunc_oneof();
  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
        ::uint8_t* BuiltinFuncs::_InternalSerialize(
            const MessageLite& base, ::uint8_t* target,
            ::google::protobuf::io::EpsCopyOutputStream* stream) {
          const BuiltinFuncs& this_ = static_cast<const BuiltinFuncs&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
        ::uint8_t* BuiltinFuncs::_InternalSerialize(
            ::uint8_t* target,
            ::google::protobuf::io::EpsCopyOutputStream* stream) const {
          const BuiltinFuncs& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
          // @@protoc_insertion_point(serialize_to_array_start:ruby_fuzzer.BuiltinFuncs)
          ::uint32_t cached_has_bits = 0;
          (void)cached_has_bits;

          switch (this_.bifunc_oneof_case()) {
            case kOs: {
              target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
                  1, *this_._impl_.bifunc_oneof_.os_, this_._impl_.bifunc_oneof_.os_->GetCachedSize(), target,
                  stream);
              break;
            }
            case kTime: {
              target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
                  2, *this_._impl_.bifunc_oneof_.time_, this_._impl_.bifunc_oneof_.time_->GetCachedSize(), target,
                  stream);
              break;
            }
            case kArr: {
              target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
                  3, *this_._impl_.bifunc_oneof_.arr_, this_._impl_.bifunc_oneof_.arr_->GetCachedSize(), target,
                  stream);
              break;
            }
            case kMops: {
              target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
                  4, *this_._impl_.bifunc_oneof_.mops_, this_._impl_.bifunc_oneof_.mops_->GetCachedSize(), target,
                  stream);
              break;
            }
            default:
              break;
          }
          if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
            target =
                ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
                    this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
          }
          // @@protoc_insertion_point(serialize_to_array_end:ruby_fuzzer.BuiltinFuncs)
          return target;
        }

#if defined(PROTOBUF_CUSTOM_VTABLE)
        ::size_t BuiltinFuncs::ByteSizeLong(const MessageLite& base) {
          const BuiltinFuncs& this_ = static_cast<const BuiltinFuncs&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
        ::size_t BuiltinFuncs::ByteSizeLong() const {
          const BuiltinFuncs& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
          // @@protoc_insertion_point(message_byte_size_start:ruby_fuzzer.BuiltinFuncs)
          ::size_t total_size = 0;

          ::uint32_t cached_has_bits = 0;
          // Prevent compiler warnings about cached_has_bits being unused
          (void)cached_has_bits;

          switch (this_.bifunc_oneof_case()) {
            // .ruby_fuzzer.ObjectSpace os = 1;
            case kOs: {
              total_size += 1 +
                            ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.bifunc_oneof_.os_);
              break;
            }
            // .ruby_fuzzer.Time time = 2;
            case kTime: {
              total_size += 1 +
                            ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.bifunc_oneof_.time_);
              break;
            }
            // .ruby_fuzzer.Array arr = 3;
            case kArr: {
              total_size += 1 +
                            ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.bifunc_oneof_.arr_);
              break;
            }
            // .ruby_fuzzer.MathOps mops = 4;
            case kMops: {
              total_size += 1 +
                            ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.bifunc_oneof_.mops_);
              break;
            }
            case BIFUNC_ONEOF_NOT_SET: {
              break;
            }
          }
          return this_.MaybeComputeUnknownFieldsSize(total_size,
                                                     &this_._impl_._cached_size_);
        }

void BuiltinFuncs::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) {
  auto* const _this = static_cast<BuiltinFuncs*>(&to_msg);
  auto& from = static_cast<const BuiltinFuncs&>(from_msg);
  ::google::protobuf::Arena* arena = _this->GetArena();
  // @@protoc_insertion_point(class_specific_merge_from_start:ruby_fuzzer.BuiltinFuncs)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (const uint32_t oneof_from_case = from._impl_._oneof_case_[0]) {
    const uint32_t oneof_to_case = _this->_impl_._oneof_case_[0];
    const bool oneof_needs_init = oneof_to_case != oneof_from_case;
    if (oneof_needs_init) {
      if (oneof_to_case != 0) {
        _this->clear_bifunc_oneof();
      }
      _this->_impl_._oneof_case_[0] = oneof_from_case;
    }

    switch (oneof_from_case) {
      case kOs: {
        if (oneof_needs_init) {
          _this->_impl_.bifunc_oneof_.os_ =
              ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::ObjectSpace>(arena, *from._impl_.bifunc_oneof_.os_);
        } else {
          _this->_impl_.bifunc_oneof_.os_->MergeFrom(from._internal_os());
        }
        break;
      }
      case kTime: {
        if (oneof_needs_init) {
          _this->_impl_.bifunc_oneof_.time_ =
              ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::Time>(arena, *from._impl_.bifunc_oneof_.time_);
        } else {
          _this->_impl_.bifunc_oneof_.time_->MergeFrom(from._internal_time());
        }
        break;
      }
      case kArr: {
        if (oneof_needs_init) {
          _this->_impl_.bifunc_oneof_.arr_ =
              ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::Array>(arena, *from._impl_.bifunc_oneof_.arr_);
        } else {
          _this->_impl_.bifunc_oneof_.arr_->MergeFrom(from._internal_arr());
        }
        break;
      }
      case kMops: {
        if (oneof_needs_init) {
          _this->_impl_.bifunc_oneof_.mops_ =
              ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::MathOps>(arena, *from._impl_.bifunc_oneof_.mops_);
        } else {
          _this->_impl_.bifunc_oneof_.mops_->MergeFrom(from._internal_mops());
        }
        break;
      }
      case BIFUNC_ONEOF_NOT_SET:
        break;
    }
  }
  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_);
}

void BuiltinFuncs::CopyFrom(const BuiltinFuncs& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:ruby_fuzzer.BuiltinFuncs)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

PROTOBUF_NOINLINE bool BuiltinFuncs::IsInitializedImpl(
    const MessageLite& msg) {
  auto& this_ = static_cast<const BuiltinFuncs&>(msg);
  switch (this_.bifunc_oneof_case()) {
    case kOs: {
      if (this_.bifunc_oneof_case() == kOs && !this_._impl_.bifunc_oneof_.os_->IsInitialized())
        return false;
      break;
    }
    case kTime: {
      if (this_.bifunc_oneof_case() == kTime && !this_._impl_.bifunc_oneof_.time_->IsInitialized())
        return false;
      break;
    }
    case kArr: {
      if (this_.bifunc_oneof_case() == kArr && !this_._impl_.bifunc_oneof_.arr_->IsInitialized())
        return false;
      break;
    }
    case kMops: {
      if (this_.bifunc_oneof_case() == kMops && !this_._impl_.bifunc_oneof_.mops_->IsInitialized())
        return false;
      break;
    }
    case BIFUNC_ONEOF_NOT_SET: {
      break;
    }
  }
  return true;
}

void BuiltinFuncs::InternalSwap(BuiltinFuncs* PROTOBUF_RESTRICT other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.bifunc_oneof_, other->_impl_.bifunc_oneof_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
}

::google::protobuf::Metadata BuiltinFuncs::GetMetadata() const {
  return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full());
}
// ===================================================================

class Statement::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
      PROTOBUF_FIELD_OFFSET(::ruby_fuzzer::Statement, _impl_._oneof_case_);
};

void Statement::set_allocated_assignment(::ruby_fuzzer::AssignmentStatement* assignment) {
  ::google::protobuf::Arena* message_arena = GetArena();
  clear_stmt_oneof();
  if (assignment) {
    ::google::protobuf::Arena* submessage_arena = assignment->GetArena();
    if (message_arena != submessage_arena) {
      assignment = ::google::protobuf::internal::GetOwnedMessage(message_arena, assignment, submessage_arena);
    }
    set_has_assignment();
    _impl_.stmt_oneof_.assignment_ = assignment;
  }
  // @@protoc_insertion_point(field_set_allocated:ruby_fuzzer.Statement.assignment)
}
void Statement::set_allocated_ifelse(::ruby_fuzzer::IfElse* ifelse) {
  ::google::protobuf::Arena* message_arena = GetArena();
  clear_stmt_oneof();
  if (ifelse) {
    ::google::protobuf::Arena* submessage_arena = ifelse->GetArena();
    if (message_arena != submessage_arena) {
      ifelse = ::google::protobuf::internal::GetOwnedMessage(message_arena, ifelse, submessage_arena);
    }
    set_has_ifelse();
    _impl_.stmt_oneof_.ifelse_ = ifelse;
  }
  // @@protoc_insertion_point(field_set_allocated:ruby_fuzzer.Statement.ifelse)
}
void Statement::set_allocated_ternary_stmt(::ruby_fuzzer::Ternary* ternary_stmt) {
  ::google::protobuf::Arena* message_arena = GetArena();
  clear_stmt_oneof();
  if (ternary_stmt) {
    ::google::protobuf::Arena* submessage_arena = ternary_stmt->GetArena();
    if (message_arena != submessage_arena) {
      ternary_stmt = ::google::protobuf::internal::GetOwnedMessage(message_arena, ternary_stmt, submessage_arena);
    }
    set_has_ternary_stmt();
    _impl_.stmt_oneof_.ternary_stmt_ = ternary_stmt;
  }
  // @@protoc_insertion_point(field_set_allocated:ruby_fuzzer.Statement.ternary_stmt)
}
void Statement::set_allocated_builtins(::ruby_fuzzer::BuiltinFuncs* builtins) {
  ::google::protobuf::Arena* message_arena = GetArena();
  clear_stmt_oneof();
  if (builtins) {
    ::google::protobuf::Arena* submessage_arena = builtins->GetArena();
    if (message_arena != submessage_arena) {
      builtins = ::google::protobuf::internal::GetOwnedMessage(message_arena, builtins, submessage_arena);
    }
    set_has_builtins();
    _impl_.stmt_oneof_.builtins_ = builtins;
  }
  // @@protoc_insertion_point(field_set_allocated:ruby_fuzzer.Statement.builtins)
}
void Statement::set_allocated_blockstmt(::ruby_fuzzer::StatementSeq* blockstmt) {
  ::google::protobuf::Arena* message_arena = GetArena();
  clear_stmt_oneof();
  if (blockstmt) {
    ::google::protobuf::Arena* submessage_arena = blockstmt->GetArena();
    if (message_arena != submessage_arena) {
      blockstmt = ::google::protobuf::internal::GetOwnedMessage(message_arena, blockstmt, submessage_arena);
    }
    set_has_blockstmt();
    _impl_.stmt_oneof_.blockstmt_ = blockstmt;
  }
  // @@protoc_insertion_point(field_set_allocated:ruby_fuzzer.Statement.blockstmt)
}
Statement::Statement(::google::protobuf::Arena* arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, _class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:ruby_fuzzer.Statement)
}
inline PROTOBUF_NDEBUG_INLINE Statement::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena,
    const Impl_& from, const ::ruby_fuzzer::Statement& from_msg)
      : stmt_oneof_{},
        _cached_size_{0},
        _oneof_case_{from._oneof_case_[0]} {}

Statement::Statement(
    ::google::protobuf::Arena* arena,
    const Statement& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, _class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  Statement* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);
  switch (stmt_oneof_case()) {
    case STMT_ONEOF_NOT_SET:
      break;
      case kAssignment:
        _impl_.stmt_oneof_.assignment_ = ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::AssignmentStatement>(arena, *from._impl_.stmt_oneof_.assignment_);
        break;
      case kIfelse:
        _impl_.stmt_oneof_.ifelse_ = ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::IfElse>(arena, *from._impl_.stmt_oneof_.ifelse_);
        break;
      case kTernaryStmt:
        _impl_.stmt_oneof_.ternary_stmt_ = ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::Ternary>(arena, *from._impl_.stmt_oneof_.ternary_stmt_);
        break;
      case kBuiltins:
        _impl_.stmt_oneof_.builtins_ = ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::BuiltinFuncs>(arena, *from._impl_.stmt_oneof_.builtins_);
        break;
      case kBlockstmt:
        _impl_.stmt_oneof_.blockstmt_ = ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::StatementSeq>(arena, *from._impl_.stmt_oneof_.blockstmt_);
        break;
  }

  // @@protoc_insertion_point(copy_constructor:ruby_fuzzer.Statement)
}
inline PROTOBUF_NDEBUG_INLINE Statement::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility,
    ::google::protobuf::Arena* arena)
      : stmt_oneof_{},
        _cached_size_{0},
        _oneof_case_{} {}

inline void Statement::SharedCtor(::_pb::Arena* arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
}
Statement::~Statement() {
  // @@protoc_insertion_point(destructor:ruby_fuzzer.Statement)
  SharedDtor(*this);
}
inline void Statement::SharedDtor(MessageLite& self) {
  Statement& this_ = static_cast<Statement&>(self);
  this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  if (this_.has_stmt_oneof()) {
    this_.clear_stmt_oneof();
  }
  this_._impl_.~Impl_();
}

void Statement::clear_stmt_oneof() {
// @@protoc_insertion_point(one_of_clear_start:ruby_fuzzer.Statement)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  switch (stmt_oneof_case()) {
    case kAssignment: {
      if (GetArena() == nullptr) {
        delete _impl_.stmt_oneof_.assignment_;
      } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
        ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.stmt_oneof_.assignment_);
      }
      break;
    }
    case kIfelse: {
      if (GetArena() == nullptr) {
        delete _impl_.stmt_oneof_.ifelse_;
      } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
        ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.stmt_oneof_.ifelse_);
      }
      break;
    }
    case kTernaryStmt: {
      if (GetArena() == nullptr) {
        delete _impl_.stmt_oneof_.ternary_stmt_;
      } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
        ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.stmt_oneof_.ternary_stmt_);
      }
      break;
    }
    case kBuiltins: {
      if (GetArena() == nullptr) {
        delete _impl_.stmt_oneof_.builtins_;
      } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
        ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.stmt_oneof_.builtins_);
      }
      break;
    }
    case kBlockstmt: {
      if (GetArena() == nullptr) {
        delete _impl_.stmt_oneof_.blockstmt_;
      } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) {
        ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.stmt_oneof_.blockstmt_);
      }
      break;
    }
    case STMT_ONEOF_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = STMT_ONEOF_NOT_SET;
}


inline void* Statement::PlacementNew_(const void*, void* mem,
                                        ::google::protobuf::Arena* arena) {
  return ::new (mem) Statement(arena);
}
constexpr auto Statement::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(Statement),
                                            alignof(Statement));
}
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataFull Statement::_class_data_ = {
    ::google::protobuf::internal::ClassData{
        &_Statement_default_instance_._instance,
        &_table_.header,
        nullptr,  // OnDemandRegisterArenaDtor
        Statement::IsInitializedImpl,
        &Statement::MergeImpl,
        ::google::protobuf::Message::GetNewImpl<Statement>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
        &Statement::SharedDtor,
        ::google::protobuf::Message::GetClearImpl<Statement>(), &Statement::ByteSizeLong,
            &Statement::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
        PROTOBUF_FIELD_OFFSET(Statement, _impl_._cached_size_),
        false,
    },
    &Statement::kDescriptorMethods,
    &descriptor_table_ruby_2eproto,
    nullptr,  // tracker
};
const ::google::protobuf::internal::ClassData* Statement::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_);
  ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table);
  return _class_data_.base();
}
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::_pbi::TcParseTable<0, 5, 5, 0, 2> Statement::_table_ = {
  {
    0,  // no _has_bits_
    0, // no _extensions_
    5, 0,  // max_field_number, fast_idx_mask
    offsetof(decltype(_table_), field_lookup_table),
    4294967264,  // skipmap
    offsetof(decltype(_table_), field_entries),
    5,  // num_field_entries
    5,  // num_aux_entries
    offsetof(decltype(_table_), aux_entries),
    _class_data_.base(),
    nullptr,  // post_loop_handler
    ::_pbi::TcParser::GenericFallback,  // fallback
    #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
    ::_pbi::TcParser::GetTable<::ruby_fuzzer::Statement>(),  // to_prefetch
    #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
  }, {{
    {::_pbi::TcParser::MiniParse, {}},
  }}, {{
    65535, 65535
  }}, {{
    // .ruby_fuzzer.AssignmentStatement assignment = 1;
    {PROTOBUF_FIELD_OFFSET(Statement, _impl_.stmt_oneof_.assignment_), _Internal::kOneofCaseOffset + 0, 0,
    (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)},
    // .ruby_fuzzer.IfElse ifelse = 2;
    {PROTOBUF_FIELD_OFFSET(Statement, _impl_.stmt_oneof_.ifelse_), _Internal::kOneofCaseOffset + 0, 1,
    (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)},
    // .ruby_fuzzer.Ternary ternary_stmt = 3;
    {PROTOBUF_FIELD_OFFSET(Statement, _impl_.stmt_oneof_.ternary_stmt_), _Internal::kOneofCaseOffset + 0, 2,
    (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)},
    // .ruby_fuzzer.BuiltinFuncs builtins = 4;
    {PROTOBUF_FIELD_OFFSET(Statement, _impl_.stmt_oneof_.builtins_), _Internal::kOneofCaseOffset + 0, 3,
    (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)},
    // .ruby_fuzzer.StatementSeq blockstmt = 5;
    {PROTOBUF_FIELD_OFFSET(Statement, _impl_.stmt_oneof_.blockstmt_), _Internal::kOneofCaseOffset + 0, 4,
    (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)},
  }}, {{
    {::_pbi::TcParser::GetTable<::ruby_fuzzer::AssignmentStatement>()},
    {::_pbi::TcParser::GetTable<::ruby_fuzzer::IfElse>()},
    {::_pbi::TcParser::GetTable<::ruby_fuzzer::Ternary>()},
    {::_pbi::TcParser::GetTable<::ruby_fuzzer::BuiltinFuncs>()},
    {::_pbi::TcParser::GetTable<::ruby_fuzzer::StatementSeq>()},
  }}, {{
  }},
};

PROTOBUF_NOINLINE void Statement::Clear() {
// @@protoc_insertion_point(message_clear_start:ruby_fuzzer.Statement)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_stmt_oneof();
  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
        ::uint8_t* Statement::_InternalSerialize(
            const MessageLite& base, ::uint8_t* target,
            ::google::protobuf::io::EpsCopyOutputStream* stream) {
          const Statement& this_ = static_cast<const Statement&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
        ::uint8_t* Statement::_InternalSerialize(
            ::uint8_t* target,
            ::google::protobuf::io::EpsCopyOutputStream* stream) const {
          const Statement& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
          // @@protoc_insertion_point(serialize_to_array_start:ruby_fuzzer.Statement)
          ::uint32_t cached_has_bits = 0;
          (void)cached_has_bits;

          switch (this_.stmt_oneof_case()) {
            case kAssignment: {
              target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
                  1, *this_._impl_.stmt_oneof_.assignment_, this_._impl_.stmt_oneof_.assignment_->GetCachedSize(), target,
                  stream);
              break;
            }
            case kIfelse: {
              target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
                  2, *this_._impl_.stmt_oneof_.ifelse_, this_._impl_.stmt_oneof_.ifelse_->GetCachedSize(), target,
                  stream);
              break;
            }
            case kTernaryStmt: {
              target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
                  3, *this_._impl_.stmt_oneof_.ternary_stmt_, this_._impl_.stmt_oneof_.ternary_stmt_->GetCachedSize(), target,
                  stream);
              break;
            }
            case kBuiltins: {
              target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
                  4, *this_._impl_.stmt_oneof_.builtins_, this_._impl_.stmt_oneof_.builtins_->GetCachedSize(), target,
                  stream);
              break;
            }
            case kBlockstmt: {
              target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
                  5, *this_._impl_.stmt_oneof_.blockstmt_, this_._impl_.stmt_oneof_.blockstmt_->GetCachedSize(), target,
                  stream);
              break;
            }
            default:
              break;
          }
          if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
            target =
                ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
                    this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
          }
          // @@protoc_insertion_point(serialize_to_array_end:ruby_fuzzer.Statement)
          return target;
        }

#if defined(PROTOBUF_CUSTOM_VTABLE)
        ::size_t Statement::ByteSizeLong(const MessageLite& base) {
          const Statement& this_ = static_cast<const Statement&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
        ::size_t Statement::ByteSizeLong() const {
          const Statement& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
          // @@protoc_insertion_point(message_byte_size_start:ruby_fuzzer.Statement)
          ::size_t total_size = 0;

          ::uint32_t cached_has_bits = 0;
          // Prevent compiler warnings about cached_has_bits being unused
          (void)cached_has_bits;

          switch (this_.stmt_oneof_case()) {
            // .ruby_fuzzer.AssignmentStatement assignment = 1;
            case kAssignment: {
              total_size += 1 +
                            ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.stmt_oneof_.assignment_);
              break;
            }
            // .ruby_fuzzer.IfElse ifelse = 2;
            case kIfelse: {
              total_size += 1 +
                            ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.stmt_oneof_.ifelse_);
              break;
            }
            // .ruby_fuzzer.Ternary ternary_stmt = 3;
            case kTernaryStmt: {
              total_size += 1 +
                            ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.stmt_oneof_.ternary_stmt_);
              break;
            }
            // .ruby_fuzzer.BuiltinFuncs builtins = 4;
            case kBuiltins: {
              total_size += 1 +
                            ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.stmt_oneof_.builtins_);
              break;
            }
            // .ruby_fuzzer.StatementSeq blockstmt = 5;
            case kBlockstmt: {
              total_size += 1 +
                            ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.stmt_oneof_.blockstmt_);
              break;
            }
            case STMT_ONEOF_NOT_SET: {
              break;
            }
          }
          return this_.MaybeComputeUnknownFieldsSize(total_size,
                                                     &this_._impl_._cached_size_);
        }

void Statement::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) {
  auto* const _this = static_cast<Statement*>(&to_msg);
  auto& from = static_cast<const Statement&>(from_msg);
  ::google::protobuf::Arena* arena = _this->GetArena();
  // @@protoc_insertion_point(class_specific_merge_from_start:ruby_fuzzer.Statement)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (const uint32_t oneof_from_case = from._impl_._oneof_case_[0]) {
    const uint32_t oneof_to_case = _this->_impl_._oneof_case_[0];
    const bool oneof_needs_init = oneof_to_case != oneof_from_case;
    if (oneof_needs_init) {
      if (oneof_to_case != 0) {
        _this->clear_stmt_oneof();
      }
      _this->_impl_._oneof_case_[0] = oneof_from_case;
    }

    switch (oneof_from_case) {
      case kAssignment: {
        if (oneof_needs_init) {
          _this->_impl_.stmt_oneof_.assignment_ =
              ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::AssignmentStatement>(arena, *from._impl_.stmt_oneof_.assignment_);
        } else {
          _this->_impl_.stmt_oneof_.assignment_->MergeFrom(from._internal_assignment());
        }
        break;
      }
      case kIfelse: {
        if (oneof_needs_init) {
          _this->_impl_.stmt_oneof_.ifelse_ =
              ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::IfElse>(arena, *from._impl_.stmt_oneof_.ifelse_);
        } else {
          _this->_impl_.stmt_oneof_.ifelse_->MergeFrom(from._internal_ifelse());
        }
        break;
      }
      case kTernaryStmt: {
        if (oneof_needs_init) {
          _this->_impl_.stmt_oneof_.ternary_stmt_ =
              ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::Ternary>(arena, *from._impl_.stmt_oneof_.ternary_stmt_);
        } else {
          _this->_impl_.stmt_oneof_.ternary_stmt_->MergeFrom(from._internal_ternary_stmt());
        }
        break;
      }
      case kBuiltins: {
        if (oneof_needs_init) {
          _this->_impl_.stmt_oneof_.builtins_ =
              ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::BuiltinFuncs>(arena, *from._impl_.stmt_oneof_.builtins_);
        } else {
          _this->_impl_.stmt_oneof_.builtins_->MergeFrom(from._internal_builtins());
        }
        break;
      }
      case kBlockstmt: {
        if (oneof_needs_init) {
          _this->_impl_.stmt_oneof_.blockstmt_ =
              ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::StatementSeq>(arena, *from._impl_.stmt_oneof_.blockstmt_);
        } else {
          _this->_impl_.stmt_oneof_.blockstmt_->MergeFrom(from._internal_blockstmt());
        }
        break;
      }
      case STMT_ONEOF_NOT_SET:
        break;
    }
  }
  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_);
}

void Statement::CopyFrom(const Statement& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:ruby_fuzzer.Statement)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

PROTOBUF_NOINLINE bool Statement::IsInitializedImpl(
    const MessageLite& msg) {
  auto& this_ = static_cast<const Statement&>(msg);
  switch (this_.stmt_oneof_case()) {
    case kAssignment: {
      if (this_.stmt_oneof_case() == kAssignment && !this_._impl_.stmt_oneof_.assignment_->IsInitialized())
        return false;
      break;
    }
    case kIfelse: {
      if (this_.stmt_oneof_case() == kIfelse && !this_._impl_.stmt_oneof_.ifelse_->IsInitialized())
        return false;
      break;
    }
    case kTernaryStmt: {
      if (this_.stmt_oneof_case() == kTernaryStmt && !this_._impl_.stmt_oneof_.ternary_stmt_->IsInitialized())
        return false;
      break;
    }
    case kBuiltins: {
      if (this_.stmt_oneof_case() == kBuiltins && !this_._impl_.stmt_oneof_.builtins_->IsInitialized())
        return false;
      break;
    }
    case kBlockstmt: {
      if (this_.stmt_oneof_case() == kBlockstmt && !this_._impl_.stmt_oneof_.blockstmt_->IsInitialized())
        return false;
      break;
    }
    case STMT_ONEOF_NOT_SET: {
      break;
    }
  }
  return true;
}

void Statement::InternalSwap(Statement* PROTOBUF_RESTRICT other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.stmt_oneof_, other->_impl_.stmt_oneof_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
}

::google::protobuf::Metadata Statement::GetMetadata() const {
  return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full());
}
// ===================================================================

class StatementSeq::_Internal {
 public:
};

StatementSeq::StatementSeq(::google::protobuf::Arena* arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, _class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:ruby_fuzzer.StatementSeq)
}
inline PROTOBUF_NDEBUG_INLINE StatementSeq::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena,
    const Impl_& from, const ::ruby_fuzzer::StatementSeq& from_msg)
      : statements_{visibility, arena, from.statements_},
        _cached_size_{0} {}

StatementSeq::StatementSeq(
    ::google::protobuf::Arena* arena,
    const StatementSeq& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, _class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  StatementSeq* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);

  // @@protoc_insertion_point(copy_constructor:ruby_fuzzer.StatementSeq)
}
inline PROTOBUF_NDEBUG_INLINE StatementSeq::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility,
    ::google::protobuf::Arena* arena)
      : statements_{visibility, arena},
        _cached_size_{0} {}

inline void StatementSeq::SharedCtor(::_pb::Arena* arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
}
StatementSeq::~StatementSeq() {
  // @@protoc_insertion_point(destructor:ruby_fuzzer.StatementSeq)
  SharedDtor(*this);
}
inline void StatementSeq::SharedDtor(MessageLite& self) {
  StatementSeq& this_ = static_cast<StatementSeq&>(self);
  this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  this_._impl_.~Impl_();
}

inline void* StatementSeq::PlacementNew_(const void*, void* mem,
                                        ::google::protobuf::Arena* arena) {
  return ::new (mem) StatementSeq(arena);
}
constexpr auto StatementSeq::InternalNewImpl_() {
  constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({
      PROTOBUF_FIELD_OFFSET(StatementSeq, _impl_.statements_) +
          decltype(StatementSeq::_impl_.statements_)::
              InternalGetArenaOffset(
                  ::google::protobuf::Message::internal_visibility()),
  });
  if (arena_bits.has_value()) {
    return ::google::protobuf::internal::MessageCreator::ZeroInit(
        sizeof(StatementSeq), alignof(StatementSeq), *arena_bits);
  } else {
    return ::google::protobuf::internal::MessageCreator(&StatementSeq::PlacementNew_,
                                 sizeof(StatementSeq),
                                 alignof(StatementSeq));
  }
}
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataFull StatementSeq::_class_data_ = {
    ::google::protobuf::internal::ClassData{
        &_StatementSeq_default_instance_._instance,
        &_table_.header,
        nullptr,  // OnDemandRegisterArenaDtor
        StatementSeq::IsInitializedImpl,
        &StatementSeq::MergeImpl,
        ::google::protobuf::Message::GetNewImpl<StatementSeq>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
        &StatementSeq::SharedDtor,
        ::google::protobuf::Message::GetClearImpl<StatementSeq>(), &StatementSeq::ByteSizeLong,
            &StatementSeq::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
        PROTOBUF_FIELD_OFFSET(StatementSeq, _impl_._cached_size_),
        false,
    },
    &StatementSeq::kDescriptorMethods,
    &descriptor_table_ruby_2eproto,
    nullptr,  // tracker
};
const ::google::protobuf::internal::ClassData* StatementSeq::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_);
  ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table);
  return _class_data_.base();
}
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::_pbi::TcParseTable<0, 1, 1, 0, 2> StatementSeq::_table_ = {
  {
    0,  // no _has_bits_
    0, // no _extensions_
    1, 0,  // max_field_number, fast_idx_mask
    offsetof(decltype(_table_), field_lookup_table),
    4294967294,  // skipmap
    offsetof(decltype(_table_), field_entries),
    1,  // num_field_entries
    1,  // num_aux_entries
    offsetof(decltype(_table_), aux_entries),
    _class_data_.base(),
    nullptr,  // post_loop_handler
    ::_pbi::TcParser::GenericFallback,  // fallback
    #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
    ::_pbi::TcParser::GetTable<::ruby_fuzzer::StatementSeq>(),  // to_prefetch
    #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
  }, {{
    // repeated .ruby_fuzzer.Statement statements = 1;
    {::_pbi::TcParser::FastMtR1,
     {10, 63, 0, PROTOBUF_FIELD_OFFSET(StatementSeq, _impl_.statements_)}},
  }}, {{
    65535, 65535
  }}, {{
    // repeated .ruby_fuzzer.Statement statements = 1;
    {PROTOBUF_FIELD_OFFSET(StatementSeq, _impl_.statements_), 0, 0,
    (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)},
  }}, {{
    {::_pbi::TcParser::GetTable<::ruby_fuzzer::Statement>()},
  }}, {{
  }},
};

PROTOBUF_NOINLINE void StatementSeq::Clear() {
// @@protoc_insertion_point(message_clear_start:ruby_fuzzer.StatementSeq)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.statements_.Clear();
  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
        ::uint8_t* StatementSeq::_InternalSerialize(
            const MessageLite& base, ::uint8_t* target,
            ::google::protobuf::io::EpsCopyOutputStream* stream) {
          const StatementSeq& this_ = static_cast<const StatementSeq&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
        ::uint8_t* StatementSeq::_InternalSerialize(
            ::uint8_t* target,
            ::google::protobuf::io::EpsCopyOutputStream* stream) const {
          const StatementSeq& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
          // @@protoc_insertion_point(serialize_to_array_start:ruby_fuzzer.StatementSeq)
          ::uint32_t cached_has_bits = 0;
          (void)cached_has_bits;

          // repeated .ruby_fuzzer.Statement statements = 1;
          for (unsigned i = 0, n = static_cast<unsigned>(
                                   this_._internal_statements_size());
               i < n; i++) {
            const auto& repfield = this_._internal_statements().Get(i);
            target =
                ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
                    1, repfield, repfield.GetCachedSize(),
                    target, stream);
          }

          if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
            target =
                ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
                    this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
          }
          // @@protoc_insertion_point(serialize_to_array_end:ruby_fuzzer.StatementSeq)
          return target;
        }

#if defined(PROTOBUF_CUSTOM_VTABLE)
        ::size_t StatementSeq::ByteSizeLong(const MessageLite& base) {
          const StatementSeq& this_ = static_cast<const StatementSeq&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
        ::size_t StatementSeq::ByteSizeLong() const {
          const StatementSeq& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
          // @@protoc_insertion_point(message_byte_size_start:ruby_fuzzer.StatementSeq)
          ::size_t total_size = 0;

          ::uint32_t cached_has_bits = 0;
          // Prevent compiler warnings about cached_has_bits being unused
          (void)cached_has_bits;

          ::_pbi::Prefetch5LinesFrom7Lines(&this_);
           {
            // repeated .ruby_fuzzer.Statement statements = 1;
            {
              total_size += 1UL * this_._internal_statements_size();
              for (const auto& msg : this_._internal_statements()) {
                total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg);
              }
            }
          }
          return this_.MaybeComputeUnknownFieldsSize(total_size,
                                                     &this_._impl_._cached_size_);
        }

void StatementSeq::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) {
  auto* const _this = static_cast<StatementSeq*>(&to_msg);
  auto& from = static_cast<const StatementSeq&>(from_msg);
  // @@protoc_insertion_point(class_specific_merge_from_start:ruby_fuzzer.StatementSeq)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_internal_mutable_statements()->MergeFrom(
      from._internal_statements());
  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_);
}

void StatementSeq::CopyFrom(const StatementSeq& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:ruby_fuzzer.StatementSeq)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

PROTOBUF_NOINLINE bool StatementSeq::IsInitializedImpl(
    const MessageLite& msg) {
  auto& this_ = static_cast<const StatementSeq&>(msg);
  if (!::google::protobuf::internal::AllAreInitialized(this_._internal_statements()))
    return false;
  return true;
}

void StatementSeq::InternalSwap(StatementSeq* PROTOBUF_RESTRICT other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  _impl_.statements_.InternalSwap(&other->_impl_.statements_);
}

::google::protobuf::Metadata StatementSeq::GetMetadata() const {
  return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full());
}
// ===================================================================

class Function::_Internal {
 public:
  using HasBits =
      decltype(std::declval<Function>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(Function, _impl_._has_bits_);
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0;
  }
};

Function::Function(::google::protobuf::Arena* arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, _class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:ruby_fuzzer.Function)
}
inline PROTOBUF_NDEBUG_INLINE Function::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena,
    const Impl_& from, const ::ruby_fuzzer::Function& from_msg)
      : _has_bits_{from._has_bits_},
        _cached_size_{0} {}

Function::Function(
    ::google::protobuf::Arena* arena,
    const Function& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, _class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  Function* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);
  ::uint32_t cached_has_bits = _impl_._has_bits_[0];
  _impl_.statements_ = (cached_has_bits & 0x00000001u) ? ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::StatementSeq>(
                              arena, *from._impl_.statements_)
                        : nullptr;

  // @@protoc_insertion_point(copy_constructor:ruby_fuzzer.Function)
}
inline PROTOBUF_NDEBUG_INLINE Function::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility,
    ::google::protobuf::Arena* arena)
      : _cached_size_{0} {}

inline void Function::SharedCtor(::_pb::Arena* arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  _impl_.statements_ = {};
}
Function::~Function() {
  // @@protoc_insertion_point(destructor:ruby_fuzzer.Function)
  SharedDtor(*this);
}
inline void Function::SharedDtor(MessageLite& self) {
  Function& this_ = static_cast<Function&>(self);
  this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  delete this_._impl_.statements_;
  this_._impl_.~Impl_();
}

inline void* Function::PlacementNew_(const void*, void* mem,
                                        ::google::protobuf::Arena* arena) {
  return ::new (mem) Function(arena);
}
constexpr auto Function::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(Function),
                                            alignof(Function));
}
PROTOBUF_CONSTINIT
PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::google::protobuf::internal::ClassDataFull Function::_class_data_ = {
    ::google::protobuf::internal::ClassData{
        &_Function_default_instance_._instance,
        &_table_.header,
        nullptr,  // OnDemandRegisterArenaDtor
        Function::IsInitializedImpl,
        &Function::MergeImpl,
        ::google::protobuf::Message::GetNewImpl<Function>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
        &Function::SharedDtor,
        ::google::protobuf::Message::GetClearImpl<Function>(), &Function::ByteSizeLong,
            &Function::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
        PROTOBUF_FIELD_OFFSET(Function, _impl_._cached_size_),
        false,
    },
    &Function::kDescriptorMethods,
    &descriptor_table_ruby_2eproto,
    nullptr,  // tracker
};
const ::google::protobuf::internal::ClassData* Function::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&_class_data_);
  ::google::protobuf::internal::PrefetchToLocalCache(_class_data_.tc_table);
  return _class_data_.base();
}
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::_pbi::TcParseTable<0, 1, 1, 0, 2> Function::_table_ = {
  {
    PROTOBUF_FIELD_OFFSET(Function, _impl_._has_bits_),
    0, // no _extensions_
    1, 0,  // max_field_number, fast_idx_mask
    offsetof(decltype(_table_), field_lookup_table),
    4294967294,  // skipmap
    offsetof(decltype(_table_), field_entries),
    1,  // num_field_entries
    1,  // num_aux_entries
    offsetof(decltype(_table_), aux_entries),
    _class_data_.base(),
    nullptr,  // post_loop_handler
    ::_pbi::TcParser::GenericFallback,  // fallback
    #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
    ::_pbi::TcParser::GetTable<::ruby_fuzzer::Function>(),  // to_prefetch
    #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
  }, {{
    // required .ruby_fuzzer.StatementSeq statements = 1;
    {::_pbi::TcParser::FastMtS1,
     {10, 0, 0, PROTOBUF_FIELD_OFFSET(Function, _impl_.statements_)}},
  }}, {{
    65535, 65535
  }}, {{
    // required .ruby_fuzzer.StatementSeq statements = 1;
    {PROTOBUF_FIELD_OFFSET(Function, _impl_.statements_), _Internal::kHasBitsOffset + 0, 0,
    (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
  }}, {{
    {::_pbi::TcParser::GetTable<::ruby_fuzzer::StatementSeq>()},
  }}, {{
  }},
};

PROTOBUF_NOINLINE void Function::Clear() {
// @@protoc_insertion_point(message_clear_start:ruby_fuzzer.Function)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    ABSL_DCHECK(_impl_.statements_ != nullptr);
    _impl_.statements_->Clear();
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
}

#if defined(PROTOBUF_CUSTOM_VTABLE)
        ::uint8_t* Function::_InternalSerialize(
            const MessageLite& base, ::uint8_t* target,
            ::google::protobuf::io::EpsCopyOutputStream* stream) {
          const Function& this_ = static_cast<const Function&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
        ::uint8_t* Function::_InternalSerialize(
            ::uint8_t* target,
            ::google::protobuf::io::EpsCopyOutputStream* stream) const {
          const Function& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
          // @@protoc_insertion_point(serialize_to_array_start:ruby_fuzzer.Function)
          ::uint32_t cached_has_bits = 0;
          (void)cached_has_bits;

          cached_has_bits = this_._impl_._has_bits_[0];
          // required .ruby_fuzzer.StatementSeq statements = 1;
          if (cached_has_bits & 0x00000001u) {
            target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
                1, *this_._impl_.statements_, this_._impl_.statements_->GetCachedSize(), target,
                stream);
          }

          if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
            target =
                ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
                    this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
          }
          // @@protoc_insertion_point(serialize_to_array_end:ruby_fuzzer.Function)
          return target;
        }

#if defined(PROTOBUF_CUSTOM_VTABLE)
        ::size_t Function::ByteSizeLong(const MessageLite& base) {
          const Function& this_ = static_cast<const Function&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
        ::size_t Function::ByteSizeLong() const {
          const Function& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
          // @@protoc_insertion_point(message_byte_size_start:ruby_fuzzer.Function)
          ::size_t total_size = 0;

          ::uint32_t cached_has_bits = 0;
          // Prevent compiler warnings about cached_has_bits being unused
          (void)cached_has_bits;

           {
            // required .ruby_fuzzer.StatementSeq statements = 1;
            cached_has_bits = this_._impl_._has_bits_[0];
            if (cached_has_bits & 0x00000001u) {
              total_size += 1 +
                            ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.statements_);
            }
          }
          return this_.MaybeComputeUnknownFieldsSize(total_size,
                                                     &this_._impl_._cached_size_);
        }

void Function::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) {
  auto* const _this = static_cast<Function*>(&to_msg);
  auto& from = static_cast<const Function&>(from_msg);
  ::google::protobuf::Arena* arena = _this->GetArena();
  // @@protoc_insertion_point(class_specific_merge_from_start:ruby_fuzzer.Function)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    ABSL_DCHECK(from._impl_.statements_ != nullptr);
    if (_this->_impl_.statements_ == nullptr) {
      _this->_impl_.statements_ =
          ::google::protobuf::Message::CopyConstruct<::ruby_fuzzer::StatementSeq>(arena, *from._impl_.statements_);
    } else {
      _this->_impl_.statements_->MergeFrom(*from._impl_.statements_);
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(from._internal_metadata_);
}

void Function::CopyFrom(const Function& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:ruby_fuzzer.Function)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

PROTOBUF_NOINLINE bool Function::IsInitializedImpl(
    const MessageLite& msg) {
  auto& this_ = static_cast<const Function&>(msg);
  if (_Internal::MissingRequiredFields(this_._impl_._has_bits_)) {
    return false;
  }
  if ((this_._impl_._has_bits_[0] & 0x00000001u) != 0) {
    if (!this_._impl_.statements_->IsInitialized()) return false;
  }
  return true;
}

void Function::InternalSwap(Function* PROTOBUF_RESTRICT other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  swap(_impl_.statements_, other->_impl_.statements_);
}

::google::protobuf::Metadata Function::GetMetadata() const {
  return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full());
}
// @@protoc_insertion_point(namespace_scope)
}  // namespace ruby_fuzzer
namespace google {
namespace protobuf {
}  // namespace protobuf
}  // namespace google
// @@protoc_insertion_point(global_scope)
PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::std::false_type
    _static_init2_ PROTOBUF_UNUSED =
        (::_pbi::AddDescriptors(&descriptor_table_ruby_2eproto),
         ::std::false_type{});
#include "google/protobuf/port_undef.inc"

Coverage Report

Created: 2025-06-13 07:32