Coverage Report

Created: 2023-06-07 07:09

/src/mruby/genfiles/ruby.pb.h
Line
Count
Source (jump to first uncovered line)
1
// Generated by the protocol buffer compiler.  DO NOT EDIT!
2
// source: ruby.proto
3
4
#ifndef GOOGLE_PROTOBUF_INCLUDED_ruby_2eproto_2epb_2eh
5
#define GOOGLE_PROTOBUF_INCLUDED_ruby_2eproto_2epb_2eh
6
7
#include <limits>
8
#include <string>
9
#include <type_traits>
10
11
#include "google/protobuf/port_def.inc"
12
#if PROTOBUF_VERSION < 4022000
13
#error "This file was generated by a newer version of protoc which is"
14
#error "incompatible with your Protocol Buffer headers. Please update"
15
#error "your headers."
16
#endif  // PROTOBUF_VERSION
17
18
#if 4022003 < PROTOBUF_MIN_PROTOC_VERSION
19
#error "This file was generated by an older version of protoc which is"
20
#error "incompatible with your Protocol Buffer headers. Please"
21
#error "regenerate this file with a newer version of protoc."
22
#endif  // PROTOBUF_MIN_PROTOC_VERSION
23
#include "google/protobuf/port_undef.inc"
24
#include "google/protobuf/io/coded_stream.h"
25
#include "google/protobuf/arena.h"
26
#include "google/protobuf/arenastring.h"
27
#include "google/protobuf/generated_message_util.h"
28
#include "google/protobuf/metadata_lite.h"
29
#include "google/protobuf/generated_message_reflection.h"
30
#include "google/protobuf/message.h"
31
#include "google/protobuf/repeated_field.h"  // IWYU pragma: export
32
#include "google/protobuf/extension_set.h"  // IWYU pragma: export
33
#include "google/protobuf/generated_enum_reflection.h"
34
#include "google/protobuf/unknown_field_set.h"
35
// @@protoc_insertion_point(includes)
36
37
// Must be included last.
38
#include "google/protobuf/port_def.inc"
39
40
#define PROTOBUF_INTERNAL_EXPORT_ruby_2eproto
41
42
PROTOBUF_NAMESPACE_OPEN
43
namespace internal {
44
class AnyMetadata;
45
}  // namespace internal
46
PROTOBUF_NAMESPACE_CLOSE
47
48
// Internal implementation detail -- do not use these members.
49
struct TableStruct_ruby_2eproto {
50
  static const ::uint32_t offsets[];
51
};
52
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable
53
    descriptor_table_ruby_2eproto;
54
namespace ruby_fuzzer {
55
class ArrType;
56
struct ArrTypeDefaultTypeInternal;
57
extern ArrTypeDefaultTypeInternal _ArrType_default_instance_;
58
class Array;
59
struct ArrayDefaultTypeInternal;
60
extern ArrayDefaultTypeInternal _Array_default_instance_;
61
class AssignmentStatement;
62
struct AssignmentStatementDefaultTypeInternal;
63
extern AssignmentStatementDefaultTypeInternal _AssignmentStatement_default_instance_;
64
class BinaryOp;
65
struct BinaryOpDefaultTypeInternal;
66
extern BinaryOpDefaultTypeInternal _BinaryOp_default_instance_;
67
class BuiltinFuncs;
68
struct BuiltinFuncsDefaultTypeInternal;
69
extern BuiltinFuncsDefaultTypeInternal _BuiltinFuncs_default_instance_;
70
class Const;
71
struct ConstDefaultTypeInternal;
72
extern ConstDefaultTypeInternal _Const_default_instance_;
73
class Function;
74
struct FunctionDefaultTypeInternal;
75
extern FunctionDefaultTypeInternal _Function_default_instance_;
76
class HashType;
77
struct HashTypeDefaultTypeInternal;
78
extern HashTypeDefaultTypeInternal _HashType_default_instance_;
79
class IfElse;
80
struct IfElseDefaultTypeInternal;
81
extern IfElseDefaultTypeInternal _IfElse_default_instance_;
82
class KVPair;
83
struct KVPairDefaultTypeInternal;
84
extern KVPairDefaultTypeInternal _KVPair_default_instance_;
85
class MathConst;
86
struct MathConstDefaultTypeInternal;
87
extern MathConstDefaultTypeInternal _MathConst_default_instance_;
88
class MathOps;
89
struct MathOpsDefaultTypeInternal;
90
extern MathOpsDefaultTypeInternal _MathOps_default_instance_;
91
class MathType;
92
struct MathTypeDefaultTypeInternal;
93
extern MathTypeDefaultTypeInternal _MathType_default_instance_;
94
class ObjectSpace;
95
struct ObjectSpaceDefaultTypeInternal;
96
extern ObjectSpaceDefaultTypeInternal _ObjectSpace_default_instance_;
97
class Rvalue;
98
struct RvalueDefaultTypeInternal;
99
extern RvalueDefaultTypeInternal _Rvalue_default_instance_;
100
class Statement;
101
struct StatementDefaultTypeInternal;
102
extern StatementDefaultTypeInternal _Statement_default_instance_;
103
class StatementSeq;
104
struct StatementSeqDefaultTypeInternal;
105
extern StatementSeqDefaultTypeInternal _StatementSeq_default_instance_;
106
class StringExtNoArg;
107
struct StringExtNoArgDefaultTypeInternal;
108
extern StringExtNoArgDefaultTypeInternal _StringExtNoArg_default_instance_;
109
class Ternary;
110
struct TernaryDefaultTypeInternal;
111
extern TernaryDefaultTypeInternal _Ternary_default_instance_;
112
class Time;
113
struct TimeDefaultTypeInternal;
114
extern TimeDefaultTypeInternal _Time_default_instance_;
115
class VarRef;
116
struct VarRefDefaultTypeInternal;
117
extern VarRefDefaultTypeInternal _VarRef_default_instance_;
118
}  // namespace ruby_fuzzer
119
PROTOBUF_NAMESPACE_OPEN
120
template <>
121
::ruby_fuzzer::ArrType* Arena::CreateMaybeMessage<::ruby_fuzzer::ArrType>(Arena*);
122
template <>
123
::ruby_fuzzer::Array* Arena::CreateMaybeMessage<::ruby_fuzzer::Array>(Arena*);
124
template <>
125
::ruby_fuzzer::AssignmentStatement* Arena::CreateMaybeMessage<::ruby_fuzzer::AssignmentStatement>(Arena*);
126
template <>
127
::ruby_fuzzer::BinaryOp* Arena::CreateMaybeMessage<::ruby_fuzzer::BinaryOp>(Arena*);
128
template <>
129
::ruby_fuzzer::BuiltinFuncs* Arena::CreateMaybeMessage<::ruby_fuzzer::BuiltinFuncs>(Arena*);
130
template <>
131
::ruby_fuzzer::Const* Arena::CreateMaybeMessage<::ruby_fuzzer::Const>(Arena*);
132
template <>
133
::ruby_fuzzer::Function* Arena::CreateMaybeMessage<::ruby_fuzzer::Function>(Arena*);
134
template <>
135
::ruby_fuzzer::HashType* Arena::CreateMaybeMessage<::ruby_fuzzer::HashType>(Arena*);
136
template <>
137
::ruby_fuzzer::IfElse* Arena::CreateMaybeMessage<::ruby_fuzzer::IfElse>(Arena*);
138
template <>
139
::ruby_fuzzer::KVPair* Arena::CreateMaybeMessage<::ruby_fuzzer::KVPair>(Arena*);
140
template <>
141
::ruby_fuzzer::MathConst* Arena::CreateMaybeMessage<::ruby_fuzzer::MathConst>(Arena*);
142
template <>
143
::ruby_fuzzer::MathOps* Arena::CreateMaybeMessage<::ruby_fuzzer::MathOps>(Arena*);
144
template <>
145
::ruby_fuzzer::MathType* Arena::CreateMaybeMessage<::ruby_fuzzer::MathType>(Arena*);
146
template <>
147
::ruby_fuzzer::ObjectSpace* Arena::CreateMaybeMessage<::ruby_fuzzer::ObjectSpace>(Arena*);
148
template <>
149
::ruby_fuzzer::Rvalue* Arena::CreateMaybeMessage<::ruby_fuzzer::Rvalue>(Arena*);
150
template <>
151
::ruby_fuzzer::Statement* Arena::CreateMaybeMessage<::ruby_fuzzer::Statement>(Arena*);
152
template <>
153
::ruby_fuzzer::StatementSeq* Arena::CreateMaybeMessage<::ruby_fuzzer::StatementSeq>(Arena*);
154
template <>
155
::ruby_fuzzer::StringExtNoArg* Arena::CreateMaybeMessage<::ruby_fuzzer::StringExtNoArg>(Arena*);
156
template <>
157
::ruby_fuzzer::Ternary* Arena::CreateMaybeMessage<::ruby_fuzzer::Ternary>(Arena*);
158
template <>
159
::ruby_fuzzer::Time* Arena::CreateMaybeMessage<::ruby_fuzzer::Time>(Arena*);
160
template <>
161
::ruby_fuzzer::VarRef* Arena::CreateMaybeMessage<::ruby_fuzzer::VarRef>(Arena*);
162
PROTOBUF_NAMESPACE_CLOSE
163
164
namespace ruby_fuzzer {
165
enum StringExtNoArg_StrExtOp : int {
166
  StringExtNoArg_StrExtOp_DUMP = 0,
167
  StringExtNoArg_StrExtOp_STRIP = 1,
168
  StringExtNoArg_StrExtOp_LSTRIP = 2,
169
  StringExtNoArg_StrExtOp_RSTRIP = 3,
170
  StringExtNoArg_StrExtOp_STRIPE = 4,
171
  StringExtNoArg_StrExtOp_LSTRIPE = 5,
172
  StringExtNoArg_StrExtOp_RSTRIPE = 6,
173
  StringExtNoArg_StrExtOp_SWAPCASE = 7,
174
  StringExtNoArg_StrExtOp_SWAPCASEE = 8,
175
  StringExtNoArg_StrExtOp_SQUEEZE = 9,
176
};
177
178
bool StringExtNoArg_StrExtOp_IsValid(int value);
179
constexpr StringExtNoArg_StrExtOp StringExtNoArg_StrExtOp_StrExtOp_MIN = static_cast<StringExtNoArg_StrExtOp>(0);
180
constexpr StringExtNoArg_StrExtOp StringExtNoArg_StrExtOp_StrExtOp_MAX = static_cast<StringExtNoArg_StrExtOp>(9);
181
constexpr int StringExtNoArg_StrExtOp_StrExtOp_ARRAYSIZE = 9 + 1;
182
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
183
StringExtNoArg_StrExtOp_descriptor();
184
template <typename T>
185
const std::string& StringExtNoArg_StrExtOp_Name(T value) {
186
  static_assert(std::is_same<T, StringExtNoArg_StrExtOp>::value ||
187
                    std::is_integral<T>::value,
188
                "Incorrect type passed to StrExtOp_Name().");
189
  return StringExtNoArg_StrExtOp_Name(static_cast<StringExtNoArg_StrExtOp>(value));
190
}
191
template <>
192
0
inline const std::string& StringExtNoArg_StrExtOp_Name(StringExtNoArg_StrExtOp value) {
193
0
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfDenseEnum<StringExtNoArg_StrExtOp_descriptor,
194
0
                                                 0, 9>(
195
0
      static_cast<int>(value));
196
0
}
197
0
inline bool StringExtNoArg_StrExtOp_Parse(absl::string_view name, StringExtNoArg_StrExtOp* value) {
198
0
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<StringExtNoArg_StrExtOp>(
199
0
      StringExtNoArg_StrExtOp_descriptor(), name, value);
200
0
}
201
enum MathConst_MathConstLit : int {
202
  MathConst_MathConstLit_PI = 0,
203
  MathConst_MathConstLit_E = 1,
204
};
205
206
bool MathConst_MathConstLit_IsValid(int value);
207
constexpr MathConst_MathConstLit MathConst_MathConstLit_MathConstLit_MIN = static_cast<MathConst_MathConstLit>(0);
208
constexpr MathConst_MathConstLit MathConst_MathConstLit_MathConstLit_MAX = static_cast<MathConst_MathConstLit>(1);
209
constexpr int MathConst_MathConstLit_MathConstLit_ARRAYSIZE = 1 + 1;
210
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
211
MathConst_MathConstLit_descriptor();
212
template <typename T>
213
const std::string& MathConst_MathConstLit_Name(T value) {
214
  static_assert(std::is_same<T, MathConst_MathConstLit>::value ||
215
                    std::is_integral<T>::value,
216
                "Incorrect type passed to MathConstLit_Name().");
217
  return MathConst_MathConstLit_Name(static_cast<MathConst_MathConstLit>(value));
218
}
219
template <>
220
0
inline const std::string& MathConst_MathConstLit_Name(MathConst_MathConstLit value) {
221
0
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfDenseEnum<MathConst_MathConstLit_descriptor,
222
0
                                                 0, 1>(
223
0
      static_cast<int>(value));
224
0
}
225
0
inline bool MathConst_MathConstLit_Parse(absl::string_view name, MathConst_MathConstLit* value) {
226
0
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<MathConst_MathConstLit>(
227
0
      MathConst_MathConstLit_descriptor(), name, value);
228
0
}
229
enum BinaryOp_Op : int {
230
  BinaryOp_Op_ADD = 0,
231
  BinaryOp_Op_SUB = 1,
232
  BinaryOp_Op_MUL = 2,
233
  BinaryOp_Op_DIV = 3,
234
  BinaryOp_Op_MOD = 4,
235
  BinaryOp_Op_XOR = 5,
236
  BinaryOp_Op_AND = 6,
237
  BinaryOp_Op_OR = 7,
238
  BinaryOp_Op_EQ = 8,
239
  BinaryOp_Op_NE = 9,
240
  BinaryOp_Op_LE = 10,
241
  BinaryOp_Op_GE = 11,
242
  BinaryOp_Op_LT = 12,
243
  BinaryOp_Op_GT = 13,
244
  BinaryOp_Op_RS = 14,
245
};
246
247
bool BinaryOp_Op_IsValid(int value);
248
constexpr BinaryOp_Op BinaryOp_Op_Op_MIN = static_cast<BinaryOp_Op>(0);
249
constexpr BinaryOp_Op BinaryOp_Op_Op_MAX = static_cast<BinaryOp_Op>(14);
250
constexpr int BinaryOp_Op_Op_ARRAYSIZE = 14 + 1;
251
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
252
BinaryOp_Op_descriptor();
253
template <typename T>
254
const std::string& BinaryOp_Op_Name(T value) {
255
  static_assert(std::is_same<T, BinaryOp_Op>::value ||
256
                    std::is_integral<T>::value,
257
                "Incorrect type passed to Op_Name().");
258
  return BinaryOp_Op_Name(static_cast<BinaryOp_Op>(value));
259
}
260
template <>
261
0
inline const std::string& BinaryOp_Op_Name(BinaryOp_Op value) {
262
0
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfDenseEnum<BinaryOp_Op_descriptor,
263
0
                                                 0, 14>(
264
0
      static_cast<int>(value));
265
0
}
266
0
inline bool BinaryOp_Op_Parse(absl::string_view name, BinaryOp_Op* value) {
267
0
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<BinaryOp_Op>(
268
0
      BinaryOp_Op_descriptor(), name, value);
269
0
}
270
enum ObjectSpace_OS_methods : int {
271
  ObjectSpace_OS_methods_COUNT = 1,
272
};
273
274
bool ObjectSpace_OS_methods_IsValid(int value);
275
constexpr ObjectSpace_OS_methods ObjectSpace_OS_methods_OS_methods_MIN = static_cast<ObjectSpace_OS_methods>(1);
276
constexpr ObjectSpace_OS_methods ObjectSpace_OS_methods_OS_methods_MAX = static_cast<ObjectSpace_OS_methods>(1);
277
constexpr int ObjectSpace_OS_methods_OS_methods_ARRAYSIZE = 1 + 1;
278
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
279
ObjectSpace_OS_methods_descriptor();
280
template <typename T>
281
const std::string& ObjectSpace_OS_methods_Name(T value) {
282
  static_assert(std::is_same<T, ObjectSpace_OS_methods>::value ||
283
                    std::is_integral<T>::value,
284
                "Incorrect type passed to OS_methods_Name().");
285
  return ObjectSpace_OS_methods_Name(static_cast<ObjectSpace_OS_methods>(value));
286
}
287
template <>
288
0
inline const std::string& ObjectSpace_OS_methods_Name(ObjectSpace_OS_methods value) {
289
0
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfDenseEnum<ObjectSpace_OS_methods_descriptor,
290
0
                                                 1, 1>(
291
0
      static_cast<int>(value));
292
0
}
293
0
inline bool ObjectSpace_OS_methods_Parse(absl::string_view name, ObjectSpace_OS_methods* value) {
294
0
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ObjectSpace_OS_methods>(
295
0
      ObjectSpace_OS_methods_descriptor(), name, value);
296
0
}
297
enum Time_T_methods : int {
298
  Time_T_methods_AT = 1,
299
  Time_T_methods_GM = 2,
300
};
301
302
bool Time_T_methods_IsValid(int value);
303
constexpr Time_T_methods Time_T_methods_T_methods_MIN = static_cast<Time_T_methods>(1);
304
constexpr Time_T_methods Time_T_methods_T_methods_MAX = static_cast<Time_T_methods>(2);
305
constexpr int Time_T_methods_T_methods_ARRAYSIZE = 2 + 1;
306
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
307
Time_T_methods_descriptor();
308
template <typename T>
309
const std::string& Time_T_methods_Name(T value) {
310
  static_assert(std::is_same<T, Time_T_methods>::value ||
311
                    std::is_integral<T>::value,
312
                "Incorrect type passed to T_methods_Name().");
313
  return Time_T_methods_Name(static_cast<Time_T_methods>(value));
314
}
315
template <>
316
0
inline const std::string& Time_T_methods_Name(Time_T_methods value) {
317
0
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfDenseEnum<Time_T_methods_descriptor,
318
0
                                                 1, 2>(
319
0
      static_cast<int>(value));
320
0
}
321
0
inline bool Time_T_methods_Parse(absl::string_view name, Time_T_methods* value) {
322
0
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Time_T_methods>(
323
0
      Time_T_methods_descriptor(), name, value);
324
0
}
325
enum Array_Arr_methods : int {
326
  Array_Arr_methods_FLATTEN = 1,
327
  Array_Arr_methods_COMPACT = 2,
328
  Array_Arr_methods_FETCH = 3,
329
  Array_Arr_methods_FILL = 4,
330
  Array_Arr_methods_ROTATE = 5,
331
  Array_Arr_methods_ROTATE_E = 6,
332
  Array_Arr_methods_DELETEIF = 7,
333
  Array_Arr_methods_INSERT = 8,
334
  Array_Arr_methods_BSEARCH = 9,
335
  Array_Arr_methods_KEEPIF = 10,
336
  Array_Arr_methods_SELECT = 11,
337
  Array_Arr_methods_VALUES_AT = 12,
338
  Array_Arr_methods_BLOCK = 13,
339
  Array_Arr_methods_DIG = 14,
340
  Array_Arr_methods_SLICE = 15,
341
  Array_Arr_methods_PERM = 16,
342
  Array_Arr_methods_COMB = 17,
343
  Array_Arr_methods_ASSOC = 18,
344
  Array_Arr_methods_RASSOC = 19,
345
};
346
347
bool Array_Arr_methods_IsValid(int value);
348
constexpr Array_Arr_methods Array_Arr_methods_Arr_methods_MIN = static_cast<Array_Arr_methods>(1);
349
constexpr Array_Arr_methods Array_Arr_methods_Arr_methods_MAX = static_cast<Array_Arr_methods>(19);
350
constexpr int Array_Arr_methods_Arr_methods_ARRAYSIZE = 19 + 1;
351
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
352
Array_Arr_methods_descriptor();
353
template <typename T>
354
const std::string& Array_Arr_methods_Name(T value) {
355
  static_assert(std::is_same<T, Array_Arr_methods>::value ||
356
                    std::is_integral<T>::value,
357
                "Incorrect type passed to Arr_methods_Name().");
358
  return Array_Arr_methods_Name(static_cast<Array_Arr_methods>(value));
359
}
360
template <>
361
0
inline const std::string& Array_Arr_methods_Name(Array_Arr_methods value) {
362
0
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfDenseEnum<Array_Arr_methods_descriptor,
363
0
                                                 1, 19>(
364
0
      static_cast<int>(value));
365
0
}
366
0
inline bool Array_Arr_methods_Parse(absl::string_view name, Array_Arr_methods* value) {
367
0
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Array_Arr_methods>(
368
0
      Array_Arr_methods_descriptor(), name, value);
369
0
}
370
enum MathOps_Mops : int {
371
  MathOps_Mops_CBRT = 1,
372
  MathOps_Mops_COS = 2,
373
  MathOps_Mops_ERF = 3,
374
  MathOps_Mops_ERFC = 4,
375
  MathOps_Mops_LOG = 5,
376
  MathOps_Mops_LOG10 = 6,
377
  MathOps_Mops_LOG2 = 7,
378
  MathOps_Mops_SIN = 8,
379
  MathOps_Mops_SQRT = 9,
380
  MathOps_Mops_TAN = 10,
381
};
382
383
bool MathOps_Mops_IsValid(int value);
384
constexpr MathOps_Mops MathOps_Mops_Mops_MIN = static_cast<MathOps_Mops>(1);
385
constexpr MathOps_Mops MathOps_Mops_Mops_MAX = static_cast<MathOps_Mops>(10);
386
constexpr int MathOps_Mops_Mops_ARRAYSIZE = 10 + 1;
387
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
388
MathOps_Mops_descriptor();
389
template <typename T>
390
const std::string& MathOps_Mops_Name(T value) {
391
  static_assert(std::is_same<T, MathOps_Mops>::value ||
392
                    std::is_integral<T>::value,
393
                "Incorrect type passed to Mops_Name().");
394
  return MathOps_Mops_Name(static_cast<MathOps_Mops>(value));
395
}
396
template <>
397
0
inline const std::string& MathOps_Mops_Name(MathOps_Mops value) {
398
0
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfDenseEnum<MathOps_Mops_descriptor,
399
0
                                                 1, 10>(
400
0
      static_cast<int>(value));
401
0
}
402
0
inline bool MathOps_Mops_Parse(absl::string_view name, MathOps_Mops* value) {
403
0
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<MathOps_Mops>(
404
0
      MathOps_Mops_descriptor(), name, value);
405
0
}
406
407
// ===================================================================
408
409
410
// -------------------------------------------------------------------
411
412
class VarRef final :
413
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ruby_fuzzer.VarRef) */ {
414
 public:
415
0
  inline VarRef() : VarRef(nullptr) {}
416
  ~VarRef() override;
417
  explicit PROTOBUF_CONSTEXPR VarRef(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
418
419
  VarRef(const VarRef& from);
420
  VarRef(VarRef&& from) noexcept
421
0
    : VarRef() {
422
0
    *this = ::std::move(from);
423
0
  }
424
425
0
  inline VarRef& operator=(const VarRef& from) {
426
0
    CopyFrom(from);
427
0
    return *this;
428
0
  }
429
0
  inline VarRef& operator=(VarRef&& from) noexcept {
430
0
    if (this == &from) return *this;
431
0
    if (GetOwningArena() == from.GetOwningArena()
432
0
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
433
0
        && GetOwningArena() != nullptr
434
0
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
435
0
    ) {
436
0
      InternalSwap(&from);
437
0
    } else {
438
0
      CopyFrom(from);
439
0
    }
440
0
    return *this;
441
0
  }
442
443
0
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
444
0
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
445
0
  }
446
0
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
447
0
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
448
0
  }
449
450
0
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
451
0
    return GetDescriptor();
452
0
  }
453
0
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
454
0
    return default_instance().GetMetadata().descriptor;
455
0
  }
456
0
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
457
0
    return default_instance().GetMetadata().reflection;
458
0
  }
459
0
  static const VarRef& default_instance() {
460
0
    return *internal_default_instance();
461
0
  }
462
0
  static inline const VarRef* internal_default_instance() {
463
0
    return reinterpret_cast<const VarRef*>(
464
0
               &_VarRef_default_instance_);
465
0
  }
466
  static constexpr int kIndexInFileMessages =
467
    0;
468
469
0
  friend void swap(VarRef& a, VarRef& b) {
470
0
    a.Swap(&b);
471
0
  }
472
0
  inline void Swap(VarRef* other) {
473
0
    if (other == this) return;
474
0
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
475
0
    if (GetOwningArena() != nullptr &&
476
0
        GetOwningArena() == other->GetOwningArena()) {
477
0
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
478
0
    if (GetOwningArena() == other->GetOwningArena()) {
479
0
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
480
0
      InternalSwap(other);
481
0
    } else {
482
0
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
483
0
    }
484
0
  }
485
0
  void UnsafeArenaSwap(VarRef* other) {
486
0
    if (other == this) return;
487
0
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
488
0
    InternalSwap(other);
489
0
  }
490
491
  // implements Message ----------------------------------------------
492
493
73.2k
  VarRef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
494
73.2k
    return CreateMaybeMessage<VarRef>(arena);
495
73.2k
  }
496
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
497
  void CopyFrom(const VarRef& from);
498
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
499
0
  void MergeFrom( const VarRef& from) {
500
0
    VarRef::MergeImpl(*this, from);
501
0
  }
502
  private:
503
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
504
  public:
505
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
506
  bool IsInitialized() const final;
507
508
  ::size_t ByteSizeLong() const final;
509
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
510
  ::uint8_t* _InternalSerialize(
511
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
512
0
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
513
514
  private:
515
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
516
  void SharedDtor();
517
  void SetCachedSize(int size) const final;
518
  void InternalSwap(VarRef* other);
519
520
  private:
521
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
522
0
  static ::absl::string_view FullMessageName() {
523
0
    return "ruby_fuzzer.VarRef";
524
0
  }
525
  protected:
526
  explicit VarRef(::PROTOBUF_NAMESPACE_ID::Arena* arena);
527
  public:
528
529
  static const ClassData _class_data_;
530
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
531
532
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
533
534
  // nested types ----------------------------------------------------
535
536
  // accessors -------------------------------------------------------
537
538
  enum : int {
539
    kVarnumFieldNumber = 1,
540
  };
541
  // required int32 varnum = 1;
542
  bool has_varnum() const;
543
  void clear_varnum() ;
544
  ::int32_t varnum() const;
545
  void set_varnum(::int32_t value);
546
547
  private:
548
  ::int32_t _internal_varnum() const;
549
  void _internal_set_varnum(::int32_t value);
550
551
  public:
552
  // @@protoc_insertion_point(class_scope:ruby_fuzzer.VarRef)
553
 private:
554
  class _Internal;
555
556
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
557
  typedef void InternalArenaConstructable_;
558
  typedef void DestructorSkippable_;
559
  struct Impl_ {
560
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
561
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
562
    ::int32_t varnum_;
563
  };
564
  union { Impl_ _impl_; };
565
  friend struct ::TableStruct_ruby_2eproto;
566
};// -------------------------------------------------------------------
567
568
class ArrType final :
569
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ruby_fuzzer.ArrType) */ {
570
 public:
571
0
  inline ArrType() : ArrType(nullptr) {}
572
  ~ArrType() override;
573
  explicit PROTOBUF_CONSTEXPR ArrType(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
574
575
  ArrType(const ArrType& from);
576
  ArrType(ArrType&& from) noexcept
577
0
    : ArrType() {
578
0
    *this = ::std::move(from);
579
0
  }
580
581
0
  inline ArrType& operator=(const ArrType& from) {
582
0
    CopyFrom(from);
583
0
    return *this;
584
0
  }
585
0
  inline ArrType& operator=(ArrType&& from) noexcept {
586
0
    if (this == &from) return *this;
587
0
    if (GetOwningArena() == from.GetOwningArena()
588
0
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
589
0
        && GetOwningArena() != nullptr
590
0
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
591
0
    ) {
592
0
      InternalSwap(&from);
593
0
    } else {
594
0
      CopyFrom(from);
595
0
    }
596
0
    return *this;
597
0
  }
598
599
0
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
600
0
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
601
0
  }
602
0
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
603
0
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
604
0
  }
605
606
0
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
607
0
    return GetDescriptor();
608
0
  }
609
0
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
610
0
    return default_instance().GetMetadata().descriptor;
611
0
  }
612
0
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
613
0
    return default_instance().GetMetadata().reflection;
614
0
  }
615
0
  static const ArrType& default_instance() {
616
0
    return *internal_default_instance();
617
0
  }
618
0
  static inline const ArrType* internal_default_instance() {
619
0
    return reinterpret_cast<const ArrType*>(
620
0
               &_ArrType_default_instance_);
621
0
  }
622
  static constexpr int kIndexInFileMessages =
623
    1;
624
625
0
  friend void swap(ArrType& a, ArrType& b) {
626
0
    a.Swap(&b);
627
0
  }
628
0
  inline void Swap(ArrType* other) {
629
0
    if (other == this) return;
630
0
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
631
0
    if (GetOwningArena() != nullptr &&
632
0
        GetOwningArena() == other->GetOwningArena()) {
633
0
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
634
0
    if (GetOwningArena() == other->GetOwningArena()) {
635
0
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
636
0
      InternalSwap(other);
637
0
    } else {
638
0
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
639
0
    }
640
0
  }
641
0
  void UnsafeArenaSwap(ArrType* other) {
642
0
    if (other == this) return;
643
0
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
644
0
    InternalSwap(other);
645
0
  }
646
647
  // implements Message ----------------------------------------------
648
649
58.5k
  ArrType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
650
58.5k
    return CreateMaybeMessage<ArrType>(arena);
651
58.5k
  }
652
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
653
  void CopyFrom(const ArrType& from);
654
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
655
0
  void MergeFrom( const ArrType& from) {
656
0
    ArrType::MergeImpl(*this, from);
657
0
  }
658
  private:
659
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
660
  public:
661
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
662
  bool IsInitialized() const final;
663
664
  ::size_t ByteSizeLong() const final;
665
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
666
  ::uint8_t* _InternalSerialize(
667
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
668
0
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
669
670
  private:
671
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
672
  void SharedDtor();
673
  void SetCachedSize(int size) const final;
674
  void InternalSwap(ArrType* other);
675
676
  private:
677
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
678
0
  static ::absl::string_view FullMessageName() {
679
0
    return "ruby_fuzzer.ArrType";
680
0
  }
681
  protected:
682
  explicit ArrType(::PROTOBUF_NAMESPACE_ID::Arena* arena);
683
  public:
684
685
  static const ClassData _class_data_;
686
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
687
688
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
689
690
  // nested types ----------------------------------------------------
691
692
  // accessors -------------------------------------------------------
693
694
  enum : int {
695
    kElementsFieldNumber = 1,
696
  };
697
  // repeated .ruby_fuzzer.Const elements = 1;
698
  int elements_size() const;
699
  private:
700
  int _internal_elements_size() const;
701
702
  public:
703
  void clear_elements() ;
704
  ::ruby_fuzzer::Const* mutable_elements(int index);
705
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::ruby_fuzzer::Const >*
706
      mutable_elements();
707
  private:
708
  const ::ruby_fuzzer::Const& _internal_elements(int index) const;
709
  ::ruby_fuzzer::Const* _internal_add_elements();
710
  public:
711
  const ::ruby_fuzzer::Const& elements(int index) const;
712
  ::ruby_fuzzer::Const* add_elements();
713
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::ruby_fuzzer::Const >&
714
      elements() const;
715
  // @@protoc_insertion_point(class_scope:ruby_fuzzer.ArrType)
716
 private:
717
  class _Internal;
718
719
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
720
  typedef void InternalArenaConstructable_;
721
  typedef void DestructorSkippable_;
722
  struct Impl_ {
723
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::ruby_fuzzer::Const > elements_;
724
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
725
  };
726
  union { Impl_ _impl_; };
727
  friend struct ::TableStruct_ruby_2eproto;
728
};// -------------------------------------------------------------------
729
730
class KVPair final :
731
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ruby_fuzzer.KVPair) */ {
732
 public:
733
0
  inline KVPair() : KVPair(nullptr) {}
734
  ~KVPair() override;
735
  explicit PROTOBUF_CONSTEXPR KVPair(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
736
737
  KVPair(const KVPair& from);
738
  KVPair(KVPair&& from) noexcept
739
0
    : KVPair() {
740
0
    *this = ::std::move(from);
741
0
  }
742
743
0
  inline KVPair& operator=(const KVPair& from) {
744
0
    CopyFrom(from);
745
0
    return *this;
746
0
  }
747
0
  inline KVPair& operator=(KVPair&& from) noexcept {
748
0
    if (this == &from) return *this;
749
0
    if (GetOwningArena() == from.GetOwningArena()
750
0
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
751
0
        && GetOwningArena() != nullptr
752
0
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
753
0
    ) {
754
0
      InternalSwap(&from);
755
0
    } else {
756
0
      CopyFrom(from);
757
0
    }
758
0
    return *this;
759
0
  }
760
761
0
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
762
0
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
763
0
  }
764
0
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
765
0
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
766
0
  }
767
768
0
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
769
0
    return GetDescriptor();
770
0
  }
771
0
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
772
0
    return default_instance().GetMetadata().descriptor;
773
0
  }
774
0
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
775
0
    return default_instance().GetMetadata().reflection;
776
0
  }
777
0
  static const KVPair& default_instance() {
778
0
    return *internal_default_instance();
779
0
  }
780
0
  static inline const KVPair* internal_default_instance() {
781
0
    return reinterpret_cast<const KVPair*>(
782
0
               &_KVPair_default_instance_);
783
0
  }
784
  static constexpr int kIndexInFileMessages =
785
    2;
786
787
0
  friend void swap(KVPair& a, KVPair& b) {
788
0
    a.Swap(&b);
789
0
  }
790
0
  inline void Swap(KVPair* other) {
791
0
    if (other == this) return;
792
0
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
793
0
    if (GetOwningArena() != nullptr &&
794
0
        GetOwningArena() == other->GetOwningArena()) {
795
0
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
796
0
    if (GetOwningArena() == other->GetOwningArena()) {
797
0
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
798
0
      InternalSwap(other);
799
0
    } else {
800
0
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
801
0
    }
802
0
  }
803
0
  void UnsafeArenaSwap(KVPair* other) {
804
0
    if (other == this) return;
805
0
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
806
0
    InternalSwap(other);
807
0
  }
808
809
  // implements Message ----------------------------------------------
810
811
129k
  KVPair* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
812
129k
    return CreateMaybeMessage<KVPair>(arena);
813
129k
  }
814
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
815
  void CopyFrom(const KVPair& from);
816
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
817
0
  void MergeFrom( const KVPair& from) {
818
0
    KVPair::MergeImpl(*this, from);
819
0
  }
820
  private:
821
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
822
  public:
823
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
824
  bool IsInitialized() const final;
825
826
  ::size_t ByteSizeLong() const final;
827
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
828
  ::uint8_t* _InternalSerialize(
829
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
830
0
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
831
832
  private:
833
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
834
  void SharedDtor();
835
  void SetCachedSize(int size) const final;
836
  void InternalSwap(KVPair* other);
837
838
  private:
839
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
840
0
  static ::absl::string_view FullMessageName() {
841
0
    return "ruby_fuzzer.KVPair";
842
0
  }
843
  protected:
844
  explicit KVPair(::PROTOBUF_NAMESPACE_ID::Arena* arena);
845
  public:
846
847
  static const ClassData _class_data_;
848
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
849
850
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
851
852
  // nested types ----------------------------------------------------
853
854
  // accessors -------------------------------------------------------
855
856
  enum : int {
857
    kKeyFieldNumber = 1,
858
    kValFieldNumber = 2,
859
  };
860
  // required string key = 1;
861
  bool has_key() const;
862
  void clear_key() ;
863
  const std::string& key() const;
864
865
866
867
868
  template <typename Arg_ = const std::string&, typename... Args_>
869
  void set_key(Arg_&& arg, Args_... args);
870
  std::string* mutable_key();
871
  PROTOBUF_NODISCARD std::string* release_key();
872
  void set_allocated_key(std::string* ptr);
873
874
  private:
875
  const std::string& _internal_key() const;
876
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key(
877
      const std::string& value);
878
  std::string* _internal_mutable_key();
879
880
  public:
881
  // required string val = 2;
882
  bool has_val() const;
883
  void clear_val() ;
884
  const std::string& val() const;
885
886
887
888
889
  template <typename Arg_ = const std::string&, typename... Args_>
890
  void set_val(Arg_&& arg, Args_... args);
891
  std::string* mutable_val();
892
  PROTOBUF_NODISCARD std::string* release_val();
893
  void set_allocated_val(std::string* ptr);
894
895
  private:
896
  const std::string& _internal_val() const;
897
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_val(
898
      const std::string& value);
899
  std::string* _internal_mutable_val();
900
901
  public:
902
  // @@protoc_insertion_point(class_scope:ruby_fuzzer.KVPair)
903
 private:
904
  class _Internal;
905
906
  // helper for ByteSizeLong()
907
  ::size_t RequiredFieldsByteSizeFallback() const;
908
909
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
910
  typedef void InternalArenaConstructable_;
911
  typedef void DestructorSkippable_;
912
  struct Impl_ {
913
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
914
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
915
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
916
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr val_;
917
  };
918
  union { Impl_ _impl_; };
919
  friend struct ::TableStruct_ruby_2eproto;
920
};// -------------------------------------------------------------------
921
922
class HashType final :
923
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ruby_fuzzer.HashType) */ {
924
 public:
925
0
  inline HashType() : HashType(nullptr) {}
926
  ~HashType() override;
927
  explicit PROTOBUF_CONSTEXPR HashType(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
928
929
  HashType(const HashType& from);
930
  HashType(HashType&& from) noexcept
931
0
    : HashType() {
932
0
    *this = ::std::move(from);
933
0
  }
934
935
0
  inline HashType& operator=(const HashType& from) {
936
0
    CopyFrom(from);
937
0
    return *this;
938
0
  }
939
0
  inline HashType& operator=(HashType&& from) noexcept {
940
0
    if (this == &from) return *this;
941
0
    if (GetOwningArena() == from.GetOwningArena()
942
0
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
943
0
        && GetOwningArena() != nullptr
944
0
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
945
0
    ) {
946
0
      InternalSwap(&from);
947
0
    } else {
948
0
      CopyFrom(from);
949
0
    }
950
0
    return *this;
951
0
  }
952
953
0
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
954
0
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
955
0
  }
956
0
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
957
0
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
958
0
  }
959
960
0
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
961
0
    return GetDescriptor();
962
0
  }
963
0
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
964
0
    return default_instance().GetMetadata().descriptor;
965
0
  }
966
0
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
967
0
    return default_instance().GetMetadata().reflection;
968
0
  }
969
0
  static const HashType& default_instance() {
970
0
    return *internal_default_instance();
971
0
  }
972
0
  static inline const HashType* internal_default_instance() {
973
0
    return reinterpret_cast<const HashType*>(
974
0
               &_HashType_default_instance_);
975
0
  }
976
  static constexpr int kIndexInFileMessages =
977
    3;
978
979
0
  friend void swap(HashType& a, HashType& b) {
980
0
    a.Swap(&b);
981
0
  }
982
0
  inline void Swap(HashType* other) {
983
0
    if (other == this) return;
984
0
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
985
0
    if (GetOwningArena() != nullptr &&
986
0
        GetOwningArena() == other->GetOwningArena()) {
987
0
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
988
0
    if (GetOwningArena() == other->GetOwningArena()) {
989
0
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
990
0
      InternalSwap(other);
991
0
    } else {
992
0
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
993
0
    }
994
0
  }
995
0
  void UnsafeArenaSwap(HashType* other) {
996
0
    if (other == this) return;
997
0
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
998
0
    InternalSwap(other);
999
0
  }
1000
1001
  // implements Message ----------------------------------------------
1002
1003
20.6k
  HashType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
1004
20.6k
    return CreateMaybeMessage<HashType>(arena);
1005
20.6k
  }
1006
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
1007
  void CopyFrom(const HashType& from);
1008
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
1009
0
  void MergeFrom( const HashType& from) {
1010
0
    HashType::MergeImpl(*this, from);
1011
0
  }
1012
  private:
1013
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
1014
  public:
1015
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1016
  bool IsInitialized() const final;
1017
1018
  ::size_t ByteSizeLong() const final;
1019
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1020
  ::uint8_t* _InternalSerialize(
1021
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1022
0
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1023
1024
  private:
1025
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1026
  void SharedDtor();
1027
  void SetCachedSize(int size) const final;
1028
  void InternalSwap(HashType* other);
1029
1030
  private:
1031
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1032
0
  static ::absl::string_view FullMessageName() {
1033
0
    return "ruby_fuzzer.HashType";
1034
0
  }
1035
  protected:
1036
  explicit HashType(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1037
  public:
1038
1039
  static const ClassData _class_data_;
1040
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
1041
1042
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1043
1044
  // nested types ----------------------------------------------------
1045
1046
  // accessors -------------------------------------------------------
1047
1048
  enum : int {
1049
    kKeyvalFieldNumber = 1,
1050
  };
1051
  // repeated .ruby_fuzzer.KVPair keyval = 1;
1052
  int keyval_size() const;
1053
  private:
1054
  int _internal_keyval_size() const;
1055
1056
  public:
1057
  void clear_keyval() ;
1058
  ::ruby_fuzzer::KVPair* mutable_keyval(int index);
1059
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::ruby_fuzzer::KVPair >*
1060
      mutable_keyval();
1061
  private:
1062
  const ::ruby_fuzzer::KVPair& _internal_keyval(int index) const;
1063
  ::ruby_fuzzer::KVPair* _internal_add_keyval();
1064
  public:
1065
  const ::ruby_fuzzer::KVPair& keyval(int index) const;
1066
  ::ruby_fuzzer::KVPair* add_keyval();
1067
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::ruby_fuzzer::KVPair >&
1068
      keyval() const;
1069
  // @@protoc_insertion_point(class_scope:ruby_fuzzer.HashType)
1070
 private:
1071
  class _Internal;
1072
1073
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1074
  typedef void InternalArenaConstructable_;
1075
  typedef void DestructorSkippable_;
1076
  struct Impl_ {
1077
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::ruby_fuzzer::KVPair > keyval_;
1078
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1079
  };
1080
  union { Impl_ _impl_; };
1081
  friend struct ::TableStruct_ruby_2eproto;
1082
};// -------------------------------------------------------------------
1083
1084
class StringExtNoArg final :
1085
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ruby_fuzzer.StringExtNoArg) */ {
1086
 public:
1087
0
  inline StringExtNoArg() : StringExtNoArg(nullptr) {}
1088
  ~StringExtNoArg() override;
1089
  explicit PROTOBUF_CONSTEXPR StringExtNoArg(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1090
1091
  StringExtNoArg(const StringExtNoArg& from);
1092
  StringExtNoArg(StringExtNoArg&& from) noexcept
1093
0
    : StringExtNoArg() {
1094
0
    *this = ::std::move(from);
1095
0
  }
1096
1097
0
  inline StringExtNoArg& operator=(const StringExtNoArg& from) {
1098
0
    CopyFrom(from);
1099
0
    return *this;
1100
0
  }
1101
0
  inline StringExtNoArg& operator=(StringExtNoArg&& from) noexcept {
1102
0
    if (this == &from) return *this;
1103
0
    if (GetOwningArena() == from.GetOwningArena()
1104
0
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1105
0
        && GetOwningArena() != nullptr
1106
0
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
1107
0
    ) {
1108
0
      InternalSwap(&from);
1109
0
    } else {
1110
0
      CopyFrom(from);
1111
0
    }
1112
0
    return *this;
1113
0
  }
1114
1115
0
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
1116
0
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
1117
0
  }
1118
0
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
1119
0
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
1120
0
  }
1121
1122
0
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1123
0
    return GetDescriptor();
1124
0
  }
1125
0
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
1126
0
    return default_instance().GetMetadata().descriptor;
1127
0
  }
1128
0
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
1129
0
    return default_instance().GetMetadata().reflection;
1130
0
  }
1131
0
  static const StringExtNoArg& default_instance() {
1132
0
    return *internal_default_instance();
1133
0
  }
1134
0
  static inline const StringExtNoArg* internal_default_instance() {
1135
0
    return reinterpret_cast<const StringExtNoArg*>(
1136
0
               &_StringExtNoArg_default_instance_);
1137
0
  }
1138
  static constexpr int kIndexInFileMessages =
1139
    4;
1140
1141
0
  friend void swap(StringExtNoArg& a, StringExtNoArg& b) {
1142
0
    a.Swap(&b);
1143
0
  }
1144
0
  inline void Swap(StringExtNoArg* other) {
1145
0
    if (other == this) return;
1146
0
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1147
0
    if (GetOwningArena() != nullptr &&
1148
0
        GetOwningArena() == other->GetOwningArena()) {
1149
0
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
1150
0
    if (GetOwningArena() == other->GetOwningArena()) {
1151
0
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
1152
0
      InternalSwap(other);
1153
0
    } else {
1154
0
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1155
0
    }
1156
0
  }
1157
0
  void UnsafeArenaSwap(StringExtNoArg* other) {
1158
0
    if (other == this) return;
1159
0
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
1160
0
    InternalSwap(other);
1161
0
  }
1162
1163
  // implements Message ----------------------------------------------
1164
1165
0
  StringExtNoArg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
1166
0
    return CreateMaybeMessage<StringExtNoArg>(arena);
1167
0
  }
1168
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
1169
  void CopyFrom(const StringExtNoArg& from);
1170
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
1171
0
  void MergeFrom( const StringExtNoArg& from) {
1172
0
    StringExtNoArg::MergeImpl(*this, from);
1173
0
  }
1174
  private:
1175
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
1176
  public:
1177
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1178
  bool IsInitialized() const final;
1179
1180
  ::size_t ByteSizeLong() const final;
1181
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1182
  ::uint8_t* _InternalSerialize(
1183
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1184
0
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1185
1186
  private:
1187
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1188
  void SharedDtor();
1189
  void SetCachedSize(int size) const final;
1190
  void InternalSwap(StringExtNoArg* other);
1191
1192
  private:
1193
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1194
0
  static ::absl::string_view FullMessageName() {
1195
0
    return "ruby_fuzzer.StringExtNoArg";
1196
0
  }
1197
  protected:
1198
  explicit StringExtNoArg(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1199
  public:
1200
1201
  static const ClassData _class_data_;
1202
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
1203
1204
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1205
1206
  // nested types ----------------------------------------------------
1207
1208
  using StrExtOp = StringExtNoArg_StrExtOp;
1209
  static constexpr StrExtOp DUMP = StringExtNoArg_StrExtOp_DUMP;
1210
  static constexpr StrExtOp STRIP = StringExtNoArg_StrExtOp_STRIP;
1211
  static constexpr StrExtOp LSTRIP = StringExtNoArg_StrExtOp_LSTRIP;
1212
  static constexpr StrExtOp RSTRIP = StringExtNoArg_StrExtOp_RSTRIP;
1213
  static constexpr StrExtOp STRIPE = StringExtNoArg_StrExtOp_STRIPE;
1214
  static constexpr StrExtOp LSTRIPE = StringExtNoArg_StrExtOp_LSTRIPE;
1215
  static constexpr StrExtOp RSTRIPE = StringExtNoArg_StrExtOp_RSTRIPE;
1216
  static constexpr StrExtOp SWAPCASE = StringExtNoArg_StrExtOp_SWAPCASE;
1217
  static constexpr StrExtOp SWAPCASEE = StringExtNoArg_StrExtOp_SWAPCASEE;
1218
  static constexpr StrExtOp SQUEEZE = StringExtNoArg_StrExtOp_SQUEEZE;
1219
0
  static inline bool StrExtOp_IsValid(int value) {
1220
0
    return StringExtNoArg_StrExtOp_IsValid(value);
1221
0
  }
1222
  static constexpr StrExtOp StrExtOp_MIN = StringExtNoArg_StrExtOp_StrExtOp_MIN;
1223
  static constexpr StrExtOp StrExtOp_MAX = StringExtNoArg_StrExtOp_StrExtOp_MAX;
1224
  static constexpr int StrExtOp_ARRAYSIZE = StringExtNoArg_StrExtOp_StrExtOp_ARRAYSIZE;
1225
0
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* StrExtOp_descriptor() {
1226
0
    return StringExtNoArg_StrExtOp_descriptor();
1227
0
  }
1228
  template <typename T>
1229
  static inline const std::string& StrExtOp_Name(T value) {
1230
    return StringExtNoArg_StrExtOp_Name(value);
1231
  }
1232
0
  static inline bool StrExtOp_Parse(absl::string_view name, StrExtOp* value) {
1233
0
    return StringExtNoArg_StrExtOp_Parse(name, value);
1234
0
  }
1235
1236
  // accessors -------------------------------------------------------
1237
1238
  enum : int {
1239
    kStrArgFieldNumber = 2,
1240
    kStrOpFieldNumber = 1,
1241
  };
1242
  // required string str_arg = 2;
1243
  bool has_str_arg() const;
1244
  void clear_str_arg() ;
1245
  const std::string& str_arg() const;
1246
1247
1248
1249
1250
  template <typename Arg_ = const std::string&, typename... Args_>
1251
  void set_str_arg(Arg_&& arg, Args_... args);
1252
  std::string* mutable_str_arg();
1253
  PROTOBUF_NODISCARD std::string* release_str_arg();
1254
  void set_allocated_str_arg(std::string* ptr);
1255
1256
  private:
1257
  const std::string& _internal_str_arg() const;
1258
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_str_arg(
1259
      const std::string& value);
1260
  std::string* _internal_mutable_str_arg();
1261
1262
  public:
1263
  // required .ruby_fuzzer.StringExtNoArg.StrExtOp str_op = 1;
1264
  bool has_str_op() const;
1265
  void clear_str_op() ;
1266
  ::ruby_fuzzer::StringExtNoArg_StrExtOp str_op() const;
1267
  void set_str_op(::ruby_fuzzer::StringExtNoArg_StrExtOp value);
1268
1269
  private:
1270
  ::ruby_fuzzer::StringExtNoArg_StrExtOp _internal_str_op() const;
1271
  void _internal_set_str_op(::ruby_fuzzer::StringExtNoArg_StrExtOp value);
1272
1273
  public:
1274
  // @@protoc_insertion_point(class_scope:ruby_fuzzer.StringExtNoArg)
1275
 private:
1276
  class _Internal;
1277
1278
  // helper for ByteSizeLong()
1279
  ::size_t RequiredFieldsByteSizeFallback() const;
1280
1281
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1282
  typedef void InternalArenaConstructable_;
1283
  typedef void DestructorSkippable_;
1284
  struct Impl_ {
1285
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1286
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1287
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr str_arg_;
1288
    int str_op_;
1289
  };
1290
  union { Impl_ _impl_; };
1291
  friend struct ::TableStruct_ruby_2eproto;
1292
};// -------------------------------------------------------------------
1293
1294
class MathConst final :
1295
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ruby_fuzzer.MathConst) */ {
1296
 public:
1297
0
  inline MathConst() : MathConst(nullptr) {}
1298
  ~MathConst() override;
1299
  explicit PROTOBUF_CONSTEXPR MathConst(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1300
1301
  MathConst(const MathConst& from);
1302
  MathConst(MathConst&& from) noexcept
1303
0
    : MathConst() {
1304
0
    *this = ::std::move(from);
1305
0
  }
1306
1307
0
  inline MathConst& operator=(const MathConst& from) {
1308
0
    CopyFrom(from);
1309
0
    return *this;
1310
0
  }
1311
0
  inline MathConst& operator=(MathConst&& from) noexcept {
1312
0
    if (this == &from) return *this;
1313
0
    if (GetOwningArena() == from.GetOwningArena()
1314
0
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1315
0
        && GetOwningArena() != nullptr
1316
0
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
1317
0
    ) {
1318
0
      InternalSwap(&from);
1319
0
    } else {
1320
0
      CopyFrom(from);
1321
0
    }
1322
0
    return *this;
1323
0
  }
1324
1325
0
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
1326
0
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
1327
0
  }
1328
0
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
1329
0
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
1330
0
  }
1331
1332
0
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1333
0
    return GetDescriptor();
1334
0
  }
1335
0
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
1336
0
    return default_instance().GetMetadata().descriptor;
1337
0
  }
1338
0
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
1339
0
    return default_instance().GetMetadata().reflection;
1340
0
  }
1341
0
  static const MathConst& default_instance() {
1342
0
    return *internal_default_instance();
1343
0
  }
1344
0
  static inline const MathConst* internal_default_instance() {
1345
0
    return reinterpret_cast<const MathConst*>(
1346
0
               &_MathConst_default_instance_);
1347
0
  }
1348
  static constexpr int kIndexInFileMessages =
1349
    5;
1350
1351
0
  friend void swap(MathConst& a, MathConst& b) {
1352
0
    a.Swap(&b);
1353
0
  }
1354
0
  inline void Swap(MathConst* other) {
1355
0
    if (other == this) return;
1356
0
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1357
0
    if (GetOwningArena() != nullptr &&
1358
0
        GetOwningArena() == other->GetOwningArena()) {
1359
0
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
1360
0
    if (GetOwningArena() == other->GetOwningArena()) {
1361
0
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
1362
0
      InternalSwap(other);
1363
0
    } else {
1364
0
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1365
0
    }
1366
0
  }
1367
0
  void UnsafeArenaSwap(MathConst* other) {
1368
0
    if (other == this) return;
1369
0
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
1370
0
    InternalSwap(other);
1371
0
  }
1372
1373
  // implements Message ----------------------------------------------
1374
1375
3.09k
  MathConst* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
1376
3.09k
    return CreateMaybeMessage<MathConst>(arena);
1377
3.09k
  }
1378
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
1379
  void CopyFrom(const MathConst& from);
1380
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
1381
0
  void MergeFrom( const MathConst& from) {
1382
0
    MathConst::MergeImpl(*this, from);
1383
0
  }
1384
  private:
1385
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
1386
  public:
1387
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1388
  bool IsInitialized() const final;
1389
1390
  ::size_t ByteSizeLong() const final;
1391
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1392
  ::uint8_t* _InternalSerialize(
1393
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1394
0
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1395
1396
  private:
1397
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1398
  void SharedDtor();
1399
  void SetCachedSize(int size) const final;
1400
  void InternalSwap(MathConst* other);
1401
1402
  private:
1403
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1404
0
  static ::absl::string_view FullMessageName() {
1405
0
    return "ruby_fuzzer.MathConst";
1406
0
  }
1407
  protected:
1408
  explicit MathConst(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1409
  public:
1410
1411
  static const ClassData _class_data_;
1412
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
1413
1414
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1415
1416
  // nested types ----------------------------------------------------
1417
1418
  using MathConstLit = MathConst_MathConstLit;
1419
  static constexpr MathConstLit PI = MathConst_MathConstLit_PI;
1420
  static constexpr MathConstLit E = MathConst_MathConstLit_E;
1421
0
  static inline bool MathConstLit_IsValid(int value) {
1422
0
    return MathConst_MathConstLit_IsValid(value);
1423
0
  }
1424
  static constexpr MathConstLit MathConstLit_MIN = MathConst_MathConstLit_MathConstLit_MIN;
1425
  static constexpr MathConstLit MathConstLit_MAX = MathConst_MathConstLit_MathConstLit_MAX;
1426
  static constexpr int MathConstLit_ARRAYSIZE = MathConst_MathConstLit_MathConstLit_ARRAYSIZE;
1427
0
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MathConstLit_descriptor() {
1428
0
    return MathConst_MathConstLit_descriptor();
1429
0
  }
1430
  template <typename T>
1431
  static inline const std::string& MathConstLit_Name(T value) {
1432
    return MathConst_MathConstLit_Name(value);
1433
  }
1434
0
  static inline bool MathConstLit_Parse(absl::string_view name, MathConstLit* value) {
1435
0
    return MathConst_MathConstLit_Parse(name, value);
1436
0
  }
1437
1438
  // accessors -------------------------------------------------------
1439
1440
  enum : int {
1441
    kMathConstFieldNumber = 1,
1442
  };
1443
  // required .ruby_fuzzer.MathConst.MathConstLit math_const = 1;
1444
  bool has_math_const() const;
1445
  void clear_math_const() ;
1446
  ::ruby_fuzzer::MathConst_MathConstLit math_const() const;
1447
  void set_math_const(::ruby_fuzzer::MathConst_MathConstLit value);
1448
1449
  private:
1450
  ::ruby_fuzzer::MathConst_MathConstLit _internal_math_const() const;
1451
  void _internal_set_math_const(::ruby_fuzzer::MathConst_MathConstLit value);
1452
1453
  public:
1454
  // @@protoc_insertion_point(class_scope:ruby_fuzzer.MathConst)
1455
 private:
1456
  class _Internal;
1457
1458
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1459
  typedef void InternalArenaConstructable_;
1460
  typedef void DestructorSkippable_;
1461
  struct Impl_ {
1462
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1463
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1464
    int math_const_;
1465
  };
1466
  union { Impl_ _impl_; };
1467
  friend struct ::TableStruct_ruby_2eproto;
1468
};// -------------------------------------------------------------------
1469
1470
class Const final :
1471
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ruby_fuzzer.Const) */ {
1472
 public:
1473
0
  inline Const() : Const(nullptr) {}
1474
  ~Const() override;
1475
  explicit PROTOBUF_CONSTEXPR Const(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1476
1477
  Const(const Const& from);
1478
  Const(Const&& from) noexcept
1479
0
    : Const() {
1480
0
    *this = ::std::move(from);
1481
0
  }
1482
1483
0
  inline Const& operator=(const Const& from) {
1484
0
    CopyFrom(from);
1485
0
    return *this;
1486
0
  }
1487
0
  inline Const& operator=(Const&& from) noexcept {
1488
0
    if (this == &from) return *this;
1489
0
    if (GetOwningArena() == from.GetOwningArena()
1490
0
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1491
0
        && GetOwningArena() != nullptr
1492
0
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
1493
0
    ) {
1494
0
      InternalSwap(&from);
1495
0
    } else {
1496
0
      CopyFrom(from);
1497
0
    }
1498
0
    return *this;
1499
0
  }
1500
1501
0
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
1502
0
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
1503
0
  }
1504
0
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
1505
0
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
1506
0
  }
1507
1508
0
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1509
0
    return GetDescriptor();
1510
0
  }
1511
0
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
1512
0
    return default_instance().GetMetadata().descriptor;
1513
0
  }
1514
0
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
1515
0
    return default_instance().GetMetadata().reflection;
1516
0
  }
1517
0
  static const Const& default_instance() {
1518
0
    return *internal_default_instance();
1519
0
  }
1520
  enum ConstOneofCase {
1521
    kIntLit = 1,
1522
    kBoolVal = 4,
1523
    CONST_ONEOF_NOT_SET = 0,
1524
  };
1525
1526
0
  static inline const Const* internal_default_instance() {
1527
0
    return reinterpret_cast<const Const*>(
1528
0
               &_Const_default_instance_);
1529
0
  }
1530
  static constexpr int kIndexInFileMessages =
1531
    6;
1532
1533
0
  friend void swap(Const& a, Const& b) {
1534
0
    a.Swap(&b);
1535
0
  }
1536
0
  inline void Swap(Const* other) {
1537
0
    if (other == this) return;
1538
0
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1539
0
    if (GetOwningArena() != nullptr &&
1540
0
        GetOwningArena() == other->GetOwningArena()) {
1541
0
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
1542
0
    if (GetOwningArena() == other->GetOwningArena()) {
1543
0
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
1544
0
      InternalSwap(other);
1545
0
    } else {
1546
0
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1547
0
    }
1548
0
  }
1549
0
  void UnsafeArenaSwap(Const* other) {
1550
0
    if (other == this) return;
1551
0
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
1552
0
    InternalSwap(other);
1553
0
  }
1554
1555
  // implements Message ----------------------------------------------
1556
1557
291k
  Const* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
1558
291k
    return CreateMaybeMessage<Const>(arena);
1559
291k
  }
1560
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
1561
  void CopyFrom(const Const& from);
1562
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
1563
0
  void MergeFrom( const Const& from) {
1564
0
    Const::MergeImpl(*this, from);
1565
0
  }
1566
  private:
1567
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
1568
  public:
1569
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1570
  bool IsInitialized() const final;
1571
1572
  ::size_t ByteSizeLong() const final;
1573
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1574
  ::uint8_t* _InternalSerialize(
1575
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1576
0
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1577
1578
  private:
1579
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1580
  void SharedDtor();
1581
  void SetCachedSize(int size) const final;
1582
  void InternalSwap(Const* other);
1583
1584
  private:
1585
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1586
0
  static ::absl::string_view FullMessageName() {
1587
0
    return "ruby_fuzzer.Const";
1588
0
  }
1589
  protected:
1590
  explicit Const(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1591
  public:
1592
1593
  static const ClassData _class_data_;
1594
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
1595
1596
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1597
1598
  // nested types ----------------------------------------------------
1599
1600
  // accessors -------------------------------------------------------
1601
1602
  enum : int {
1603
    kIntLitFieldNumber = 1,
1604
    kBoolValFieldNumber = 4,
1605
  };
1606
  // uint32 int_lit = 1;
1607
  bool has_int_lit() const;
1608
  void clear_int_lit() ;
1609
  ::uint32_t int_lit() const;
1610
  void set_int_lit(::uint32_t value);
1611
1612
  private:
1613
  ::uint32_t _internal_int_lit() const;
1614
  void _internal_set_int_lit(::uint32_t value);
1615
1616
  public:
1617
  // bool bool_val = 4;
1618
  bool has_bool_val() const;
1619
  void clear_bool_val() ;
1620
  bool bool_val() const;
1621
  void set_bool_val(bool value);
1622
1623
  private:
1624
  bool _internal_bool_val() const;
1625
  void _internal_set_bool_val(bool value);
1626
1627
  public:
1628
  void clear_const_oneof();
1629
  ConstOneofCase const_oneof_case() const;
1630
  // @@protoc_insertion_point(class_scope:ruby_fuzzer.Const)
1631
 private:
1632
  class _Internal;
1633
  void set_has_int_lit();
1634
  void set_has_bool_val();
1635
1636
  inline bool has_const_oneof() const;
1637
  inline void clear_has_const_oneof();
1638
1639
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1640
  typedef void InternalArenaConstructable_;
1641
  typedef void DestructorSkippable_;
1642
  struct Impl_ {
1643
    union ConstOneofUnion {
1644
291k
      constexpr ConstOneofUnion() : _constinit_{} {}
1645
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
1646
      ::uint32_t int_lit_;
1647
      bool bool_val_;
1648
    } const_oneof_;
1649
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1650
    ::uint32_t _oneof_case_[1];
1651
1652
  };
1653
  union { Impl_ _impl_; };
1654
  friend struct ::TableStruct_ruby_2eproto;
1655
};// -------------------------------------------------------------------
1656
1657
class BinaryOp final :
1658
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ruby_fuzzer.BinaryOp) */ {
1659
 public:
1660
0
  inline BinaryOp() : BinaryOp(nullptr) {}
1661
  ~BinaryOp() override;
1662
  explicit PROTOBUF_CONSTEXPR BinaryOp(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1663
1664
  BinaryOp(const BinaryOp& from);
1665
  BinaryOp(BinaryOp&& from) noexcept
1666
0
    : BinaryOp() {
1667
0
    *this = ::std::move(from);
1668
0
  }
1669
1670
0
  inline BinaryOp& operator=(const BinaryOp& from) {
1671
0
    CopyFrom(from);
1672
0
    return *this;
1673
0
  }
1674
0
  inline BinaryOp& operator=(BinaryOp&& from) noexcept {
1675
0
    if (this == &from) return *this;
1676
0
    if (GetOwningArena() == from.GetOwningArena()
1677
0
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1678
0
        && GetOwningArena() != nullptr
1679
0
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
1680
0
    ) {
1681
0
      InternalSwap(&from);
1682
0
    } else {
1683
0
      CopyFrom(from);
1684
0
    }
1685
0
    return *this;
1686
0
  }
1687
1688
0
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
1689
0
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
1690
0
  }
1691
0
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
1692
0
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
1693
0
  }
1694
1695
0
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1696
0
    return GetDescriptor();
1697
0
  }
1698
0
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
1699
0
    return default_instance().GetMetadata().descriptor;
1700
0
  }
1701
0
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
1702
0
    return default_instance().GetMetadata().reflection;
1703
0
  }
1704
0
  static const BinaryOp& default_instance() {
1705
0
    return *internal_default_instance();
1706
0
  }
1707
262k
  static inline const BinaryOp* internal_default_instance() {
1708
262k
    return reinterpret_cast<const BinaryOp*>(
1709
262k
               &_BinaryOp_default_instance_);
1710
262k
  }
1711
  static constexpr int kIndexInFileMessages =
1712
    7;
1713
1714
0
  friend void swap(BinaryOp& a, BinaryOp& b) {
1715
0
    a.Swap(&b);
1716
0
  }
1717
0
  inline void Swap(BinaryOp* other) {
1718
0
    if (other == this) return;
1719
0
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1720
0
    if (GetOwningArena() != nullptr &&
1721
0
        GetOwningArena() == other->GetOwningArena()) {
1722
0
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
1723
0
    if (GetOwningArena() == other->GetOwningArena()) {
1724
0
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
1725
0
      InternalSwap(other);
1726
0
    } else {
1727
0
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1728
0
    }
1729
0
  }
1730
0
  void UnsafeArenaSwap(BinaryOp* other) {
1731
0
    if (other == this) return;
1732
0
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
1733
0
    InternalSwap(other);
1734
0
  }
1735
1736
  // implements Message ----------------------------------------------
1737
1738
131k
  BinaryOp* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
1739
131k
    return CreateMaybeMessage<BinaryOp>(arena);
1740
131k
  }
1741
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
1742
  void CopyFrom(const BinaryOp& from);
1743
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
1744
0
  void MergeFrom( const BinaryOp& from) {
1745
0
    BinaryOp::MergeImpl(*this, from);
1746
0
  }
1747
  private:
1748
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
1749
  public:
1750
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1751
  bool IsInitialized() const final;
1752
1753
  ::size_t ByteSizeLong() const final;
1754
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1755
  ::uint8_t* _InternalSerialize(
1756
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1757
0
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1758
1759
  private:
1760
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1761
  void SharedDtor();
1762
  void SetCachedSize(int size) const final;
1763
  void InternalSwap(BinaryOp* other);
1764
1765
  private:
1766
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1767
0
  static ::absl::string_view FullMessageName() {
1768
0
    return "ruby_fuzzer.BinaryOp";
1769
0
  }
1770
  protected:
1771
  explicit BinaryOp(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1772
  public:
1773
1774
  static const ClassData _class_data_;
1775
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
1776
1777
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1778
1779
  // nested types ----------------------------------------------------
1780
1781
  using Op = BinaryOp_Op;
1782
  static constexpr Op ADD = BinaryOp_Op_ADD;
1783
  static constexpr Op SUB = BinaryOp_Op_SUB;
1784
  static constexpr Op MUL = BinaryOp_Op_MUL;
1785
  static constexpr Op DIV = BinaryOp_Op_DIV;
1786
  static constexpr Op MOD = BinaryOp_Op_MOD;
1787
  static constexpr Op XOR = BinaryOp_Op_XOR;
1788
  static constexpr Op AND = BinaryOp_Op_AND;
1789
  static constexpr Op OR = BinaryOp_Op_OR;
1790
  static constexpr Op EQ = BinaryOp_Op_EQ;
1791
  static constexpr Op NE = BinaryOp_Op_NE;
1792
  static constexpr Op LE = BinaryOp_Op_LE;
1793
  static constexpr Op GE = BinaryOp_Op_GE;
1794
  static constexpr Op LT = BinaryOp_Op_LT;
1795
  static constexpr Op GT = BinaryOp_Op_GT;
1796
  static constexpr Op RS = BinaryOp_Op_RS;
1797
0
  static inline bool Op_IsValid(int value) {
1798
0
    return BinaryOp_Op_IsValid(value);
1799
0
  }
1800
  static constexpr Op Op_MIN = BinaryOp_Op_Op_MIN;
1801
  static constexpr Op Op_MAX = BinaryOp_Op_Op_MAX;
1802
  static constexpr int Op_ARRAYSIZE = BinaryOp_Op_Op_ARRAYSIZE;
1803
0
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Op_descriptor() {
1804
0
    return BinaryOp_Op_descriptor();
1805
0
  }
1806
  template <typename T>
1807
  static inline const std::string& Op_Name(T value) {
1808
    return BinaryOp_Op_Name(value);
1809
  }
1810
0
  static inline bool Op_Parse(absl::string_view name, Op* value) {
1811
0
    return BinaryOp_Op_Parse(name, value);
1812
0
  }
1813
1814
  // accessors -------------------------------------------------------
1815
1816
  enum : int {
1817
    kLeftFieldNumber = 2,
1818
    kRightFieldNumber = 3,
1819
    kOpFieldNumber = 1,
1820
  };
1821
  // required .ruby_fuzzer.Rvalue left = 2;
1822
  bool has_left() const;
1823
  void clear_left() ;
1824
  const ::ruby_fuzzer::Rvalue& left() const;
1825
  PROTOBUF_NODISCARD ::ruby_fuzzer::Rvalue* release_left();
1826
  ::ruby_fuzzer::Rvalue* mutable_left();
1827
  void set_allocated_left(::ruby_fuzzer::Rvalue* left);
1828
  private:
1829
  const ::ruby_fuzzer::Rvalue& _internal_left() const;
1830
  ::ruby_fuzzer::Rvalue* _internal_mutable_left();
1831
  public:
1832
  void unsafe_arena_set_allocated_left(
1833
      ::ruby_fuzzer::Rvalue* left);
1834
  ::ruby_fuzzer::Rvalue* unsafe_arena_release_left();
1835
  // required .ruby_fuzzer.Rvalue right = 3;
1836
  bool has_right() const;
1837
  void clear_right() ;
1838
  const ::ruby_fuzzer::Rvalue& right() const;
1839
  PROTOBUF_NODISCARD ::ruby_fuzzer::Rvalue* release_right();
1840
  ::ruby_fuzzer::Rvalue* mutable_right();
1841
  void set_allocated_right(::ruby_fuzzer::Rvalue* right);
1842
  private:
1843
  const ::ruby_fuzzer::Rvalue& _internal_right() const;
1844
  ::ruby_fuzzer::Rvalue* _internal_mutable_right();
1845
  public:
1846
  void unsafe_arena_set_allocated_right(
1847
      ::ruby_fuzzer::Rvalue* right);
1848
  ::ruby_fuzzer::Rvalue* unsafe_arena_release_right();
1849
  // required .ruby_fuzzer.BinaryOp.Op op = 1;
1850
  bool has_op() const;
1851
  void clear_op() ;
1852
  ::ruby_fuzzer::BinaryOp_Op op() const;
1853
  void set_op(::ruby_fuzzer::BinaryOp_Op value);
1854
1855
  private:
1856
  ::ruby_fuzzer::BinaryOp_Op _internal_op() const;
1857
  void _internal_set_op(::ruby_fuzzer::BinaryOp_Op value);
1858
1859
  public:
1860
  // @@protoc_insertion_point(class_scope:ruby_fuzzer.BinaryOp)
1861
 private:
1862
  class _Internal;
1863
1864
  // helper for ByteSizeLong()
1865
  ::size_t RequiredFieldsByteSizeFallback() const;
1866
1867
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1868
  typedef void InternalArenaConstructable_;
1869
  typedef void DestructorSkippable_;
1870
  struct Impl_ {
1871
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1872
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1873
    ::ruby_fuzzer::Rvalue* left_;
1874
    ::ruby_fuzzer::Rvalue* right_;
1875
    int op_;
1876
  };
1877
  union { Impl_ _impl_; };
1878
  friend struct ::TableStruct_ruby_2eproto;
1879
};// -------------------------------------------------------------------
1880
1881
class Rvalue final :
1882
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ruby_fuzzer.Rvalue) */ {
1883
 public:
1884
0
  inline Rvalue() : Rvalue(nullptr) {}
1885
  ~Rvalue() override;
1886
  explicit PROTOBUF_CONSTEXPR Rvalue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1887
1888
  Rvalue(const Rvalue& from);
1889
  Rvalue(Rvalue&& from) noexcept
1890
0
    : Rvalue() {
1891
0
    *this = ::std::move(from);
1892
0
  }
1893
1894
0
  inline Rvalue& operator=(const Rvalue& from) {
1895
0
    CopyFrom(from);
1896
0
    return *this;
1897
0
  }
1898
0
  inline Rvalue& operator=(Rvalue&& from) noexcept {
1899
0
    if (this == &from) return *this;
1900
0
    if (GetOwningArena() == from.GetOwningArena()
1901
0
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1902
0
        && GetOwningArena() != nullptr
1903
0
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
1904
0
    ) {
1905
0
      InternalSwap(&from);
1906
0
    } else {
1907
0
      CopyFrom(from);
1908
0
    }
1909
0
    return *this;
1910
0
  }
1911
1912
0
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
1913
0
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
1914
0
  }
1915
0
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
1916
0
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
1917
0
  }
1918
1919
0
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1920
0
    return GetDescriptor();
1921
0
  }
1922
0
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
1923
0
    return default_instance().GetMetadata().descriptor;
1924
0
  }
1925
0
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
1926
0
    return default_instance().GetMetadata().reflection;
1927
0
  }
1928
0
  static const Rvalue& default_instance() {
1929
0
    return *internal_default_instance();
1930
0
  }
1931
  enum RvalueOneofCase {
1932
    kVarref = 1,
1933
    kCons = 2,
1934
    kBinop = 3,
1935
    RVALUE_ONEOF_NOT_SET = 0,
1936
  };
1937
1938
0
  static inline const Rvalue* internal_default_instance() {
1939
0
    return reinterpret_cast<const Rvalue*>(
1940
0
               &_Rvalue_default_instance_);
1941
0
  }
1942
  static constexpr int kIndexInFileMessages =
1943
    8;
1944
1945
0
  friend void swap(Rvalue& a, Rvalue& b) {
1946
0
    a.Swap(&b);
1947
0
  }
1948
0
  inline void Swap(Rvalue* other) {
1949
0
    if (other == this) return;
1950
0
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1951
0
    if (GetOwningArena() != nullptr &&
1952
0
        GetOwningArena() == other->GetOwningArena()) {
1953
0
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
1954
0
    if (GetOwningArena() == other->GetOwningArena()) {
1955
0
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
1956
0
      InternalSwap(other);
1957
0
    } else {
1958
0
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1959
0
    }
1960
0
  }
1961
0
  void UnsafeArenaSwap(Rvalue* other) {
1962
0
    if (other == this) return;
1963
0
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
1964
0
    InternalSwap(other);
1965
0
  }
1966
1967
  // implements Message ----------------------------------------------
1968
1969
580k
  Rvalue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
1970
580k
    return CreateMaybeMessage<Rvalue>(arena);
1971
580k
  }
1972
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
1973
  void CopyFrom(const Rvalue& from);
1974
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
1975
0
  void MergeFrom( const Rvalue& from) {
1976
0
    Rvalue::MergeImpl(*this, from);
1977
0
  }
1978
  private:
1979
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
1980
  public:
1981
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1982
  bool IsInitialized() const final;
1983
1984
  ::size_t ByteSizeLong() const final;
1985
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1986
  ::uint8_t* _InternalSerialize(
1987
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1988
0
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1989
1990
  private:
1991
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1992
  void SharedDtor();
1993
  void SetCachedSize(int size) const final;
1994
  void InternalSwap(Rvalue* other);
1995
1996
  private:
1997
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1998
0
  static ::absl::string_view FullMessageName() {
1999
0
    return "ruby_fuzzer.Rvalue";
2000
0
  }
2001
  protected:
2002
  explicit Rvalue(::PROTOBUF_NAMESPACE_ID::Arena* arena);
2003
  public:
2004
2005
  static const ClassData _class_data_;
2006
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
2007
2008
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
2009
2010
  // nested types ----------------------------------------------------
2011
2012
  // accessors -------------------------------------------------------
2013
2014
  enum : int {
2015
    kVarrefFieldNumber = 1,
2016
    kConsFieldNumber = 2,
2017
    kBinopFieldNumber = 3,
2018
  };
2019
  // .ruby_fuzzer.VarRef varref = 1;
2020
  bool has_varref() const;
2021
  private:
2022
  bool _internal_has_varref() const;
2023
2024
  public:
2025
  void clear_varref() ;
2026
  const ::ruby_fuzzer::VarRef& varref() const;
2027
  PROTOBUF_NODISCARD ::ruby_fuzzer::VarRef* release_varref();
2028
  ::ruby_fuzzer::VarRef* mutable_varref();
2029
  void set_allocated_varref(::ruby_fuzzer::VarRef* varref);
2030
  private:
2031
  const ::ruby_fuzzer::VarRef& _internal_varref() const;
2032
  ::ruby_fuzzer::VarRef* _internal_mutable_varref();
2033
  public:
2034
  void unsafe_arena_set_allocated_varref(
2035
      ::ruby_fuzzer::VarRef* varref);
2036
  ::ruby_fuzzer::VarRef* unsafe_arena_release_varref();
2037
  // .ruby_fuzzer.Const cons = 2;
2038
  bool has_cons() const;
2039
  private:
2040
  bool _internal_has_cons() const;
2041
2042
  public:
2043
  void clear_cons() ;
2044
  const ::ruby_fuzzer::Const& cons() const;
2045
  PROTOBUF_NODISCARD ::ruby_fuzzer::Const* release_cons();
2046
  ::ruby_fuzzer::Const* mutable_cons();
2047
  void set_allocated_cons(::ruby_fuzzer::Const* cons);
2048
  private:
2049
  const ::ruby_fuzzer::Const& _internal_cons() const;
2050
  ::ruby_fuzzer::Const* _internal_mutable_cons();
2051
  public:
2052
  void unsafe_arena_set_allocated_cons(
2053
      ::ruby_fuzzer::Const* cons);
2054
  ::ruby_fuzzer::Const* unsafe_arena_release_cons();
2055
  // .ruby_fuzzer.BinaryOp binop = 3;
2056
  bool has_binop() const;
2057
  private:
2058
  bool _internal_has_binop() const;
2059
2060
  public:
2061
  void clear_binop() ;
2062
  const ::ruby_fuzzer::BinaryOp& binop() const;
2063
  PROTOBUF_NODISCARD ::ruby_fuzzer::BinaryOp* release_binop();
2064
  ::ruby_fuzzer::BinaryOp* mutable_binop();
2065
  void set_allocated_binop(::ruby_fuzzer::BinaryOp* binop);
2066
  private:
2067
  const ::ruby_fuzzer::BinaryOp& _internal_binop() const;
2068
  ::ruby_fuzzer::BinaryOp* _internal_mutable_binop();
2069
  public:
2070
  void unsafe_arena_set_allocated_binop(
2071
      ::ruby_fuzzer::BinaryOp* binop);
2072
  ::ruby_fuzzer::BinaryOp* unsafe_arena_release_binop();
2073
  void clear_rvalue_oneof();
2074
  RvalueOneofCase rvalue_oneof_case() const;
2075
  // @@protoc_insertion_point(class_scope:ruby_fuzzer.Rvalue)
2076
 private:
2077
  class _Internal;
2078
  void set_has_varref();
2079
  void set_has_cons();
2080
  void set_has_binop();
2081
2082
  inline bool has_rvalue_oneof() const;
2083
  inline void clear_has_rvalue_oneof();
2084
2085
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2086
  typedef void InternalArenaConstructable_;
2087
  typedef void DestructorSkippable_;
2088
  struct Impl_ {
2089
    union RvalueOneofUnion {
2090
580k
      constexpr RvalueOneofUnion() : _constinit_{} {}
2091
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
2092
      ::ruby_fuzzer::VarRef* varref_;
2093
      ::ruby_fuzzer::Const* cons_;
2094
      ::ruby_fuzzer::BinaryOp* binop_;
2095
    } rvalue_oneof_;
2096
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2097
    ::uint32_t _oneof_case_[1];
2098
2099
  };
2100
  union { Impl_ _impl_; };
2101
  friend struct ::TableStruct_ruby_2eproto;
2102
};// -------------------------------------------------------------------
2103
2104
class AssignmentStatement final :
2105
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ruby_fuzzer.AssignmentStatement) */ {
2106
 public:
2107
0
  inline AssignmentStatement() : AssignmentStatement(nullptr) {}
2108
  ~AssignmentStatement() override;
2109
  explicit PROTOBUF_CONSTEXPR AssignmentStatement(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2110
2111
  AssignmentStatement(const AssignmentStatement& from);
2112
  AssignmentStatement(AssignmentStatement&& from) noexcept
2113
0
    : AssignmentStatement() {
2114
0
    *this = ::std::move(from);
2115
0
  }
2116
2117
0
  inline AssignmentStatement& operator=(const AssignmentStatement& from) {
2118
0
    CopyFrom(from);
2119
0
    return *this;
2120
0
  }
2121
0
  inline AssignmentStatement& operator=(AssignmentStatement&& from) noexcept {
2122
0
    if (this == &from) return *this;
2123
0
    if (GetOwningArena() == from.GetOwningArena()
2124
0
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2125
0
        && GetOwningArena() != nullptr
2126
0
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
2127
0
    ) {
2128
0
      InternalSwap(&from);
2129
0
    } else {
2130
0
      CopyFrom(from);
2131
0
    }
2132
0
    return *this;
2133
0
  }
2134
2135
0
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
2136
0
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
2137
0
  }
2138
0
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
2139
0
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
2140
0
  }
2141
2142
0
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
2143
0
    return GetDescriptor();
2144
0
  }
2145
0
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
2146
0
    return default_instance().GetMetadata().descriptor;
2147
0
  }
2148
0
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
2149
0
    return default_instance().GetMetadata().reflection;
2150
0
  }
2151
0
  static const AssignmentStatement& default_instance() {
2152
0
    return *internal_default_instance();
2153
0
  }
2154
215k
  static inline const AssignmentStatement* internal_default_instance() {
2155
215k
    return reinterpret_cast<const AssignmentStatement*>(
2156
215k
               &_AssignmentStatement_default_instance_);
2157
215k
  }
2158
  static constexpr int kIndexInFileMessages =
2159
    9;
2160
2161
0
  friend void swap(AssignmentStatement& a, AssignmentStatement& b) {
2162
0
    a.Swap(&b);
2163
0
  }
2164
0
  inline void Swap(AssignmentStatement* other) {
2165
0
    if (other == this) return;
2166
0
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2167
0
    if (GetOwningArena() != nullptr &&
2168
0
        GetOwningArena() == other->GetOwningArena()) {
2169
0
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
2170
0
    if (GetOwningArena() == other->GetOwningArena()) {
2171
0
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
2172
0
      InternalSwap(other);
2173
0
    } else {
2174
0
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2175
0
    }
2176
0
  }
2177
0
  void UnsafeArenaSwap(AssignmentStatement* other) {
2178
0
    if (other == this) return;
2179
0
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
2180
0
    InternalSwap(other);
2181
0
  }
2182
2183
  // implements Message ----------------------------------------------
2184
2185
215k
  AssignmentStatement* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
2186
215k
    return CreateMaybeMessage<AssignmentStatement>(arena);
2187
215k
  }
2188
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
2189
  void CopyFrom(const AssignmentStatement& from);
2190
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
2191
0
  void MergeFrom( const AssignmentStatement& from) {
2192
0
    AssignmentStatement::MergeImpl(*this, from);
2193
0
  }
2194
  private:
2195
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
2196
  public:
2197
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2198
  bool IsInitialized() const final;
2199
2200
  ::size_t ByteSizeLong() const final;
2201
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2202
  ::uint8_t* _InternalSerialize(
2203
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2204
0
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2205
2206
  private:
2207
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
2208
  void SharedDtor();
2209
  void SetCachedSize(int size) const final;
2210
  void InternalSwap(AssignmentStatement* other);
2211
2212
  private:
2213
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2214
0
  static ::absl::string_view FullMessageName() {
2215
0
    return "ruby_fuzzer.AssignmentStatement";
2216
0
  }
2217
  protected:
2218
  explicit AssignmentStatement(::PROTOBUF_NAMESPACE_ID::Arena* arena);
2219
  public:
2220
2221
  static const ClassData _class_data_;
2222
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
2223
2224
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
2225
2226
  // nested types ----------------------------------------------------
2227
2228
  // accessors -------------------------------------------------------
2229
2230
  enum : int {
2231
    kRvalueFieldNumber = 2,
2232
  };
2233
  // required .ruby_fuzzer.Rvalue rvalue = 2;
2234
  bool has_rvalue() const;
2235
  void clear_rvalue() ;
2236
  const ::ruby_fuzzer::Rvalue& rvalue() const;
2237
  PROTOBUF_NODISCARD ::ruby_fuzzer::Rvalue* release_rvalue();
2238
  ::ruby_fuzzer::Rvalue* mutable_rvalue();
2239
  void set_allocated_rvalue(::ruby_fuzzer::Rvalue* rvalue);
2240
  private:
2241
  const ::ruby_fuzzer::Rvalue& _internal_rvalue() const;
2242
  ::ruby_fuzzer::Rvalue* _internal_mutable_rvalue();
2243
  public:
2244
  void unsafe_arena_set_allocated_rvalue(
2245
      ::ruby_fuzzer::Rvalue* rvalue);
2246
  ::ruby_fuzzer::Rvalue* unsafe_arena_release_rvalue();
2247
  // @@protoc_insertion_point(class_scope:ruby_fuzzer.AssignmentStatement)
2248
 private:
2249
  class _Internal;
2250
2251
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2252
  typedef void InternalArenaConstructable_;
2253
  typedef void DestructorSkippable_;
2254
  struct Impl_ {
2255
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
2256
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2257
    ::ruby_fuzzer::Rvalue* rvalue_;
2258
  };
2259
  union { Impl_ _impl_; };
2260
  friend struct ::TableStruct_ruby_2eproto;
2261
};// -------------------------------------------------------------------
2262
2263
class IfElse final :
2264
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ruby_fuzzer.IfElse) */ {
2265
 public:
2266
0
  inline IfElse() : IfElse(nullptr) {}
2267
  ~IfElse() override;
2268
  explicit PROTOBUF_CONSTEXPR IfElse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2269
2270
  IfElse(const IfElse& from);
2271
  IfElse(IfElse&& from) noexcept
2272
0
    : IfElse() {
2273
0
    *this = ::std::move(from);
2274
0
  }
2275
2276
0
  inline IfElse& operator=(const IfElse& from) {
2277
0
    CopyFrom(from);
2278
0
    return *this;
2279
0
  }
2280
0
  inline IfElse& operator=(IfElse&& from) noexcept {
2281
0
    if (this == &from) return *this;
2282
0
    if (GetOwningArena() == from.GetOwningArena()
2283
0
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2284
0
        && GetOwningArena() != nullptr
2285
0
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
2286
0
    ) {
2287
0
      InternalSwap(&from);
2288
0
    } else {
2289
0
      CopyFrom(from);
2290
0
    }
2291
0
    return *this;
2292
0
  }
2293
2294
0
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
2295
0
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
2296
0
  }
2297
0
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
2298
0
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
2299
0
  }
2300
2301
0
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
2302
0
    return GetDescriptor();
2303
0
  }
2304
0
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
2305
0
    return default_instance().GetMetadata().descriptor;
2306
0
  }
2307
0
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
2308
0
    return default_instance().GetMetadata().reflection;
2309
0
  }
2310
0
  static const IfElse& default_instance() {
2311
0
    return *internal_default_instance();
2312
0
  }
2313
52.5k
  static inline const IfElse* internal_default_instance() {
2314
52.5k
    return reinterpret_cast<const IfElse*>(
2315
52.5k
               &_IfElse_default_instance_);
2316
52.5k
  }
2317
  static constexpr int kIndexInFileMessages =
2318
    10;
2319
2320
0
  friend void swap(IfElse& a, IfElse& b) {
2321
0
    a.Swap(&b);
2322
0
  }
2323
0
  inline void Swap(IfElse* other) {
2324
0
    if (other == this) return;
2325
0
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2326
0
    if (GetOwningArena() != nullptr &&
2327
0
        GetOwningArena() == other->GetOwningArena()) {
2328
0
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
2329
0
    if (GetOwningArena() == other->GetOwningArena()) {
2330
0
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
2331
0
      InternalSwap(other);
2332
0
    } else {
2333
0
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2334
0
    }
2335
0
  }
2336
0
  void UnsafeArenaSwap(IfElse* other) {
2337
0
    if (other == this) return;
2338
0
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
2339
0
    InternalSwap(other);
2340
0
  }
2341
2342
  // implements Message ----------------------------------------------
2343
2344
17.5k
  IfElse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
2345
17.5k
    return CreateMaybeMessage<IfElse>(arena);
2346
17.5k
  }
2347
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
2348
  void CopyFrom(const IfElse& from);
2349
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
2350
0
  void MergeFrom( const IfElse& from) {
2351
0
    IfElse::MergeImpl(*this, from);
2352
0
  }
2353
  private:
2354
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
2355
  public:
2356
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2357
  bool IsInitialized() const final;
2358
2359
  ::size_t ByteSizeLong() const final;
2360
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2361
  ::uint8_t* _InternalSerialize(
2362
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2363
0
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2364
2365
  private:
2366
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
2367
  void SharedDtor();
2368
  void SetCachedSize(int size) const final;
2369
  void InternalSwap(IfElse* other);
2370
2371
  private:
2372
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2373
0
  static ::absl::string_view FullMessageName() {
2374
0
    return "ruby_fuzzer.IfElse";
2375
0
  }
2376
  protected:
2377
  explicit IfElse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
2378
  public:
2379
2380
  static const ClassData _class_data_;
2381
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
2382
2383
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
2384
2385
  // nested types ----------------------------------------------------
2386
2387
  // accessors -------------------------------------------------------
2388
2389
  enum : int {
2390
    kCondFieldNumber = 1,
2391
    kIfBodyFieldNumber = 2,
2392
    kElseBodyFieldNumber = 3,
2393
  };
2394
  // required .ruby_fuzzer.Rvalue cond = 1;
2395
  bool has_cond() const;
2396
  void clear_cond() ;
2397
  const ::ruby_fuzzer::Rvalue& cond() const;
2398
  PROTOBUF_NODISCARD ::ruby_fuzzer::Rvalue* release_cond();
2399
  ::ruby_fuzzer::Rvalue* mutable_cond();
2400
  void set_allocated_cond(::ruby_fuzzer::Rvalue* cond);
2401
  private:
2402
  const ::ruby_fuzzer::Rvalue& _internal_cond() const;
2403
  ::ruby_fuzzer::Rvalue* _internal_mutable_cond();
2404
  public:
2405
  void unsafe_arena_set_allocated_cond(
2406
      ::ruby_fuzzer::Rvalue* cond);
2407
  ::ruby_fuzzer::Rvalue* unsafe_arena_release_cond();
2408
  // required .ruby_fuzzer.StatementSeq if_body = 2;
2409
  bool has_if_body() const;
2410
  void clear_if_body() ;
2411
  const ::ruby_fuzzer::StatementSeq& if_body() const;
2412
  PROTOBUF_NODISCARD ::ruby_fuzzer::StatementSeq* release_if_body();
2413
  ::ruby_fuzzer::StatementSeq* mutable_if_body();
2414
  void set_allocated_if_body(::ruby_fuzzer::StatementSeq* if_body);
2415
  private:
2416
  const ::ruby_fuzzer::StatementSeq& _internal_if_body() const;
2417
  ::ruby_fuzzer::StatementSeq* _internal_mutable_if_body();
2418
  public:
2419
  void unsafe_arena_set_allocated_if_body(
2420
      ::ruby_fuzzer::StatementSeq* if_body);
2421
  ::ruby_fuzzer::StatementSeq* unsafe_arena_release_if_body();
2422
  // required .ruby_fuzzer.StatementSeq else_body = 3;
2423
  bool has_else_body() const;
2424
  void clear_else_body() ;
2425
  const ::ruby_fuzzer::StatementSeq& else_body() const;
2426
  PROTOBUF_NODISCARD ::ruby_fuzzer::StatementSeq* release_else_body();
2427
  ::ruby_fuzzer::StatementSeq* mutable_else_body();
2428
  void set_allocated_else_body(::ruby_fuzzer::StatementSeq* else_body);
2429
  private:
2430
  const ::ruby_fuzzer::StatementSeq& _internal_else_body() const;
2431
  ::ruby_fuzzer::StatementSeq* _internal_mutable_else_body();
2432
  public:
2433
  void unsafe_arena_set_allocated_else_body(
2434
      ::ruby_fuzzer::StatementSeq* else_body);
2435
  ::ruby_fuzzer::StatementSeq* unsafe_arena_release_else_body();
2436
  // @@protoc_insertion_point(class_scope:ruby_fuzzer.IfElse)
2437
 private:
2438
  class _Internal;
2439
2440
  // helper for ByteSizeLong()
2441
  ::size_t RequiredFieldsByteSizeFallback() const;
2442
2443
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2444
  typedef void InternalArenaConstructable_;
2445
  typedef void DestructorSkippable_;
2446
  struct Impl_ {
2447
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
2448
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2449
    ::ruby_fuzzer::Rvalue* cond_;
2450
    ::ruby_fuzzer::StatementSeq* if_body_;
2451
    ::ruby_fuzzer::StatementSeq* else_body_;
2452
  };
2453
  union { Impl_ _impl_; };
2454
  friend struct ::TableStruct_ruby_2eproto;
2455
};// -------------------------------------------------------------------
2456
2457
class Ternary final :
2458
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ruby_fuzzer.Ternary) */ {
2459
 public:
2460
0
  inline Ternary() : Ternary(nullptr) {}
2461
  ~Ternary() override;
2462
  explicit PROTOBUF_CONSTEXPR Ternary(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2463
2464
  Ternary(const Ternary& from);
2465
  Ternary(Ternary&& from) noexcept
2466
0
    : Ternary() {
2467
0
    *this = ::std::move(from);
2468
0
  }
2469
2470
0
  inline Ternary& operator=(const Ternary& from) {
2471
0
    CopyFrom(from);
2472
0
    return *this;
2473
0
  }
2474
0
  inline Ternary& operator=(Ternary&& from) noexcept {
2475
0
    if (this == &from) return *this;
2476
0
    if (GetOwningArena() == from.GetOwningArena()
2477
0
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2478
0
        && GetOwningArena() != nullptr
2479
0
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
2480
0
    ) {
2481
0
      InternalSwap(&from);
2482
0
    } else {
2483
0
      CopyFrom(from);
2484
0
    }
2485
0
    return *this;
2486
0
  }
2487
2488
0
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
2489
0
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
2490
0
  }
2491
0
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
2492
0
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
2493
0
  }
2494
2495
0
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
2496
0
    return GetDescriptor();
2497
0
  }
2498
0
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
2499
0
    return default_instance().GetMetadata().descriptor;
2500
0
  }
2501
0
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
2502
0
    return default_instance().GetMetadata().reflection;
2503
0
  }
2504
0
  static const Ternary& default_instance() {
2505
0
    return *internal_default_instance();
2506
0
  }
2507
25.9k
  static inline const Ternary* internal_default_instance() {
2508
25.9k
    return reinterpret_cast<const Ternary*>(
2509
25.9k
               &_Ternary_default_instance_);
2510
25.9k
  }
2511
  static constexpr int kIndexInFileMessages =
2512
    11;
2513
2514
0
  friend void swap(Ternary& a, Ternary& b) {
2515
0
    a.Swap(&b);
2516
0
  }
2517
0
  inline void Swap(Ternary* other) {
2518
0
    if (other == this) return;
2519
0
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2520
0
    if (GetOwningArena() != nullptr &&
2521
0
        GetOwningArena() == other->GetOwningArena()) {
2522
0
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
2523
0
    if (GetOwningArena() == other->GetOwningArena()) {
2524
0
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
2525
0
      InternalSwap(other);
2526
0
    } else {
2527
0
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2528
0
    }
2529
0
  }
2530
0
  void UnsafeArenaSwap(Ternary* other) {
2531
0
    if (other == this) return;
2532
0
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
2533
0
    InternalSwap(other);
2534
0
  }
2535
2536
  // implements Message ----------------------------------------------
2537
2538
8.65k
  Ternary* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
2539
8.65k
    return CreateMaybeMessage<Ternary>(arena);
2540
8.65k
  }
2541
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
2542
  void CopyFrom(const Ternary& from);
2543
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
2544
0
  void MergeFrom( const Ternary& from) {
2545
0
    Ternary::MergeImpl(*this, from);
2546
0
  }
2547
  private:
2548
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
2549
  public:
2550
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2551
  bool IsInitialized() const final;
2552
2553
  ::size_t ByteSizeLong() const final;
2554
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2555
  ::uint8_t* _InternalSerialize(
2556
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2557
0
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2558
2559
  private:
2560
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
2561
  void SharedDtor();
2562
  void SetCachedSize(int size) const final;
2563
  void InternalSwap(Ternary* other);
2564
2565
  private:
2566
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2567
0
  static ::absl::string_view FullMessageName() {
2568
0
    return "ruby_fuzzer.Ternary";
2569
0
  }
2570
  protected:
2571
  explicit Ternary(::PROTOBUF_NAMESPACE_ID::Arena* arena);
2572
  public:
2573
2574
  static const ClassData _class_data_;
2575
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
2576
2577
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
2578
2579
  // nested types ----------------------------------------------------
2580
2581
  // accessors -------------------------------------------------------
2582
2583
  enum : int {
2584
    kTernCondFieldNumber = 1,
2585
    kTBranchFieldNumber = 2,
2586
    kFBranchFieldNumber = 3,
2587
  };
2588
  // required .ruby_fuzzer.Rvalue tern_cond = 1;
2589
  bool has_tern_cond() const;
2590
  void clear_tern_cond() ;
2591
  const ::ruby_fuzzer::Rvalue& tern_cond() const;
2592
  PROTOBUF_NODISCARD ::ruby_fuzzer::Rvalue* release_tern_cond();
2593
  ::ruby_fuzzer::Rvalue* mutable_tern_cond();
2594
  void set_allocated_tern_cond(::ruby_fuzzer::Rvalue* tern_cond);
2595
  private:
2596
  const ::ruby_fuzzer::Rvalue& _internal_tern_cond() const;
2597
  ::ruby_fuzzer::Rvalue* _internal_mutable_tern_cond();
2598
  public:
2599
  void unsafe_arena_set_allocated_tern_cond(
2600
      ::ruby_fuzzer::Rvalue* tern_cond);
2601
  ::ruby_fuzzer::Rvalue* unsafe_arena_release_tern_cond();
2602
  // required .ruby_fuzzer.Rvalue t_branch = 2;
2603
  bool has_t_branch() const;
2604
  void clear_t_branch() ;
2605
  const ::ruby_fuzzer::Rvalue& t_branch() const;
2606
  PROTOBUF_NODISCARD ::ruby_fuzzer::Rvalue* release_t_branch();
2607
  ::ruby_fuzzer::Rvalue* mutable_t_branch();
2608
  void set_allocated_t_branch(::ruby_fuzzer::Rvalue* t_branch);
2609
  private:
2610
  const ::ruby_fuzzer::Rvalue& _internal_t_branch() const;
2611
  ::ruby_fuzzer::Rvalue* _internal_mutable_t_branch();
2612
  public:
2613
  void unsafe_arena_set_allocated_t_branch(
2614
      ::ruby_fuzzer::Rvalue* t_branch);
2615
  ::ruby_fuzzer::Rvalue* unsafe_arena_release_t_branch();
2616
  // required .ruby_fuzzer.Rvalue f_branch = 3;
2617
  bool has_f_branch() const;
2618
  void clear_f_branch() ;
2619
  const ::ruby_fuzzer::Rvalue& f_branch() const;
2620
  PROTOBUF_NODISCARD ::ruby_fuzzer::Rvalue* release_f_branch();
2621
  ::ruby_fuzzer::Rvalue* mutable_f_branch();
2622
  void set_allocated_f_branch(::ruby_fuzzer::Rvalue* f_branch);
2623
  private:
2624
  const ::ruby_fuzzer::Rvalue& _internal_f_branch() const;
2625
  ::ruby_fuzzer::Rvalue* _internal_mutable_f_branch();
2626
  public:
2627
  void unsafe_arena_set_allocated_f_branch(
2628
      ::ruby_fuzzer::Rvalue* f_branch);
2629
  ::ruby_fuzzer::Rvalue* unsafe_arena_release_f_branch();
2630
  // @@protoc_insertion_point(class_scope:ruby_fuzzer.Ternary)
2631
 private:
2632
  class _Internal;
2633
2634
  // helper for ByteSizeLong()
2635
  ::size_t RequiredFieldsByteSizeFallback() const;
2636
2637
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2638
  typedef void InternalArenaConstructable_;
2639
  typedef void DestructorSkippable_;
2640
  struct Impl_ {
2641
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
2642
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2643
    ::ruby_fuzzer::Rvalue* tern_cond_;
2644
    ::ruby_fuzzer::Rvalue* t_branch_;
2645
    ::ruby_fuzzer::Rvalue* f_branch_;
2646
  };
2647
  union { Impl_ _impl_; };
2648
  friend struct ::TableStruct_ruby_2eproto;
2649
};// -------------------------------------------------------------------
2650
2651
class ObjectSpace final :
2652
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ruby_fuzzer.ObjectSpace) */ {
2653
 public:
2654
0
  inline ObjectSpace() : ObjectSpace(nullptr) {}
2655
  ~ObjectSpace() override;
2656
  explicit PROTOBUF_CONSTEXPR ObjectSpace(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2657
2658
  ObjectSpace(const ObjectSpace& from);
2659
  ObjectSpace(ObjectSpace&& from) noexcept
2660
0
    : ObjectSpace() {
2661
0
    *this = ::std::move(from);
2662
0
  }
2663
2664
0
  inline ObjectSpace& operator=(const ObjectSpace& from) {
2665
0
    CopyFrom(from);
2666
0
    return *this;
2667
0
  }
2668
0
  inline ObjectSpace& operator=(ObjectSpace&& from) noexcept {
2669
0
    if (this == &from) return *this;
2670
0
    if (GetOwningArena() == from.GetOwningArena()
2671
0
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2672
0
        && GetOwningArena() != nullptr
2673
0
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
2674
0
    ) {
2675
0
      InternalSwap(&from);
2676
0
    } else {
2677
0
      CopyFrom(from);
2678
0
    }
2679
0
    return *this;
2680
0
  }
2681
2682
0
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
2683
0
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
2684
0
  }
2685
0
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
2686
0
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
2687
0
  }
2688
2689
0
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
2690
0
    return GetDescriptor();
2691
0
  }
2692
0
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
2693
0
    return default_instance().GetMetadata().descriptor;
2694
0
  }
2695
0
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
2696
0
    return default_instance().GetMetadata().reflection;
2697
0
  }
2698
0
  static const ObjectSpace& default_instance() {
2699
0
    return *internal_default_instance();
2700
0
  }
2701
20.6k
  static inline const ObjectSpace* internal_default_instance() {
2702
20.6k
    return reinterpret_cast<const ObjectSpace*>(
2703
20.6k
               &_ObjectSpace_default_instance_);
2704
20.6k
  }
2705
  static constexpr int kIndexInFileMessages =
2706
    12;
2707
2708
0
  friend void swap(ObjectSpace& a, ObjectSpace& b) {
2709
0
    a.Swap(&b);
2710
0
  }
2711
0
  inline void Swap(ObjectSpace* other) {
2712
0
    if (other == this) return;
2713
0
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2714
0
    if (GetOwningArena() != nullptr &&
2715
0
        GetOwningArena() == other->GetOwningArena()) {
2716
0
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
2717
0
    if (GetOwningArena() == other->GetOwningArena()) {
2718
0
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
2719
0
      InternalSwap(other);
2720
0
    } else {
2721
0
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2722
0
    }
2723
0
  }
2724
0
  void UnsafeArenaSwap(ObjectSpace* other) {
2725
0
    if (other == this) return;
2726
0
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
2727
0
    InternalSwap(other);
2728
0
  }
2729
2730
  // implements Message ----------------------------------------------
2731
2732
20.6k
  ObjectSpace* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
2733
20.6k
    return CreateMaybeMessage<ObjectSpace>(arena);
2734
20.6k
  }
2735
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
2736
  void CopyFrom(const ObjectSpace& from);
2737
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
2738
0
  void MergeFrom( const ObjectSpace& from) {
2739
0
    ObjectSpace::MergeImpl(*this, from);
2740
0
  }
2741
  private:
2742
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
2743
  public:
2744
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2745
  bool IsInitialized() const final;
2746
2747
  ::size_t ByteSizeLong() const final;
2748
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2749
  ::uint8_t* _InternalSerialize(
2750
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2751
0
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2752
2753
  private:
2754
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
2755
  void SharedDtor();
2756
  void SetCachedSize(int size) const final;
2757
  void InternalSwap(ObjectSpace* other);
2758
2759
  private:
2760
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2761
0
  static ::absl::string_view FullMessageName() {
2762
0
    return "ruby_fuzzer.ObjectSpace";
2763
0
  }
2764
  protected:
2765
  explicit ObjectSpace(::PROTOBUF_NAMESPACE_ID::Arena* arena);
2766
  public:
2767
2768
  static const ClassData _class_data_;
2769
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
2770
2771
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
2772
2773
  // nested types ----------------------------------------------------
2774
2775
  using OS_methods = ObjectSpace_OS_methods;
2776
  static constexpr OS_methods COUNT = ObjectSpace_OS_methods_COUNT;
2777
0
  static inline bool OS_methods_IsValid(int value) {
2778
0
    return ObjectSpace_OS_methods_IsValid(value);
2779
0
  }
2780
  static constexpr OS_methods OS_methods_MIN = ObjectSpace_OS_methods_OS_methods_MIN;
2781
  static constexpr OS_methods OS_methods_MAX = ObjectSpace_OS_methods_OS_methods_MAX;
2782
  static constexpr int OS_methods_ARRAYSIZE = ObjectSpace_OS_methods_OS_methods_ARRAYSIZE;
2783
0
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* OS_methods_descriptor() {
2784
0
    return ObjectSpace_OS_methods_descriptor();
2785
0
  }
2786
  template <typename T>
2787
  static inline const std::string& OS_methods_Name(T value) {
2788
    return ObjectSpace_OS_methods_Name(value);
2789
  }
2790
0
  static inline bool OS_methods_Parse(absl::string_view name, OS_methods* value) {
2791
0
    return ObjectSpace_OS_methods_Parse(name, value);
2792
0
  }
2793
2794
  // accessors -------------------------------------------------------
2795
2796
  enum : int {
2797
    kOsArgFieldNumber = 2,
2798
    kOsFuncFieldNumber = 1,
2799
  };
2800
  // required .ruby_fuzzer.HashType os_arg = 2;
2801
  bool has_os_arg() const;
2802
  void clear_os_arg() ;
2803
  const ::ruby_fuzzer::HashType& os_arg() const;
2804
  PROTOBUF_NODISCARD ::ruby_fuzzer::HashType* release_os_arg();
2805
  ::ruby_fuzzer::HashType* mutable_os_arg();
2806
  void set_allocated_os_arg(::ruby_fuzzer::HashType* os_arg);
2807
  private:
2808
  const ::ruby_fuzzer::HashType& _internal_os_arg() const;
2809
  ::ruby_fuzzer::HashType* _internal_mutable_os_arg();
2810
  public:
2811
  void unsafe_arena_set_allocated_os_arg(
2812
      ::ruby_fuzzer::HashType* os_arg);
2813
  ::ruby_fuzzer::HashType* unsafe_arena_release_os_arg();
2814
  // required .ruby_fuzzer.ObjectSpace.OS_methods os_func = 1;
2815
  bool has_os_func() const;
2816
  void clear_os_func() ;
2817
  ::ruby_fuzzer::ObjectSpace_OS_methods os_func() const;
2818
  void set_os_func(::ruby_fuzzer::ObjectSpace_OS_methods value);
2819
2820
  private:
2821
  ::ruby_fuzzer::ObjectSpace_OS_methods _internal_os_func() const;
2822
  void _internal_set_os_func(::ruby_fuzzer::ObjectSpace_OS_methods value);
2823
2824
  public:
2825
  // @@protoc_insertion_point(class_scope:ruby_fuzzer.ObjectSpace)
2826
 private:
2827
  class _Internal;
2828
2829
  // helper for ByteSizeLong()
2830
  ::size_t RequiredFieldsByteSizeFallback() const;
2831
2832
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2833
  typedef void InternalArenaConstructable_;
2834
  typedef void DestructorSkippable_;
2835
  struct Impl_ {
2836
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
2837
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2838
    ::ruby_fuzzer::HashType* os_arg_;
2839
    int os_func_;
2840
  };
2841
  union { Impl_ _impl_; };
2842
  friend struct ::TableStruct_ruby_2eproto;
2843
};// -------------------------------------------------------------------
2844
2845
class Time final :
2846
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ruby_fuzzer.Time) */ {
2847
 public:
2848
0
  inline Time() : Time(nullptr) {}
2849
  ~Time() override;
2850
  explicit PROTOBUF_CONSTEXPR Time(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2851
2852
  Time(const Time& from);
2853
  Time(Time&& from) noexcept
2854
0
    : Time() {
2855
0
    *this = ::std::move(from);
2856
0
  }
2857
2858
0
  inline Time& operator=(const Time& from) {
2859
0
    CopyFrom(from);
2860
0
    return *this;
2861
0
  }
2862
0
  inline Time& operator=(Time&& from) noexcept {
2863
0
    if (this == &from) return *this;
2864
0
    if (GetOwningArena() == from.GetOwningArena()
2865
0
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2866
0
        && GetOwningArena() != nullptr
2867
0
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
2868
0
    ) {
2869
0
      InternalSwap(&from);
2870
0
    } else {
2871
0
      CopyFrom(from);
2872
0
    }
2873
0
    return *this;
2874
0
  }
2875
2876
0
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
2877
0
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
2878
0
  }
2879
0
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
2880
0
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
2881
0
  }
2882
2883
0
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
2884
0
    return GetDescriptor();
2885
0
  }
2886
0
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
2887
0
    return default_instance().GetMetadata().descriptor;
2888
0
  }
2889
0
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
2890
0
    return default_instance().GetMetadata().reflection;
2891
0
  }
2892
0
  static const Time& default_instance() {
2893
0
    return *internal_default_instance();
2894
0
  }
2895
0
  static inline const Time* internal_default_instance() {
2896
0
    return reinterpret_cast<const Time*>(
2897
0
               &_Time_default_instance_);
2898
0
  }
2899
  static constexpr int kIndexInFileMessages =
2900
    13;
2901
2902
0
  friend void swap(Time& a, Time& b) {
2903
0
    a.Swap(&b);
2904
0
  }
2905
0
  inline void Swap(Time* other) {
2906
0
    if (other == this) return;
2907
0
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2908
0
    if (GetOwningArena() != nullptr &&
2909
0
        GetOwningArena() == other->GetOwningArena()) {
2910
0
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
2911
0
    if (GetOwningArena() == other->GetOwningArena()) {
2912
0
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
2913
0
      InternalSwap(other);
2914
0
    } else {
2915
0
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2916
0
    }
2917
0
  }
2918
0
  void UnsafeArenaSwap(Time* other) {
2919
0
    if (other == this) return;
2920
0
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
2921
0
    InternalSwap(other);
2922
0
  }
2923
2924
  // implements Message ----------------------------------------------
2925
2926
10.2k
  Time* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
2927
10.2k
    return CreateMaybeMessage<Time>(arena);
2928
10.2k
  }
2929
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
2930
  void CopyFrom(const Time& from);
2931
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
2932
0
  void MergeFrom( const Time& from) {
2933
0
    Time::MergeImpl(*this, from);
2934
0
  }
2935
  private:
2936
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
2937
  public:
2938
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2939
  bool IsInitialized() const final;
2940
2941
  ::size_t ByteSizeLong() const final;
2942
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2943
  ::uint8_t* _InternalSerialize(
2944
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2945
0
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2946
2947
  private:
2948
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
2949
  void SharedDtor();
2950
  void SetCachedSize(int size) const final;
2951
  void InternalSwap(Time* other);
2952
2953
  private:
2954
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2955
0
  static ::absl::string_view FullMessageName() {
2956
0
    return "ruby_fuzzer.Time";
2957
0
  }
2958
  protected:
2959
  explicit Time(::PROTOBUF_NAMESPACE_ID::Arena* arena);
2960
  public:
2961
2962
  static const ClassData _class_data_;
2963
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
2964
2965
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
2966
2967
  // nested types ----------------------------------------------------
2968
2969
  using T_methods = Time_T_methods;
2970
  static constexpr T_methods AT = Time_T_methods_AT;
2971
  static constexpr T_methods GM = Time_T_methods_GM;
2972
0
  static inline bool T_methods_IsValid(int value) {
2973
0
    return Time_T_methods_IsValid(value);
2974
0
  }
2975
  static constexpr T_methods T_methods_MIN = Time_T_methods_T_methods_MIN;
2976
  static constexpr T_methods T_methods_MAX = Time_T_methods_T_methods_MAX;
2977
  static constexpr int T_methods_ARRAYSIZE = Time_T_methods_T_methods_ARRAYSIZE;
2978
0
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* T_methods_descriptor() {
2979
0
    return Time_T_methods_descriptor();
2980
0
  }
2981
  template <typename T>
2982
  static inline const std::string& T_methods_Name(T value) {
2983
    return Time_T_methods_Name(value);
2984
  }
2985
0
  static inline bool T_methods_Parse(absl::string_view name, T_methods* value) {
2986
0
    return Time_T_methods_Parse(name, value);
2987
0
  }
2988
2989
  // accessors -------------------------------------------------------
2990
2991
  enum : int {
2992
    kTArgFieldNumber = 2,
2993
    kTFuncFieldNumber = 1,
2994
  };
2995
  // required uint32 t_arg = 2;
2996
  bool has_t_arg() const;
2997
  void clear_t_arg() ;
2998
  ::uint32_t t_arg() const;
2999
  void set_t_arg(::uint32_t value);
3000
3001
  private:
3002
  ::uint32_t _internal_t_arg() const;
3003
  void _internal_set_t_arg(::uint32_t value);
3004
3005
  public:
3006
  // required .ruby_fuzzer.Time.T_methods t_func = 1;
3007
  bool has_t_func() const;
3008
  void clear_t_func() ;
3009
  ::ruby_fuzzer::Time_T_methods t_func() const;
3010
  void set_t_func(::ruby_fuzzer::Time_T_methods value);
3011
3012
  private:
3013
  ::ruby_fuzzer::Time_T_methods _internal_t_func() const;
3014
  void _internal_set_t_func(::ruby_fuzzer::Time_T_methods value);
3015
3016
  public:
3017
  // @@protoc_insertion_point(class_scope:ruby_fuzzer.Time)
3018
 private:
3019
  class _Internal;
3020
3021
  // helper for ByteSizeLong()
3022
  ::size_t RequiredFieldsByteSizeFallback() const;
3023
3024
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
3025
  typedef void InternalArenaConstructable_;
3026
  typedef void DestructorSkippable_;
3027
  struct Impl_ {
3028
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
3029
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3030
    ::uint32_t t_arg_;
3031
    int t_func_;
3032
  };
3033
  union { Impl_ _impl_; };
3034
  friend struct ::TableStruct_ruby_2eproto;
3035
};// -------------------------------------------------------------------
3036
3037
class Array final :
3038
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ruby_fuzzer.Array) */ {
3039
 public:
3040
0
  inline Array() : Array(nullptr) {}
3041
  ~Array() override;
3042
  explicit PROTOBUF_CONSTEXPR Array(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
3043
3044
  Array(const Array& from);
3045
  Array(Array&& from) noexcept
3046
0
    : Array() {
3047
0
    *this = ::std::move(from);
3048
0
  }
3049
3050
0
  inline Array& operator=(const Array& from) {
3051
0
    CopyFrom(from);
3052
0
    return *this;
3053
0
  }
3054
0
  inline Array& operator=(Array&& from) noexcept {
3055
0
    if (this == &from) return *this;
3056
0
    if (GetOwningArena() == from.GetOwningArena()
3057
0
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
3058
0
        && GetOwningArena() != nullptr
3059
0
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
3060
0
    ) {
3061
0
      InternalSwap(&from);
3062
0
    } else {
3063
0
      CopyFrom(from);
3064
0
    }
3065
0
    return *this;
3066
0
  }
3067
3068
0
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
3069
0
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
3070
0
  }
3071
0
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
3072
0
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
3073
0
  }
3074
3075
0
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
3076
0
    return GetDescriptor();
3077
0
  }
3078
0
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
3079
0
    return default_instance().GetMetadata().descriptor;
3080
0
  }
3081
0
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
3082
0
    return default_instance().GetMetadata().reflection;
3083
0
  }
3084
0
  static const Array& default_instance() {
3085
0
    return *internal_default_instance();
3086
0
  }
3087
112k
  static inline const Array* internal_default_instance() {
3088
112k
    return reinterpret_cast<const Array*>(
3089
112k
               &_Array_default_instance_);
3090
112k
  }
3091
  static constexpr int kIndexInFileMessages =
3092
    14;
3093
3094
0
  friend void swap(Array& a, Array& b) {
3095
0
    a.Swap(&b);
3096
0
  }
3097
0
  inline void Swap(Array* other) {
3098
0
    if (other == this) return;
3099
0
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
3100
0
    if (GetOwningArena() != nullptr &&
3101
0
        GetOwningArena() == other->GetOwningArena()) {
3102
0
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
3103
0
    if (GetOwningArena() == other->GetOwningArena()) {
3104
0
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
3105
0
      InternalSwap(other);
3106
0
    } else {
3107
0
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
3108
0
    }
3109
0
  }
3110
0
  void UnsafeArenaSwap(Array* other) {
3111
0
    if (other == this) return;
3112
0
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
3113
0
    InternalSwap(other);
3114
0
  }
3115
3116
  // implements Message ----------------------------------------------
3117
3118
56.1k
  Array* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
3119
56.1k
    return CreateMaybeMessage<Array>(arena);
3120
56.1k
  }
3121
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
3122
  void CopyFrom(const Array& from);
3123
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
3124
0
  void MergeFrom( const Array& from) {
3125
0
    Array::MergeImpl(*this, from);
3126
0
  }
3127
  private:
3128
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
3129
  public:
3130
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3131
  bool IsInitialized() const final;
3132
3133
  ::size_t ByteSizeLong() const final;
3134
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3135
  ::uint8_t* _InternalSerialize(
3136
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
3137
0
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
3138
3139
  private:
3140
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
3141
  void SharedDtor();
3142
  void SetCachedSize(int size) const final;
3143
  void InternalSwap(Array* other);
3144
3145
  private:
3146
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3147
0
  static ::absl::string_view FullMessageName() {
3148
0
    return "ruby_fuzzer.Array";
3149
0
  }
3150
  protected:
3151
  explicit Array(::PROTOBUF_NAMESPACE_ID::Arena* arena);
3152
  public:
3153
3154
  static const ClassData _class_data_;
3155
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
3156
3157
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
3158
3159
  // nested types ----------------------------------------------------
3160
3161
  using Arr_methods = Array_Arr_methods;
3162
  static constexpr Arr_methods FLATTEN = Array_Arr_methods_FLATTEN;
3163
  static constexpr Arr_methods COMPACT = Array_Arr_methods_COMPACT;
3164
  static constexpr Arr_methods FETCH = Array_Arr_methods_FETCH;
3165
  static constexpr Arr_methods FILL = Array_Arr_methods_FILL;
3166
  static constexpr Arr_methods ROTATE = Array_Arr_methods_ROTATE;
3167
  static constexpr Arr_methods ROTATE_E = Array_Arr_methods_ROTATE_E;
3168
  static constexpr Arr_methods DELETEIF = Array_Arr_methods_DELETEIF;
3169
  static constexpr Arr_methods INSERT = Array_Arr_methods_INSERT;
3170
  static constexpr Arr_methods BSEARCH = Array_Arr_methods_BSEARCH;
3171
  static constexpr Arr_methods KEEPIF = Array_Arr_methods_KEEPIF;
3172
  static constexpr Arr_methods SELECT = Array_Arr_methods_SELECT;
3173
  static constexpr Arr_methods VALUES_AT = Array_Arr_methods_VALUES_AT;
3174
  static constexpr Arr_methods BLOCK = Array_Arr_methods_BLOCK;
3175
  static constexpr Arr_methods DIG = Array_Arr_methods_DIG;
3176
  static constexpr Arr_methods SLICE = Array_Arr_methods_SLICE;
3177
  static constexpr Arr_methods PERM = Array_Arr_methods_PERM;
3178
  static constexpr Arr_methods COMB = Array_Arr_methods_COMB;
3179
  static constexpr Arr_methods ASSOC = Array_Arr_methods_ASSOC;
3180
  static constexpr Arr_methods RASSOC = Array_Arr_methods_RASSOC;
3181
0
  static inline bool Arr_methods_IsValid(int value) {
3182
0
    return Array_Arr_methods_IsValid(value);
3183
0
  }
3184
  static constexpr Arr_methods Arr_methods_MIN = Array_Arr_methods_Arr_methods_MIN;
3185
  static constexpr Arr_methods Arr_methods_MAX = Array_Arr_methods_Arr_methods_MAX;
3186
  static constexpr int Arr_methods_ARRAYSIZE = Array_Arr_methods_Arr_methods_ARRAYSIZE;
3187
0
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Arr_methods_descriptor() {
3188
0
    return Array_Arr_methods_descriptor();
3189
0
  }
3190
  template <typename T>
3191
  static inline const std::string& Arr_methods_Name(T value) {
3192
    return Array_Arr_methods_Name(value);
3193
  }
3194
0
  static inline bool Arr_methods_Parse(absl::string_view name, Arr_methods* value) {
3195
0
    return Array_Arr_methods_Parse(name, value);
3196
0
  }
3197
3198
  // accessors -------------------------------------------------------
3199
3200
  enum : int {
3201
    kArrArgFieldNumber = 2,
3202
    kValArgFieldNumber = 3,
3203
    kArrFuncFieldNumber = 1,
3204
  };
3205
  // required .ruby_fuzzer.ArrType arr_arg = 2;
3206
  bool has_arr_arg() const;
3207
  void clear_arr_arg() ;
3208
  const ::ruby_fuzzer::ArrType& arr_arg() const;
3209
  PROTOBUF_NODISCARD ::ruby_fuzzer::ArrType* release_arr_arg();
3210
  ::ruby_fuzzer::ArrType* mutable_arr_arg();
3211
  void set_allocated_arr_arg(::ruby_fuzzer::ArrType* arr_arg);
3212
  private:
3213
  const ::ruby_fuzzer::ArrType& _internal_arr_arg() const;
3214
  ::ruby_fuzzer::ArrType* _internal_mutable_arr_arg();
3215
  public:
3216
  void unsafe_arena_set_allocated_arr_arg(
3217
      ::ruby_fuzzer::ArrType* arr_arg);
3218
  ::ruby_fuzzer::ArrType* unsafe_arena_release_arr_arg();
3219
  // required .ruby_fuzzer.Rvalue val_arg = 3;
3220
  bool has_val_arg() const;
3221
  void clear_val_arg() ;
3222
  const ::ruby_fuzzer::Rvalue& val_arg() const;
3223
  PROTOBUF_NODISCARD ::ruby_fuzzer::Rvalue* release_val_arg();
3224
  ::ruby_fuzzer::Rvalue* mutable_val_arg();
3225
  void set_allocated_val_arg(::ruby_fuzzer::Rvalue* val_arg);
3226
  private:
3227
  const ::ruby_fuzzer::Rvalue& _internal_val_arg() const;
3228
  ::ruby_fuzzer::Rvalue* _internal_mutable_val_arg();
3229
  public:
3230
  void unsafe_arena_set_allocated_val_arg(
3231
      ::ruby_fuzzer::Rvalue* val_arg);
3232
  ::ruby_fuzzer::Rvalue* unsafe_arena_release_val_arg();
3233
  // required .ruby_fuzzer.Array.Arr_methods arr_func = 1;
3234
  bool has_arr_func() const;
3235
  void clear_arr_func() ;
3236
  ::ruby_fuzzer::Array_Arr_methods arr_func() const;
3237
  void set_arr_func(::ruby_fuzzer::Array_Arr_methods value);
3238
3239
  private:
3240
  ::ruby_fuzzer::Array_Arr_methods _internal_arr_func() const;
3241
  void _internal_set_arr_func(::ruby_fuzzer::Array_Arr_methods value);
3242
3243
  public:
3244
  // @@protoc_insertion_point(class_scope:ruby_fuzzer.Array)
3245
 private:
3246
  class _Internal;
3247
3248
  // helper for ByteSizeLong()
3249
  ::size_t RequiredFieldsByteSizeFallback() const;
3250
3251
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
3252
  typedef void InternalArenaConstructable_;
3253
  typedef void DestructorSkippable_;
3254
  struct Impl_ {
3255
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
3256
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3257
    ::ruby_fuzzer::ArrType* arr_arg_;
3258
    ::ruby_fuzzer::Rvalue* val_arg_;
3259
    int arr_func_;
3260
  };
3261
  union { Impl_ _impl_; };
3262
  friend struct ::TableStruct_ruby_2eproto;
3263
};// -------------------------------------------------------------------
3264
3265
class MathType final :
3266
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ruby_fuzzer.MathType) */ {
3267
 public:
3268
0
  inline MathType() : MathType(nullptr) {}
3269
  ~MathType() override;
3270
  explicit PROTOBUF_CONSTEXPR MathType(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
3271
3272
  MathType(const MathType& from);
3273
  MathType(MathType&& from) noexcept
3274
0
    : MathType() {
3275
0
    *this = ::std::move(from);
3276
0
  }
3277
3278
0
  inline MathType& operator=(const MathType& from) {
3279
0
    CopyFrom(from);
3280
0
    return *this;
3281
0
  }
3282
0
  inline MathType& operator=(MathType&& from) noexcept {
3283
0
    if (this == &from) return *this;
3284
0
    if (GetOwningArena() == from.GetOwningArena()
3285
0
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
3286
0
        && GetOwningArena() != nullptr
3287
0
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
3288
0
    ) {
3289
0
      InternalSwap(&from);
3290
0
    } else {
3291
0
      CopyFrom(from);
3292
0
    }
3293
0
    return *this;
3294
0
  }
3295
3296
0
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
3297
0
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
3298
0
  }
3299
0
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
3300
0
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
3301
0
  }
3302
3303
0
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
3304
0
    return GetDescriptor();
3305
0
  }
3306
0
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
3307
0
    return default_instance().GetMetadata().descriptor;
3308
0
  }
3309
0
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
3310
0
    return default_instance().GetMetadata().reflection;
3311
0
  }
3312
0
  static const MathType& default_instance() {
3313
0
    return *internal_default_instance();
3314
0
  }
3315
  enum MathArgOneofCase {
3316
    kMathRval = 2,
3317
    kMathConst = 3,
3318
    MATH_ARG_ONEOF_NOT_SET = 0,
3319
  };
3320
3321
0
  static inline const MathType* internal_default_instance() {
3322
0
    return reinterpret_cast<const MathType*>(
3323
0
               &_MathType_default_instance_);
3324
0
  }
3325
  static constexpr int kIndexInFileMessages =
3326
    15;
3327
3328
0
  friend void swap(MathType& a, MathType& b) {
3329
0
    a.Swap(&b);
3330
0
  }
3331
0
  inline void Swap(MathType* other) {
3332
0
    if (other == this) return;
3333
0
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
3334
0
    if (GetOwningArena() != nullptr &&
3335
0
        GetOwningArena() == other->GetOwningArena()) {
3336
0
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
3337
0
    if (GetOwningArena() == other->GetOwningArena()) {
3338
0
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
3339
0
      InternalSwap(other);
3340
0
    } else {
3341
0
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
3342
0
    }
3343
0
  }
3344
0
  void UnsafeArenaSwap(MathType* other) {
3345
0
    if (other == this) return;
3346
0
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
3347
0
    InternalSwap(other);
3348
0
  }
3349
3350
  // implements Message ----------------------------------------------
3351
3352
9.45k
  MathType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
3353
9.45k
    return CreateMaybeMessage<MathType>(arena);
3354
9.45k
  }
3355
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
3356
  void CopyFrom(const MathType& from);
3357
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
3358
0
  void MergeFrom( const MathType& from) {
3359
0
    MathType::MergeImpl(*this, from);
3360
0
  }
3361
  private:
3362
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
3363
  public:
3364
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3365
  bool IsInitialized() const final;
3366
3367
  ::size_t ByteSizeLong() const final;
3368
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3369
  ::uint8_t* _InternalSerialize(
3370
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
3371
0
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
3372
3373
  private:
3374
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
3375
  void SharedDtor();
3376
  void SetCachedSize(int size) const final;
3377
  void InternalSwap(MathType* other);
3378
3379
  private:
3380
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3381
0
  static ::absl::string_view FullMessageName() {
3382
0
    return "ruby_fuzzer.MathType";
3383
0
  }
3384
  protected:
3385
  explicit MathType(::PROTOBUF_NAMESPACE_ID::Arena* arena);
3386
  public:
3387
3388
  static const ClassData _class_data_;
3389
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
3390
3391
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
3392
3393
  // nested types ----------------------------------------------------
3394
3395
  // accessors -------------------------------------------------------
3396
3397
  enum : int {
3398
    kMathRvalFieldNumber = 2,
3399
    kMathConstFieldNumber = 3,
3400
  };
3401
  // .ruby_fuzzer.Rvalue math_rval = 2;
3402
  bool has_math_rval() const;
3403
  private:
3404
  bool _internal_has_math_rval() const;
3405
3406
  public:
3407
  void clear_math_rval() ;
3408
  const ::ruby_fuzzer::Rvalue& math_rval() const;
3409
  PROTOBUF_NODISCARD ::ruby_fuzzer::Rvalue* release_math_rval();
3410
  ::ruby_fuzzer::Rvalue* mutable_math_rval();
3411
  void set_allocated_math_rval(::ruby_fuzzer::Rvalue* math_rval);
3412
  private:
3413
  const ::ruby_fuzzer::Rvalue& _internal_math_rval() const;
3414
  ::ruby_fuzzer::Rvalue* _internal_mutable_math_rval();
3415
  public:
3416
  void unsafe_arena_set_allocated_math_rval(
3417
      ::ruby_fuzzer::Rvalue* math_rval);
3418
  ::ruby_fuzzer::Rvalue* unsafe_arena_release_math_rval();
3419
  // .ruby_fuzzer.MathConst math_const = 3;
3420
  bool has_math_const() const;
3421
  private:
3422
  bool _internal_has_math_const() const;
3423
3424
  public:
3425
  void clear_math_const() ;
3426
  const ::ruby_fuzzer::MathConst& math_const() const;
3427
  PROTOBUF_NODISCARD ::ruby_fuzzer::MathConst* release_math_const();
3428
  ::ruby_fuzzer::MathConst* mutable_math_const();
3429
  void set_allocated_math_const(::ruby_fuzzer::MathConst* math_const);
3430
  private:
3431
  const ::ruby_fuzzer::MathConst& _internal_math_const() const;
3432
  ::ruby_fuzzer::MathConst* _internal_mutable_math_const();
3433
  public:
3434
  void unsafe_arena_set_allocated_math_const(
3435
      ::ruby_fuzzer::MathConst* math_const);
3436
  ::ruby_fuzzer::MathConst* unsafe_arena_release_math_const();
3437
  void clear_math_arg_oneof();
3438
  MathArgOneofCase math_arg_oneof_case() const;
3439
  // @@protoc_insertion_point(class_scope:ruby_fuzzer.MathType)
3440
 private:
3441
  class _Internal;
3442
  void set_has_math_rval();
3443
  void set_has_math_const();
3444
3445
  inline bool has_math_arg_oneof() const;
3446
  inline void clear_has_math_arg_oneof();
3447
3448
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
3449
  typedef void InternalArenaConstructable_;
3450
  typedef void DestructorSkippable_;
3451
  struct Impl_ {
3452
    union MathArgOneofUnion {
3453
9.45k
      constexpr MathArgOneofUnion() : _constinit_{} {}
3454
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
3455
      ::ruby_fuzzer::Rvalue* math_rval_;
3456
      ::ruby_fuzzer::MathConst* math_const_;
3457
    } math_arg_oneof_;
3458
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3459
    ::uint32_t _oneof_case_[1];
3460
3461
  };
3462
  union { Impl_ _impl_; };
3463
  friend struct ::TableStruct_ruby_2eproto;
3464
};// -------------------------------------------------------------------
3465
3466
class MathOps final :
3467
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ruby_fuzzer.MathOps) */ {
3468
 public:
3469
0
  inline MathOps() : MathOps(nullptr) {}
3470
  ~MathOps() override;
3471
  explicit PROTOBUF_CONSTEXPR MathOps(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
3472
3473
  MathOps(const MathOps& from);
3474
  MathOps(MathOps&& from) noexcept
3475
0
    : MathOps() {
3476
0
    *this = ::std::move(from);
3477
0
  }
3478
3479
0
  inline MathOps& operator=(const MathOps& from) {
3480
0
    CopyFrom(from);
3481
0
    return *this;
3482
0
  }
3483
0
  inline MathOps& operator=(MathOps&& from) noexcept {
3484
0
    if (this == &from) return *this;
3485
0
    if (GetOwningArena() == from.GetOwningArena()
3486
0
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
3487
0
        && GetOwningArena() != nullptr
3488
0
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
3489
0
    ) {
3490
0
      InternalSwap(&from);
3491
0
    } else {
3492
0
      CopyFrom(from);
3493
0
    }
3494
0
    return *this;
3495
0
  }
3496
3497
0
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
3498
0
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
3499
0
  }
3500
0
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
3501
0
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
3502
0
  }
3503
3504
0
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
3505
0
    return GetDescriptor();
3506
0
  }
3507
0
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
3508
0
    return default_instance().GetMetadata().descriptor;
3509
0
  }
3510
0
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
3511
0
    return default_instance().GetMetadata().reflection;
3512
0
  }
3513
0
  static const MathOps& default_instance() {
3514
0
    return *internal_default_instance();
3515
0
  }
3516
9.47k
  static inline const MathOps* internal_default_instance() {
3517
9.47k
    return reinterpret_cast<const MathOps*>(
3518
9.47k
               &_MathOps_default_instance_);
3519
9.47k
  }
3520
  static constexpr int kIndexInFileMessages =
3521
    16;
3522
3523
0
  friend void swap(MathOps& a, MathOps& b) {
3524
0
    a.Swap(&b);
3525
0
  }
3526
0
  inline void Swap(MathOps* other) {
3527
0
    if (other == this) return;
3528
0
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
3529
0
    if (GetOwningArena() != nullptr &&
3530
0
        GetOwningArena() == other->GetOwningArena()) {
3531
0
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
3532
0
    if (GetOwningArena() == other->GetOwningArena()) {
3533
0
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
3534
0
      InternalSwap(other);
3535
0
    } else {
3536
0
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
3537
0
    }
3538
0
  }
3539
0
  void UnsafeArenaSwap(MathOps* other) {
3540
0
    if (other == this) return;
3541
0
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
3542
0
    InternalSwap(other);
3543
0
  }
3544
3545
  // implements Message ----------------------------------------------
3546
3547
9.47k
  MathOps* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
3548
9.47k
    return CreateMaybeMessage<MathOps>(arena);
3549
9.47k
  }
3550
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
3551
  void CopyFrom(const MathOps& from);
3552
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
3553
0
  void MergeFrom( const MathOps& from) {
3554
0
    MathOps::MergeImpl(*this, from);
3555
0
  }
3556
  private:
3557
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
3558
  public:
3559
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3560
  bool IsInitialized() const final;
3561
3562
  ::size_t ByteSizeLong() const final;
3563
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3564
  ::uint8_t* _InternalSerialize(
3565
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
3566
0
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
3567
3568
  private:
3569
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
3570
  void SharedDtor();
3571
  void SetCachedSize(int size) const final;
3572
  void InternalSwap(MathOps* other);
3573
3574
  private:
3575
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3576
0
  static ::absl::string_view FullMessageName() {
3577
0
    return "ruby_fuzzer.MathOps";
3578
0
  }
3579
  protected:
3580
  explicit MathOps(::PROTOBUF_NAMESPACE_ID::Arena* arena);
3581
  public:
3582
3583
  static const ClassData _class_data_;
3584
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
3585
3586
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
3587
3588
  // nested types ----------------------------------------------------
3589
3590
  using Mops = MathOps_Mops;
3591
  static constexpr Mops CBRT = MathOps_Mops_CBRT;
3592
  static constexpr Mops COS = MathOps_Mops_COS;
3593
  static constexpr Mops ERF = MathOps_Mops_ERF;
3594
  static constexpr Mops ERFC = MathOps_Mops_ERFC;
3595
  static constexpr Mops LOG = MathOps_Mops_LOG;
3596
  static constexpr Mops LOG10 = MathOps_Mops_LOG10;
3597
  static constexpr Mops LOG2 = MathOps_Mops_LOG2;
3598
  static constexpr Mops SIN = MathOps_Mops_SIN;
3599
  static constexpr Mops SQRT = MathOps_Mops_SQRT;
3600
  static constexpr Mops TAN = MathOps_Mops_TAN;
3601
0
  static inline bool Mops_IsValid(int value) {
3602
0
    return MathOps_Mops_IsValid(value);
3603
0
  }
3604
  static constexpr Mops Mops_MIN = MathOps_Mops_Mops_MIN;
3605
  static constexpr Mops Mops_MAX = MathOps_Mops_Mops_MAX;
3606
  static constexpr int Mops_ARRAYSIZE = MathOps_Mops_Mops_ARRAYSIZE;
3607
0
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Mops_descriptor() {
3608
0
    return MathOps_Mops_descriptor();
3609
0
  }
3610
  template <typename T>
3611
  static inline const std::string& Mops_Name(T value) {
3612
    return MathOps_Mops_Name(value);
3613
  }
3614
0
  static inline bool Mops_Parse(absl::string_view name, Mops* value) {
3615
0
    return MathOps_Mops_Parse(name, value);
3616
0
  }
3617
3618
  // accessors -------------------------------------------------------
3619
3620
  enum : int {
3621
    kMathArgFieldNumber = 2,
3622
    kMathOpFieldNumber = 1,
3623
  };
3624
  // required .ruby_fuzzer.MathType math_arg = 2;
3625
  bool has_math_arg() const;
3626
  void clear_math_arg() ;
3627
  const ::ruby_fuzzer::MathType& math_arg() const;
3628
  PROTOBUF_NODISCARD ::ruby_fuzzer::MathType* release_math_arg();
3629
  ::ruby_fuzzer::MathType* mutable_math_arg();
3630
  void set_allocated_math_arg(::ruby_fuzzer::MathType* math_arg);
3631
  private:
3632
  const ::ruby_fuzzer::MathType& _internal_math_arg() const;
3633
  ::ruby_fuzzer::MathType* _internal_mutable_math_arg();
3634
  public:
3635
  void unsafe_arena_set_allocated_math_arg(
3636
      ::ruby_fuzzer::MathType* math_arg);
3637
  ::ruby_fuzzer::MathType* unsafe_arena_release_math_arg();
3638
  // required .ruby_fuzzer.MathOps.Mops math_op = 1;
3639
  bool has_math_op() const;
3640
  void clear_math_op() ;
3641
  ::ruby_fuzzer::MathOps_Mops math_op() const;
3642
  void set_math_op(::ruby_fuzzer::MathOps_Mops value);
3643
3644
  private:
3645
  ::ruby_fuzzer::MathOps_Mops _internal_math_op() const;
3646
  void _internal_set_math_op(::ruby_fuzzer::MathOps_Mops value);
3647
3648
  public:
3649
  // @@protoc_insertion_point(class_scope:ruby_fuzzer.MathOps)
3650
 private:
3651
  class _Internal;
3652
3653
  // helper for ByteSizeLong()
3654
  ::size_t RequiredFieldsByteSizeFallback() const;
3655
3656
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
3657
  typedef void InternalArenaConstructable_;
3658
  typedef void DestructorSkippable_;
3659
  struct Impl_ {
3660
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
3661
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3662
    ::ruby_fuzzer::MathType* math_arg_;
3663
    int math_op_;
3664
  };
3665
  union { Impl_ _impl_; };
3666
  friend struct ::TableStruct_ruby_2eproto;
3667
};// -------------------------------------------------------------------
3668
3669
class BuiltinFuncs final :
3670
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ruby_fuzzer.BuiltinFuncs) */ {
3671
 public:
3672
0
  inline BuiltinFuncs() : BuiltinFuncs(nullptr) {}
3673
  ~BuiltinFuncs() override;
3674
  explicit PROTOBUF_CONSTEXPR BuiltinFuncs(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
3675
3676
  BuiltinFuncs(const BuiltinFuncs& from);
3677
  BuiltinFuncs(BuiltinFuncs&& from) noexcept
3678
0
    : BuiltinFuncs() {
3679
0
    *this = ::std::move(from);
3680
0
  }
3681
3682
0
  inline BuiltinFuncs& operator=(const BuiltinFuncs& from) {
3683
0
    CopyFrom(from);
3684
0
    return *this;
3685
0
  }
3686
0
  inline BuiltinFuncs& operator=(BuiltinFuncs&& from) noexcept {
3687
0
    if (this == &from) return *this;
3688
0
    if (GetOwningArena() == from.GetOwningArena()
3689
0
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
3690
0
        && GetOwningArena() != nullptr
3691
0
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
3692
0
    ) {
3693
0
      InternalSwap(&from);
3694
0
    } else {
3695
0
      CopyFrom(from);
3696
0
    }
3697
0
    return *this;
3698
0
  }
3699
3700
0
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
3701
0
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
3702
0
  }
3703
0
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
3704
0
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
3705
0
  }
3706
3707
0
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
3708
0
    return GetDescriptor();
3709
0
  }
3710
0
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
3711
0
    return default_instance().GetMetadata().descriptor;
3712
0
  }
3713
0
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
3714
0
    return default_instance().GetMetadata().reflection;
3715
0
  }
3716
0
  static const BuiltinFuncs& default_instance() {
3717
0
    return *internal_default_instance();
3718
0
  }
3719
  enum BifuncOneofCase {
3720
    kOs = 1,
3721
    kTime = 2,
3722
    kArr = 3,
3723
    kMops = 4,
3724
    BIFUNC_ONEOF_NOT_SET = 0,
3725
  };
3726
3727
0
  static inline const BuiltinFuncs* internal_default_instance() {
3728
0
    return reinterpret_cast<const BuiltinFuncs*>(
3729
0
               &_BuiltinFuncs_default_instance_);
3730
0
  }
3731
  static constexpr int kIndexInFileMessages =
3732
    17;
3733
3734
0
  friend void swap(BuiltinFuncs& a, BuiltinFuncs& b) {
3735
0
    a.Swap(&b);
3736
0
  }
3737
0
  inline void Swap(BuiltinFuncs* other) {
3738
0
    if (other == this) return;
3739
0
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
3740
0
    if (GetOwningArena() != nullptr &&
3741
0
        GetOwningArena() == other->GetOwningArena()) {
3742
0
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
3743
0
    if (GetOwningArena() == other->GetOwningArena()) {
3744
0
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
3745
0
      InternalSwap(other);
3746
0
    } else {
3747
0
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
3748
0
    }
3749
0
  }
3750
0
  void UnsafeArenaSwap(BuiltinFuncs* other) {
3751
0
    if (other == this) return;
3752
0
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
3753
0
    InternalSwap(other);
3754
0
  }
3755
3756
  // implements Message ----------------------------------------------
3757
3758
119k
  BuiltinFuncs* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
3759
119k
    return CreateMaybeMessage<BuiltinFuncs>(arena);
3760
119k
  }
3761
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
3762
  void CopyFrom(const BuiltinFuncs& from);
3763
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
3764
0
  void MergeFrom( const BuiltinFuncs& from) {
3765
0
    BuiltinFuncs::MergeImpl(*this, from);
3766
0
  }
3767
  private:
3768
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
3769
  public:
3770
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3771
  bool IsInitialized() const final;
3772
3773
  ::size_t ByteSizeLong() const final;
3774
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3775
  ::uint8_t* _InternalSerialize(
3776
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
3777
0
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
3778
3779
  private:
3780
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
3781
  void SharedDtor();
3782
  void SetCachedSize(int size) const final;
3783
  void InternalSwap(BuiltinFuncs* other);
3784
3785
  private:
3786
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3787
0
  static ::absl::string_view FullMessageName() {
3788
0
    return "ruby_fuzzer.BuiltinFuncs";
3789
0
  }
3790
  protected:
3791
  explicit BuiltinFuncs(::PROTOBUF_NAMESPACE_ID::Arena* arena);
3792
  public:
3793
3794
  static const ClassData _class_data_;
3795
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
3796
3797
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
3798
3799
  // nested types ----------------------------------------------------
3800
3801
  // accessors -------------------------------------------------------
3802
3803
  enum : int {
3804
    kOsFieldNumber = 1,
3805
    kTimeFieldNumber = 2,
3806
    kArrFieldNumber = 3,
3807
    kMopsFieldNumber = 4,
3808
  };
3809
  // .ruby_fuzzer.ObjectSpace os = 1;
3810
  bool has_os() const;
3811
  private:
3812
  bool _internal_has_os() const;
3813
3814
  public:
3815
  void clear_os() ;
3816
  const ::ruby_fuzzer::ObjectSpace& os() const;
3817
  PROTOBUF_NODISCARD ::ruby_fuzzer::ObjectSpace* release_os();
3818
  ::ruby_fuzzer::ObjectSpace* mutable_os();
3819
  void set_allocated_os(::ruby_fuzzer::ObjectSpace* os);
3820
  private:
3821
  const ::ruby_fuzzer::ObjectSpace& _internal_os() const;
3822
  ::ruby_fuzzer::ObjectSpace* _internal_mutable_os();
3823
  public:
3824
  void unsafe_arena_set_allocated_os(
3825
      ::ruby_fuzzer::ObjectSpace* os);
3826
  ::ruby_fuzzer::ObjectSpace* unsafe_arena_release_os();
3827
  // .ruby_fuzzer.Time time = 2;
3828
  bool has_time() const;
3829
  private:
3830
  bool _internal_has_time() const;
3831
3832
  public:
3833
  void clear_time() ;
3834
  const ::ruby_fuzzer::Time& time() const;
3835
  PROTOBUF_NODISCARD ::ruby_fuzzer::Time* release_time();
3836
  ::ruby_fuzzer::Time* mutable_time();
3837
  void set_allocated_time(::ruby_fuzzer::Time* time);
3838
  private:
3839
  const ::ruby_fuzzer::Time& _internal_time() const;
3840
  ::ruby_fuzzer::Time* _internal_mutable_time();
3841
  public:
3842
  void unsafe_arena_set_allocated_time(
3843
      ::ruby_fuzzer::Time* time);
3844
  ::ruby_fuzzer::Time* unsafe_arena_release_time();
3845
  // .ruby_fuzzer.Array arr = 3;
3846
  bool has_arr() const;
3847
  private:
3848
  bool _internal_has_arr() const;
3849
3850
  public:
3851
  void clear_arr() ;
3852
  const ::ruby_fuzzer::Array& arr() const;
3853
  PROTOBUF_NODISCARD ::ruby_fuzzer::Array* release_arr();
3854
  ::ruby_fuzzer::Array* mutable_arr();
3855
  void set_allocated_arr(::ruby_fuzzer::Array* arr);
3856
  private:
3857
  const ::ruby_fuzzer::Array& _internal_arr() const;
3858
  ::ruby_fuzzer::Array* _internal_mutable_arr();
3859
  public:
3860
  void unsafe_arena_set_allocated_arr(
3861
      ::ruby_fuzzer::Array* arr);
3862
  ::ruby_fuzzer::Array* unsafe_arena_release_arr();
3863
  // .ruby_fuzzer.MathOps mops = 4;
3864
  bool has_mops() const;
3865
  private:
3866
  bool _internal_has_mops() const;
3867
3868
  public:
3869
  void clear_mops() ;
3870
  const ::ruby_fuzzer::MathOps& mops() const;
3871
  PROTOBUF_NODISCARD ::ruby_fuzzer::MathOps* release_mops();
3872
  ::ruby_fuzzer::MathOps* mutable_mops();
3873
  void set_allocated_mops(::ruby_fuzzer::MathOps* mops);
3874
  private:
3875
  const ::ruby_fuzzer::MathOps& _internal_mops() const;
3876
  ::ruby_fuzzer::MathOps* _internal_mutable_mops();
3877
  public:
3878
  void unsafe_arena_set_allocated_mops(
3879
      ::ruby_fuzzer::MathOps* mops);
3880
  ::ruby_fuzzer::MathOps* unsafe_arena_release_mops();
3881
  void clear_bifunc_oneof();
3882
  BifuncOneofCase bifunc_oneof_case() const;
3883
  // @@protoc_insertion_point(class_scope:ruby_fuzzer.BuiltinFuncs)
3884
 private:
3885
  class _Internal;
3886
  void set_has_os();
3887
  void set_has_time();
3888
  void set_has_arr();
3889
  void set_has_mops();
3890
3891
  inline bool has_bifunc_oneof() const;
3892
  inline void clear_has_bifunc_oneof();
3893
3894
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
3895
  typedef void InternalArenaConstructable_;
3896
  typedef void DestructorSkippable_;
3897
  struct Impl_ {
3898
    union BifuncOneofUnion {
3899
119k
      constexpr BifuncOneofUnion() : _constinit_{} {}
3900
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
3901
      ::ruby_fuzzer::ObjectSpace* os_;
3902
      ::ruby_fuzzer::Time* time_;
3903
      ::ruby_fuzzer::Array* arr_;
3904
      ::ruby_fuzzer::MathOps* mops_;
3905
    } bifunc_oneof_;
3906
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3907
    ::uint32_t _oneof_case_[1];
3908
3909
  };
3910
  union { Impl_ _impl_; };
3911
  friend struct ::TableStruct_ruby_2eproto;
3912
};// -------------------------------------------------------------------
3913
3914
class Statement final :
3915
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ruby_fuzzer.Statement) */ {
3916
 public:
3917
0
  inline Statement() : Statement(nullptr) {}
3918
  ~Statement() override;
3919
  explicit PROTOBUF_CONSTEXPR Statement(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
3920
3921
  Statement(const Statement& from);
3922
  Statement(Statement&& from) noexcept
3923
0
    : Statement() {
3924
0
    *this = ::std::move(from);
3925
0
  }
3926
3927
0
  inline Statement& operator=(const Statement& from) {
3928
0
    CopyFrom(from);
3929
0
    return *this;
3930
0
  }
3931
0
  inline Statement& operator=(Statement&& from) noexcept {
3932
0
    if (this == &from) return *this;
3933
0
    if (GetOwningArena() == from.GetOwningArena()
3934
0
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
3935
0
        && GetOwningArena() != nullptr
3936
0
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
3937
0
    ) {
3938
0
      InternalSwap(&from);
3939
0
    } else {
3940
0
      CopyFrom(from);
3941
0
    }
3942
0
    return *this;
3943
0
  }
3944
3945
0
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
3946
0
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
3947
0
  }
3948
0
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
3949
0
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
3950
0
  }
3951
3952
0
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
3953
0
    return GetDescriptor();
3954
0
  }
3955
0
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
3956
0
    return default_instance().GetMetadata().descriptor;
3957
0
  }
3958
0
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
3959
0
    return default_instance().GetMetadata().reflection;
3960
0
  }
3961
0
  static const Statement& default_instance() {
3962
0
    return *internal_default_instance();
3963
0
  }
3964
  enum StmtOneofCase {
3965
    kAssignment = 1,
3966
    kIfelse = 2,
3967
    kTernaryStmt = 3,
3968
    kBuiltins = 4,
3969
    kBlockstmt = 5,
3970
    STMT_ONEOF_NOT_SET = 0,
3971
  };
3972
3973
0
  static inline const Statement* internal_default_instance() {
3974
0
    return reinterpret_cast<const Statement*>(
3975
0
               &_Statement_default_instance_);
3976
0
  }
3977
  static constexpr int kIndexInFileMessages =
3978
    18;
3979
3980
0
  friend void swap(Statement& a, Statement& b) {
3981
0
    a.Swap(&b);
3982
0
  }
3983
0
  inline void Swap(Statement* other) {
3984
0
    if (other == this) return;
3985
0
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
3986
0
    if (GetOwningArena() != nullptr &&
3987
0
        GetOwningArena() == other->GetOwningArena()) {
3988
0
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
3989
0
    if (GetOwningArena() == other->GetOwningArena()) {
3990
0
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
3991
0
      InternalSwap(other);
3992
0
    } else {
3993
0
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
3994
0
    }
3995
0
  }
3996
0
  void UnsafeArenaSwap(Statement* other) {
3997
0
    if (other == this) return;
3998
0
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
3999
0
    InternalSwap(other);
4000
0
  }
4001
4002
  // implements Message ----------------------------------------------
4003
4004
554k
  Statement* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
4005
554k
    return CreateMaybeMessage<Statement>(arena);
4006
554k
  }
4007
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
4008
  void CopyFrom(const Statement& from);
4009
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
4010
0
  void MergeFrom( const Statement& from) {
4011
0
    Statement::MergeImpl(*this, from);
4012
0
  }
4013
  private:
4014
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
4015
  public:
4016
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
4017
  bool IsInitialized() const final;
4018
4019
  ::size_t ByteSizeLong() const final;
4020
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
4021
  ::uint8_t* _InternalSerialize(
4022
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
4023
0
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
4024
4025
  private:
4026
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
4027
  void SharedDtor();
4028
  void SetCachedSize(int size) const final;
4029
  void InternalSwap(Statement* other);
4030
4031
  private:
4032
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
4033
0
  static ::absl::string_view FullMessageName() {
4034
0
    return "ruby_fuzzer.Statement";
4035
0
  }
4036
  protected:
4037
  explicit Statement(::PROTOBUF_NAMESPACE_ID::Arena* arena);
4038
  public:
4039
4040
  static const ClassData _class_data_;
4041
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
4042
4043
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
4044
4045
  // nested types ----------------------------------------------------
4046
4047
  // accessors -------------------------------------------------------
4048
4049
  enum : int {
4050
    kAssignmentFieldNumber = 1,
4051
    kIfelseFieldNumber = 2,
4052
    kTernaryStmtFieldNumber = 3,
4053
    kBuiltinsFieldNumber = 4,
4054
    kBlockstmtFieldNumber = 5,
4055
  };
4056
  // .ruby_fuzzer.AssignmentStatement assignment = 1;
4057
  bool has_assignment() const;
4058
  private:
4059
  bool _internal_has_assignment() const;
4060
4061
  public:
4062
  void clear_assignment() ;
4063
  const ::ruby_fuzzer::AssignmentStatement& assignment() const;
4064
  PROTOBUF_NODISCARD ::ruby_fuzzer::AssignmentStatement* release_assignment();
4065
  ::ruby_fuzzer::AssignmentStatement* mutable_assignment();
4066
  void set_allocated_assignment(::ruby_fuzzer::AssignmentStatement* assignment);
4067
  private:
4068
  const ::ruby_fuzzer::AssignmentStatement& _internal_assignment() const;
4069
  ::ruby_fuzzer::AssignmentStatement* _internal_mutable_assignment();
4070
  public:
4071
  void unsafe_arena_set_allocated_assignment(
4072
      ::ruby_fuzzer::AssignmentStatement* assignment);
4073
  ::ruby_fuzzer::AssignmentStatement* unsafe_arena_release_assignment();
4074
  // .ruby_fuzzer.IfElse ifelse = 2;
4075
  bool has_ifelse() const;
4076
  private:
4077
  bool _internal_has_ifelse() const;
4078
4079
  public:
4080
  void clear_ifelse() ;
4081
  const ::ruby_fuzzer::IfElse& ifelse() const;
4082
  PROTOBUF_NODISCARD ::ruby_fuzzer::IfElse* release_ifelse();
4083
  ::ruby_fuzzer::IfElse* mutable_ifelse();
4084
  void set_allocated_ifelse(::ruby_fuzzer::IfElse* ifelse);
4085
  private:
4086
  const ::ruby_fuzzer::IfElse& _internal_ifelse() const;
4087
  ::ruby_fuzzer::IfElse* _internal_mutable_ifelse();
4088
  public:
4089
  void unsafe_arena_set_allocated_ifelse(
4090
      ::ruby_fuzzer::IfElse* ifelse);
4091
  ::ruby_fuzzer::IfElse* unsafe_arena_release_ifelse();
4092
  // .ruby_fuzzer.Ternary ternary_stmt = 3;
4093
  bool has_ternary_stmt() const;
4094
  private:
4095
  bool _internal_has_ternary_stmt() const;
4096
4097
  public:
4098
  void clear_ternary_stmt() ;
4099
  const ::ruby_fuzzer::Ternary& ternary_stmt() const;
4100
  PROTOBUF_NODISCARD ::ruby_fuzzer::Ternary* release_ternary_stmt();
4101
  ::ruby_fuzzer::Ternary* mutable_ternary_stmt();
4102
  void set_allocated_ternary_stmt(::ruby_fuzzer::Ternary* ternary_stmt);
4103
  private:
4104
  const ::ruby_fuzzer::Ternary& _internal_ternary_stmt() const;
4105
  ::ruby_fuzzer::Ternary* _internal_mutable_ternary_stmt();
4106
  public:
4107
  void unsafe_arena_set_allocated_ternary_stmt(
4108
      ::ruby_fuzzer::Ternary* ternary_stmt);
4109
  ::ruby_fuzzer::Ternary* unsafe_arena_release_ternary_stmt();
4110
  // .ruby_fuzzer.BuiltinFuncs builtins = 4;
4111
  bool has_builtins() const;
4112
  private:
4113
  bool _internal_has_builtins() const;
4114
4115
  public:
4116
  void clear_builtins() ;
4117
  const ::ruby_fuzzer::BuiltinFuncs& builtins() const;
4118
  PROTOBUF_NODISCARD ::ruby_fuzzer::BuiltinFuncs* release_builtins();
4119
  ::ruby_fuzzer::BuiltinFuncs* mutable_builtins();
4120
  void set_allocated_builtins(::ruby_fuzzer::BuiltinFuncs* builtins);
4121
  private:
4122
  const ::ruby_fuzzer::BuiltinFuncs& _internal_builtins() const;
4123
  ::ruby_fuzzer::BuiltinFuncs* _internal_mutable_builtins();
4124
  public:
4125
  void unsafe_arena_set_allocated_builtins(
4126
      ::ruby_fuzzer::BuiltinFuncs* builtins);
4127
  ::ruby_fuzzer::BuiltinFuncs* unsafe_arena_release_builtins();
4128
  // .ruby_fuzzer.StatementSeq blockstmt = 5;
4129
  bool has_blockstmt() const;
4130
  private:
4131
  bool _internal_has_blockstmt() const;
4132
4133
  public:
4134
  void clear_blockstmt() ;
4135
  const ::ruby_fuzzer::StatementSeq& blockstmt() const;
4136
  PROTOBUF_NODISCARD ::ruby_fuzzer::StatementSeq* release_blockstmt();
4137
  ::ruby_fuzzer::StatementSeq* mutable_blockstmt();
4138
  void set_allocated_blockstmt(::ruby_fuzzer::StatementSeq* blockstmt);
4139
  private:
4140
  const ::ruby_fuzzer::StatementSeq& _internal_blockstmt() const;
4141
  ::ruby_fuzzer::StatementSeq* _internal_mutable_blockstmt();
4142
  public:
4143
  void unsafe_arena_set_allocated_blockstmt(
4144
      ::ruby_fuzzer::StatementSeq* blockstmt);
4145
  ::ruby_fuzzer::StatementSeq* unsafe_arena_release_blockstmt();
4146
  void clear_stmt_oneof();
4147
  StmtOneofCase stmt_oneof_case() const;
4148
  // @@protoc_insertion_point(class_scope:ruby_fuzzer.Statement)
4149
 private:
4150
  class _Internal;
4151
  void set_has_assignment();
4152
  void set_has_ifelse();
4153
  void set_has_ternary_stmt();
4154
  void set_has_builtins();
4155
  void set_has_blockstmt();
4156
4157
  inline bool has_stmt_oneof() const;
4158
  inline void clear_has_stmt_oneof();
4159
4160
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
4161
  typedef void InternalArenaConstructable_;
4162
  typedef void DestructorSkippable_;
4163
  struct Impl_ {
4164
    union StmtOneofUnion {
4165
554k
      constexpr StmtOneofUnion() : _constinit_{} {}
4166
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
4167
      ::ruby_fuzzer::AssignmentStatement* assignment_;
4168
      ::ruby_fuzzer::IfElse* ifelse_;
4169
      ::ruby_fuzzer::Ternary* ternary_stmt_;
4170
      ::ruby_fuzzer::BuiltinFuncs* builtins_;
4171
      ::ruby_fuzzer::StatementSeq* blockstmt_;
4172
    } stmt_oneof_;
4173
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
4174
    ::uint32_t _oneof_case_[1];
4175
4176
  };
4177
  union { Impl_ _impl_; };
4178
  friend struct ::TableStruct_ruby_2eproto;
4179
};// -------------------------------------------------------------------
4180
4181
class StatementSeq final :
4182
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ruby_fuzzer.StatementSeq) */ {
4183
 public:
4184
0
  inline StatementSeq() : StatementSeq(nullptr) {}
4185
  ~StatementSeq() override;
4186
  explicit PROTOBUF_CONSTEXPR StatementSeq(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
4187
4188
  StatementSeq(const StatementSeq& from);
4189
  StatementSeq(StatementSeq&& from) noexcept
4190
0
    : StatementSeq() {
4191
0
    *this = ::std::move(from);
4192
0
  }
4193
4194
0
  inline StatementSeq& operator=(const StatementSeq& from) {
4195
0
    CopyFrom(from);
4196
0
    return *this;
4197
0
  }
4198
0
  inline StatementSeq& operator=(StatementSeq&& from) noexcept {
4199
0
    if (this == &from) return *this;
4200
0
    if (GetOwningArena() == from.GetOwningArena()
4201
0
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
4202
0
        && GetOwningArena() != nullptr
4203
0
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
4204
0
    ) {
4205
0
      InternalSwap(&from);
4206
0
    } else {
4207
0
      CopyFrom(from);
4208
0
    }
4209
0
    return *this;
4210
0
  }
4211
4212
0
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
4213
0
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
4214
0
  }
4215
0
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
4216
0
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
4217
0
  }
4218
4219
0
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
4220
0
    return GetDescriptor();
4221
0
  }
4222
0
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
4223
0
    return default_instance().GetMetadata().descriptor;
4224
0
  }
4225
0
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
4226
0
    return default_instance().GetMetadata().reflection;
4227
0
  }
4228
0
  static const StatementSeq& default_instance() {
4229
0
    return *internal_default_instance();
4230
0
  }
4231
0
  static inline const StatementSeq* internal_default_instance() {
4232
0
    return reinterpret_cast<const StatementSeq*>(
4233
0
               &_StatementSeq_default_instance_);
4234
0
  }
4235
  static constexpr int kIndexInFileMessages =
4236
    19;
4237
4238
0
  friend void swap(StatementSeq& a, StatementSeq& b) {
4239
0
    a.Swap(&b);
4240
0
  }
4241
0
  inline void Swap(StatementSeq* other) {
4242
0
    if (other == this) return;
4243
0
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
4244
0
    if (GetOwningArena() != nullptr &&
4245
0
        GetOwningArena() == other->GetOwningArena()) {
4246
0
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
4247
0
    if (GetOwningArena() == other->GetOwningArena()) {
4248
0
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
4249
0
      InternalSwap(other);
4250
0
    } else {
4251
0
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
4252
0
    }
4253
0
  }
4254
0
  void UnsafeArenaSwap(StatementSeq* other) {
4255
0
    if (other == this) return;
4256
0
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
4257
0
    InternalSwap(other);
4258
0
  }
4259
4260
  // implements Message ----------------------------------------------
4261
4262
70.0k
  StatementSeq* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
4263
70.0k
    return CreateMaybeMessage<StatementSeq>(arena);
4264
70.0k
  }
4265
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
4266
  void CopyFrom(const StatementSeq& from);
4267
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
4268
0
  void MergeFrom( const StatementSeq& from) {
4269
0
    StatementSeq::MergeImpl(*this, from);
4270
0
  }
4271
  private:
4272
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
4273
  public:
4274
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
4275
  bool IsInitialized() const final;
4276
4277
  ::size_t ByteSizeLong() const final;
4278
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
4279
  ::uint8_t* _InternalSerialize(
4280
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
4281
0
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
4282
4283
  private:
4284
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
4285
  void SharedDtor();
4286
  void SetCachedSize(int size) const final;
4287
  void InternalSwap(StatementSeq* other);
4288
4289
  private:
4290
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
4291
0
  static ::absl::string_view FullMessageName() {
4292
0
    return "ruby_fuzzer.StatementSeq";
4293
0
  }
4294
  protected:
4295
  explicit StatementSeq(::PROTOBUF_NAMESPACE_ID::Arena* arena);
4296
  public:
4297
4298
  static const ClassData _class_data_;
4299
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
4300
4301
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
4302
4303
  // nested types ----------------------------------------------------
4304
4305
  // accessors -------------------------------------------------------
4306
4307
  enum : int {
4308
    kStatementsFieldNumber = 1,
4309
  };
4310
  // repeated .ruby_fuzzer.Statement statements = 1;
4311
  int statements_size() const;
4312
  private:
4313
  int _internal_statements_size() const;
4314
4315
  public:
4316
  void clear_statements() ;
4317
  ::ruby_fuzzer::Statement* mutable_statements(int index);
4318
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::ruby_fuzzer::Statement >*
4319
      mutable_statements();
4320
  private:
4321
  const ::ruby_fuzzer::Statement& _internal_statements(int index) const;
4322
  ::ruby_fuzzer::Statement* _internal_add_statements();
4323
  public:
4324
  const ::ruby_fuzzer::Statement& statements(int index) const;
4325
  ::ruby_fuzzer::Statement* add_statements();
4326
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::ruby_fuzzer::Statement >&
4327
      statements() const;
4328
  // @@protoc_insertion_point(class_scope:ruby_fuzzer.StatementSeq)
4329
 private:
4330
  class _Internal;
4331
4332
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
4333
  typedef void InternalArenaConstructable_;
4334
  typedef void DestructorSkippable_;
4335
  struct Impl_ {
4336
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::ruby_fuzzer::Statement > statements_;
4337
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
4338
  };
4339
  union { Impl_ _impl_; };
4340
  friend struct ::TableStruct_ruby_2eproto;
4341
};// -------------------------------------------------------------------
4342
4343
class Function final :
4344
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:ruby_fuzzer.Function) */ {
4345
 public:
4346
1.76k
  inline Function() : Function(nullptr) {}
4347
  ~Function() override;
4348
  explicit PROTOBUF_CONSTEXPR Function(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
4349
4350
  Function(const Function& from);
4351
  Function(Function&& from) noexcept
4352
0
    : Function() {
4353
0
    *this = ::std::move(from);
4354
0
  }
4355
4356
0
  inline Function& operator=(const Function& from) {
4357
0
    CopyFrom(from);
4358
0
    return *this;
4359
0
  }
4360
0
  inline Function& operator=(Function&& from) noexcept {
4361
0
    if (this == &from) return *this;
4362
0
    if (GetOwningArena() == from.GetOwningArena()
4363
0
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
4364
0
        && GetOwningArena() != nullptr
4365
0
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
4366
0
    ) {
4367
0
      InternalSwap(&from);
4368
0
    } else {
4369
0
      CopyFrom(from);
4370
0
    }
4371
0
    return *this;
4372
0
  }
4373
4374
0
  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
4375
0
    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
4376
0
  }
4377
0
  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
4378
0
    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
4379
0
  }
4380
4381
0
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
4382
0
    return GetDescriptor();
4383
0
  }
4384
0
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
4385
0
    return default_instance().GetMetadata().descriptor;
4386
0
  }
4387
0
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
4388
0
    return default_instance().GetMetadata().reflection;
4389
0
  }
4390
0
  static const Function& default_instance() {
4391
0
    return *internal_default_instance();
4392
0
  }
4393
1.76k
  static inline const Function* internal_default_instance() {
4394
1.76k
    return reinterpret_cast<const Function*>(
4395
1.76k
               &_Function_default_instance_);
4396
1.76k
  }
4397
  static constexpr int kIndexInFileMessages =
4398
    20;
4399
4400
0
  friend void swap(Function& a, Function& b) {
4401
0
    a.Swap(&b);
4402
0
  }
4403
0
  inline void Swap(Function* other) {
4404
0
    if (other == this) return;
4405
0
  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
4406
0
    if (GetOwningArena() != nullptr &&
4407
0
        GetOwningArena() == other->GetOwningArena()) {
4408
0
   #else  // PROTOBUF_FORCE_COPY_IN_SWAP
4409
0
    if (GetOwningArena() == other->GetOwningArena()) {
4410
0
  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
4411
0
      InternalSwap(other);
4412
0
    } else {
4413
0
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
4414
0
    }
4415
0
  }
4416
0
  void UnsafeArenaSwap(Function* other) {
4417
0
    if (other == this) return;
4418
0
    ABSL_DCHECK(GetOwningArena() == other->GetOwningArena());
4419
0
    InternalSwap(other);
4420
0
  }
4421
4422
  // implements Message ----------------------------------------------
4423
4424
0
  Function* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
4425
0
    return CreateMaybeMessage<Function>(arena);
4426
0
  }
4427
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
4428
  void CopyFrom(const Function& from);
4429
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
4430
0
  void MergeFrom( const Function& from) {
4431
0
    Function::MergeImpl(*this, from);
4432
0
  }
4433
  private:
4434
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);
4435
  public:
4436
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
4437
  bool IsInitialized() const final;
4438
4439
  ::size_t ByteSizeLong() const final;
4440
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
4441
  ::uint8_t* _InternalSerialize(
4442
      ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
4443
0
  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
4444
4445
  private:
4446
  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
4447
  void SharedDtor();
4448
  void SetCachedSize(int size) const final;
4449
  void InternalSwap(Function* other);
4450
4451
  private:
4452
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
4453
0
  static ::absl::string_view FullMessageName() {
4454
0
    return "ruby_fuzzer.Function";
4455
0
  }
4456
  protected:
4457
  explicit Function(::PROTOBUF_NAMESPACE_ID::Arena* arena);
4458
  public:
4459
4460
  static const ClassData _class_data_;
4461
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
4462
4463
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
4464
4465
  // nested types ----------------------------------------------------
4466
4467
  // accessors -------------------------------------------------------
4468
4469
  enum : int {
4470
    kStatementsFieldNumber = 1,
4471
  };
4472
  // required .ruby_fuzzer.StatementSeq statements = 1;
4473
  bool has_statements() const;
4474
  void clear_statements() ;
4475
  const ::ruby_fuzzer::StatementSeq& statements() const;
4476
  PROTOBUF_NODISCARD ::ruby_fuzzer::StatementSeq* release_statements();
4477
  ::ruby_fuzzer::StatementSeq* mutable_statements();
4478
  void set_allocated_statements(::ruby_fuzzer::StatementSeq* statements);
4479
  private:
4480
  const ::ruby_fuzzer::StatementSeq& _internal_statements() const;
4481
  ::ruby_fuzzer::StatementSeq* _internal_mutable_statements();
4482
  public:
4483
  void unsafe_arena_set_allocated_statements(
4484
      ::ruby_fuzzer::StatementSeq* statements);
4485
  ::ruby_fuzzer::StatementSeq* unsafe_arena_release_statements();
4486
  // @@protoc_insertion_point(class_scope:ruby_fuzzer.Function)
4487
 private:
4488
  class _Internal;
4489
4490
  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
4491
  typedef void InternalArenaConstructable_;
4492
  typedef void DestructorSkippable_;
4493
  struct Impl_ {
4494
    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
4495
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
4496
    ::ruby_fuzzer::StatementSeq* statements_;
4497
  };
4498
  union { Impl_ _impl_; };
4499
  friend struct ::TableStruct_ruby_2eproto;
4500
};
4501
4502
// ===================================================================
4503
4504
4505
4506
4507
// ===================================================================
4508
4509
4510
#ifdef __GNUC__
4511
#pragma GCC diagnostic push
4512
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
4513
#endif  // __GNUC__
4514
// -------------------------------------------------------------------
4515
4516
// VarRef
4517
4518
// required int32 varnum = 1;
4519
0
inline bool VarRef::has_varnum() const {
4520
0
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
4521
0
  return value;
4522
0
}
4523
0
inline void VarRef::clear_varnum() {
4524
0
  _impl_.varnum_ = 0;
4525
0
  _impl_._has_bits_[0] &= ~0x00000001u;
4526
0
}
4527
72.8k
inline ::int32_t VarRef::varnum() const {
4528
  // @@protoc_insertion_point(field_get:ruby_fuzzer.VarRef.varnum)
4529
72.8k
  return _internal_varnum();
4530
72.8k
}
4531
0
inline void VarRef::set_varnum(::int32_t value) {
4532
0
  _internal_set_varnum(value);
4533
0
  // @@protoc_insertion_point(field_set:ruby_fuzzer.VarRef.varnum)
4534
0
}
4535
72.8k
inline ::int32_t VarRef::_internal_varnum() const {
4536
72.8k
  return _impl_.varnum_;
4537
72.8k
}
4538
0
inline void VarRef::_internal_set_varnum(::int32_t value) {
4539
0
  _impl_._has_bits_[0] |= 0x00000001u;
4540
0
  _impl_.varnum_ = value;
4541
0
}
4542
4543
// -------------------------------------------------------------------
4544
4545
// ArrType
4546
4547
// repeated .ruby_fuzzer.Const elements = 1;
4548
63.0k
inline int ArrType::_internal_elements_size() const {
4549
63.0k
  return _impl_.elements_.size();
4550
63.0k
}
4551
63.0k
inline int ArrType::elements_size() const {
4552
63.0k
  return _internal_elements_size();
4553
63.0k
}
4554
0
inline void ArrType::clear_elements() {
4555
0
  _impl_.elements_.Clear();
4556
0
}
4557
0
inline ::ruby_fuzzer::Const* ArrType::mutable_elements(int index) {
4558
0
  // @@protoc_insertion_point(field_mutable:ruby_fuzzer.ArrType.elements)
4559
0
  return _impl_.elements_.Mutable(index);
4560
0
}
4561
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::ruby_fuzzer::Const >*
4562
0
ArrType::mutable_elements() {
4563
0
  // @@protoc_insertion_point(field_mutable_list:ruby_fuzzer.ArrType.elements)
4564
0
  return &_impl_.elements_;
4565
0
}
4566
0
inline const ::ruby_fuzzer::Const& ArrType::_internal_elements(int index) const {
4567
0
  return _impl_.elements_.Get(index);
4568
0
}
4569
0
inline const ::ruby_fuzzer::Const& ArrType::elements(int index) const {
4570
0
  // @@protoc_insertion_point(field_get:ruby_fuzzer.ArrType.elements)
4571
0
  return _internal_elements(index);
4572
0
}
4573
0
inline ::ruby_fuzzer::Const* ArrType::_internal_add_elements() {
4574
0
  return _impl_.elements_.Add();
4575
0
}
4576
0
inline ::ruby_fuzzer::Const* ArrType::add_elements() {
4577
0
  ::ruby_fuzzer::Const* _add = _internal_add_elements();
4578
0
  // @@protoc_insertion_point(field_add:ruby_fuzzer.ArrType.elements)
4579
0
  return _add;
4580
0
}
4581
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::ruby_fuzzer::Const >&
4582
7.26k
ArrType::elements() const {
4583
  // @@protoc_insertion_point(field_list:ruby_fuzzer.ArrType.elements)
4584
7.26k
  return _impl_.elements_;
4585
7.26k
}
4586
4587
// -------------------------------------------------------------------
4588
4589
// KVPair
4590
4591
// required string key = 1;
4592
0
inline bool KVPair::has_key() const {
4593
0
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
4594
0
  return value;
4595
0
}
4596
0
inline void KVPair::clear_key() {
4597
0
  _impl_.key_.ClearToEmpty();
4598
0
  _impl_._has_bits_[0] &= ~0x00000001u;
4599
0
}
4600
129k
inline const std::string& KVPair::key() const {
4601
  // @@protoc_insertion_point(field_get:ruby_fuzzer.KVPair.key)
4602
129k
  return _internal_key();
4603
129k
}
4604
template <typename Arg_, typename... Args_>
4605
inline PROTOBUF_ALWAYS_INLINE void KVPair::set_key(Arg_&& arg,
4606
                                                     Args_... args) {
4607
  _impl_._has_bits_[0] |= 0x00000001u;
4608
  _impl_.key_.Set(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
4609
  // @@protoc_insertion_point(field_set:ruby_fuzzer.KVPair.key)
4610
}
4611
0
inline std::string* KVPair::mutable_key() {
4612
0
  std::string* _s = _internal_mutable_key();
4613
0
  // @@protoc_insertion_point(field_mutable:ruby_fuzzer.KVPair.key)
4614
0
  return _s;
4615
0
}
4616
129k
inline const std::string& KVPair::_internal_key() const {
4617
129k
  return _impl_.key_.Get();
4618
129k
}
4619
0
inline void KVPair::_internal_set_key(const std::string& value) {
4620
0
  _impl_._has_bits_[0] |= 0x00000001u;
4621
4622
4623
0
  _impl_.key_.Set(value, GetArenaForAllocation());
4624
0
}
4625
0
inline std::string* KVPair::_internal_mutable_key() {
4626
0
  _impl_._has_bits_[0] |= 0x00000001u;
4627
0
  return _impl_.key_.Mutable( GetArenaForAllocation());
4628
0
}
4629
0
inline std::string* KVPair::release_key() {
4630
0
  // @@protoc_insertion_point(field_release:ruby_fuzzer.KVPair.key)
4631
0
  if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
4632
0
    return nullptr;
4633
0
  }
4634
0
  _impl_._has_bits_[0] &= ~0x00000001u;
4635
0
  auto* released = _impl_.key_.Release();
4636
0
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4637
0
  _impl_.key_.Set("", GetArenaForAllocation());
4638
0
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4639
0
  return released;
4640
0
}
4641
0
inline void KVPair::set_allocated_key(std::string* value) {
4642
0
  if (value != nullptr) {
4643
0
    _impl_._has_bits_[0] |= 0x00000001u;
4644
0
  } else {
4645
0
    _impl_._has_bits_[0] &= ~0x00000001u;
4646
0
  }
4647
0
  _impl_.key_.SetAllocated(value, GetArenaForAllocation());
4648
0
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4649
0
        if (_impl_.key_.IsDefault()) {
4650
0
          _impl_.key_.Set("", GetArenaForAllocation());
4651
0
        }
4652
0
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4653
0
  // @@protoc_insertion_point(field_set_allocated:ruby_fuzzer.KVPair.key)
4654
0
}
4655
4656
// required string val = 2;
4657
0
inline bool KVPair::has_val() const {
4658
0
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
4659
0
  return value;
4660
0
}
4661
0
inline void KVPair::clear_val() {
4662
0
  _impl_.val_.ClearToEmpty();
4663
0
  _impl_._has_bits_[0] &= ~0x00000002u;
4664
0
}
4665
129k
inline const std::string& KVPair::val() const {
4666
  // @@protoc_insertion_point(field_get:ruby_fuzzer.KVPair.val)
4667
129k
  return _internal_val();
4668
129k
}
4669
template <typename Arg_, typename... Args_>
4670
inline PROTOBUF_ALWAYS_INLINE void KVPair::set_val(Arg_&& arg,
4671
                                                     Args_... args) {
4672
  _impl_._has_bits_[0] |= 0x00000002u;
4673
  _impl_.val_.Set(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
4674
  // @@protoc_insertion_point(field_set:ruby_fuzzer.KVPair.val)
4675
}
4676
0
inline std::string* KVPair::mutable_val() {
4677
0
  std::string* _s = _internal_mutable_val();
4678
0
  // @@protoc_insertion_point(field_mutable:ruby_fuzzer.KVPair.val)
4679
0
  return _s;
4680
0
}
4681
129k
inline const std::string& KVPair::_internal_val() const {
4682
129k
  return _impl_.val_.Get();
4683
129k
}
4684
0
inline void KVPair::_internal_set_val(const std::string& value) {
4685
0
  _impl_._has_bits_[0] |= 0x00000002u;
4686
4687
4688
0
  _impl_.val_.Set(value, GetArenaForAllocation());
4689
0
}
4690
0
inline std::string* KVPair::_internal_mutable_val() {
4691
0
  _impl_._has_bits_[0] |= 0x00000002u;
4692
0
  return _impl_.val_.Mutable( GetArenaForAllocation());
4693
0
}
4694
0
inline std::string* KVPair::release_val() {
4695
0
  // @@protoc_insertion_point(field_release:ruby_fuzzer.KVPair.val)
4696
0
  if ((_impl_._has_bits_[0] & 0x00000002u) == 0) {
4697
0
    return nullptr;
4698
0
  }
4699
0
  _impl_._has_bits_[0] &= ~0x00000002u;
4700
0
  auto* released = _impl_.val_.Release();
4701
0
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4702
0
  _impl_.val_.Set("", GetArenaForAllocation());
4703
0
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4704
0
  return released;
4705
0
}
4706
0
inline void KVPair::set_allocated_val(std::string* value) {
4707
0
  if (value != nullptr) {
4708
0
    _impl_._has_bits_[0] |= 0x00000002u;
4709
0
  } else {
4710
0
    _impl_._has_bits_[0] &= ~0x00000002u;
4711
0
  }
4712
0
  _impl_.val_.SetAllocated(value, GetArenaForAllocation());
4713
0
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4714
0
        if (_impl_.val_.IsDefault()) {
4715
0
          _impl_.val_.Set("", GetArenaForAllocation());
4716
0
        }
4717
0
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4718
0
  // @@protoc_insertion_point(field_set_allocated:ruby_fuzzer.KVPair.val)
4719
0
}
4720
4721
// -------------------------------------------------------------------
4722
4723
// HashType
4724
4725
// repeated .ruby_fuzzer.KVPair keyval = 1;
4726
24.2k
inline int HashType::_internal_keyval_size() const {
4727
24.2k
  return _impl_.keyval_.size();
4728
24.2k
}
4729
24.2k
inline int HashType::keyval_size() const {
4730
24.2k
  return _internal_keyval_size();
4731
24.2k
}
4732
0
inline void HashType::clear_keyval() {
4733
0
  _impl_.keyval_.Clear();
4734
0
}
4735
0
inline ::ruby_fuzzer::KVPair* HashType::mutable_keyval(int index) {
4736
0
  // @@protoc_insertion_point(field_mutable:ruby_fuzzer.HashType.keyval)
4737
0
  return _impl_.keyval_.Mutable(index);
4738
0
}
4739
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::ruby_fuzzer::KVPair >*
4740
0
HashType::mutable_keyval() {
4741
0
  // @@protoc_insertion_point(field_mutable_list:ruby_fuzzer.HashType.keyval)
4742
0
  return &_impl_.keyval_;
4743
0
}
4744
0
inline const ::ruby_fuzzer::KVPair& HashType::_internal_keyval(int index) const {
4745
0
  return _impl_.keyval_.Get(index);
4746
0
}
4747
0
inline const ::ruby_fuzzer::KVPair& HashType::keyval(int index) const {
4748
0
  // @@protoc_insertion_point(field_get:ruby_fuzzer.HashType.keyval)
4749
0
  return _internal_keyval(index);
4750
0
}
4751
0
inline ::ruby_fuzzer::KVPair* HashType::_internal_add_keyval() {
4752
0
  return _impl_.keyval_.Add();
4753
0
}
4754
0
inline ::ruby_fuzzer::KVPair* HashType::add_keyval() {
4755
0
  ::ruby_fuzzer::KVPair* _add = _internal_add_keyval();
4756
0
  // @@protoc_insertion_point(field_add:ruby_fuzzer.HashType.keyval)
4757
0
  return _add;
4758
0
}
4759
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::ruby_fuzzer::KVPair >&
4760
3.61k
HashType::keyval() const {
4761
  // @@protoc_insertion_point(field_list:ruby_fuzzer.HashType.keyval)
4762
3.61k
  return _impl_.keyval_;
4763
3.61k
}
4764
4765
// -------------------------------------------------------------------
4766
4767
// StringExtNoArg
4768
4769
// required .ruby_fuzzer.StringExtNoArg.StrExtOp str_op = 1;
4770
0
inline bool StringExtNoArg::has_str_op() const {
4771
0
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
4772
0
  return value;
4773
0
}
4774
0
inline void StringExtNoArg::clear_str_op() {
4775
0
  _impl_.str_op_ = 0;
4776
0
  _impl_._has_bits_[0] &= ~0x00000002u;
4777
0
}
4778
0
inline ::ruby_fuzzer::StringExtNoArg_StrExtOp StringExtNoArg::str_op() const {
4779
  // @@protoc_insertion_point(field_get:ruby_fuzzer.StringExtNoArg.str_op)
4780
0
  return _internal_str_op();
4781
0
}
4782
0
inline void StringExtNoArg::set_str_op(::ruby_fuzzer::StringExtNoArg_StrExtOp value) {
4783
0
   _internal_set_str_op(value);
4784
0
  // @@protoc_insertion_point(field_set:ruby_fuzzer.StringExtNoArg.str_op)
4785
0
}
4786
0
inline ::ruby_fuzzer::StringExtNoArg_StrExtOp StringExtNoArg::_internal_str_op() const {
4787
0
  return static_cast<::ruby_fuzzer::StringExtNoArg_StrExtOp>(_impl_.str_op_);
4788
0
}
4789
0
inline void StringExtNoArg::_internal_set_str_op(::ruby_fuzzer::StringExtNoArg_StrExtOp value) {
4790
0
  assert(::ruby_fuzzer::StringExtNoArg_StrExtOp_IsValid(value));
4791
0
  _impl_._has_bits_[0] |= 0x00000002u;
4792
0
  _impl_.str_op_ = value;
4793
0
}
4794
4795
// required string str_arg = 2;
4796
0
inline bool StringExtNoArg::has_str_arg() const {
4797
0
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
4798
0
  return value;
4799
0
}
4800
0
inline void StringExtNoArg::clear_str_arg() {
4801
0
  _impl_.str_arg_.ClearToEmpty();
4802
0
  _impl_._has_bits_[0] &= ~0x00000001u;
4803
0
}
4804
0
inline const std::string& StringExtNoArg::str_arg() const {
4805
  // @@protoc_insertion_point(field_get:ruby_fuzzer.StringExtNoArg.str_arg)
4806
0
  return _internal_str_arg();
4807
0
}
4808
template <typename Arg_, typename... Args_>
4809
inline PROTOBUF_ALWAYS_INLINE void StringExtNoArg::set_str_arg(Arg_&& arg,
4810
                                                     Args_... args) {
4811
  _impl_._has_bits_[0] |= 0x00000001u;
4812
  _impl_.str_arg_.Set(static_cast<Arg_&&>(arg), args..., GetArenaForAllocation());
4813
  // @@protoc_insertion_point(field_set:ruby_fuzzer.StringExtNoArg.str_arg)
4814
}
4815
0
inline std::string* StringExtNoArg::mutable_str_arg() {
4816
0
  std::string* _s = _internal_mutable_str_arg();
4817
0
  // @@protoc_insertion_point(field_mutable:ruby_fuzzer.StringExtNoArg.str_arg)
4818
0
  return _s;
4819
0
}
4820
0
inline const std::string& StringExtNoArg::_internal_str_arg() const {
4821
0
  return _impl_.str_arg_.Get();
4822
0
}
4823
0
inline void StringExtNoArg::_internal_set_str_arg(const std::string& value) {
4824
0
  _impl_._has_bits_[0] |= 0x00000001u;
4825
4826
4827
0
  _impl_.str_arg_.Set(value, GetArenaForAllocation());
4828
0
}
4829
0
inline std::string* StringExtNoArg::_internal_mutable_str_arg() {
4830
0
  _impl_._has_bits_[0] |= 0x00000001u;
4831
0
  return _impl_.str_arg_.Mutable( GetArenaForAllocation());
4832
0
}
4833
0
inline std::string* StringExtNoArg::release_str_arg() {
4834
0
  // @@protoc_insertion_point(field_release:ruby_fuzzer.StringExtNoArg.str_arg)
4835
0
  if ((_impl_._has_bits_[0] & 0x00000001u) == 0) {
4836
0
    return nullptr;
4837
0
  }
4838
0
  _impl_._has_bits_[0] &= ~0x00000001u;
4839
0
  auto* released = _impl_.str_arg_.Release();
4840
0
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4841
0
  _impl_.str_arg_.Set("", GetArenaForAllocation());
4842
0
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4843
0
  return released;
4844
0
}
4845
0
inline void StringExtNoArg::set_allocated_str_arg(std::string* value) {
4846
0
  if (value != nullptr) {
4847
0
    _impl_._has_bits_[0] |= 0x00000001u;
4848
0
  } else {
4849
0
    _impl_._has_bits_[0] &= ~0x00000001u;
4850
0
  }
4851
0
  _impl_.str_arg_.SetAllocated(value, GetArenaForAllocation());
4852
0
  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4853
0
        if (_impl_.str_arg_.IsDefault()) {
4854
0
          _impl_.str_arg_.Set("", GetArenaForAllocation());
4855
0
        }
4856
0
  #endif  // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4857
0
  // @@protoc_insertion_point(field_set_allocated:ruby_fuzzer.StringExtNoArg.str_arg)
4858
0
}
4859
4860
// -------------------------------------------------------------------
4861
4862
// MathConst
4863
4864
// required .ruby_fuzzer.MathConst.MathConstLit math_const = 1;
4865
0
inline bool MathConst::has_math_const() const {
4866
0
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
4867
0
  return value;
4868
0
}
4869
0
inline void MathConst::clear_math_const() {
4870
0
  _impl_.math_const_ = 0;
4871
0
  _impl_._has_bits_[0] &= ~0x00000001u;
4872
0
}
4873
3.08k
inline ::ruby_fuzzer::MathConst_MathConstLit MathConst::math_const() const {
4874
  // @@protoc_insertion_point(field_get:ruby_fuzzer.MathConst.math_const)
4875
3.08k
  return _internal_math_const();
4876
3.08k
}
4877
0
inline void MathConst::set_math_const(::ruby_fuzzer::MathConst_MathConstLit value) {
4878
0
   _internal_set_math_const(value);
4879
0
  // @@protoc_insertion_point(field_set:ruby_fuzzer.MathConst.math_const)
4880
0
}
4881
3.08k
inline ::ruby_fuzzer::MathConst_MathConstLit MathConst::_internal_math_const() const {
4882
3.08k
  return static_cast<::ruby_fuzzer::MathConst_MathConstLit>(_impl_.math_const_);
4883
3.08k
}
4884
0
inline void MathConst::_internal_set_math_const(::ruby_fuzzer::MathConst_MathConstLit value) {
4885
0
  assert(::ruby_fuzzer::MathConst_MathConstLit_IsValid(value));
4886
0
  _impl_._has_bits_[0] |= 0x00000001u;
4887
0
  _impl_.math_const_ = value;
4888
0
}
4889
4890
// -------------------------------------------------------------------
4891
4892
// Const
4893
4894
// uint32 int_lit = 1;
4895
0
inline bool Const::has_int_lit() const {
4896
0
  return const_oneof_case() == kIntLit;
4897
0
}
4898
0
inline void Const::set_has_int_lit() {
4899
0
  _impl_._oneof_case_[0] = kIntLit;
4900
0
}
4901
0
inline void Const::clear_int_lit() {
4902
0
  if (const_oneof_case() == kIntLit) {
4903
0
    _impl_.const_oneof_.int_lit_ = 0u;
4904
0
    clear_has_const_oneof();
4905
0
  }
4906
0
}
4907
32.2k
inline ::uint32_t Const::int_lit() const {
4908
  // @@protoc_insertion_point(field_get:ruby_fuzzer.Const.int_lit)
4909
32.2k
  return _internal_int_lit();
4910
32.2k
}
4911
0
inline void Const::set_int_lit(::uint32_t value) {
4912
0
  _internal_set_int_lit(value);
4913
0
  // @@protoc_insertion_point(field_set:ruby_fuzzer.Const.int_lit)
4914
0
}
4915
32.2k
inline ::uint32_t Const::_internal_int_lit() const {
4916
32.2k
  if (const_oneof_case() == kIntLit) {
4917
32.2k
    return _impl_.const_oneof_.int_lit_;
4918
32.2k
  }
4919
0
  return 0u;
4920
32.2k
}
4921
0
inline void Const::_internal_set_int_lit(::uint32_t value) {
4922
0
  if (const_oneof_case() != kIntLit) {
4923
0
    clear_const_oneof();
4924
0
    set_has_int_lit();
4925
0
  }
4926
0
  _impl_.const_oneof_.int_lit_ = value;
4927
0
}
4928
4929
// bool bool_val = 4;
4930
0
inline bool Const::has_bool_val() const {
4931
0
  return const_oneof_case() == kBoolVal;
4932
0
}
4933
0
inline void Const::set_has_bool_val() {
4934
0
  _impl_._oneof_case_[0] = kBoolVal;
4935
0
}
4936
0
inline void Const::clear_bool_val() {
4937
0
  if (const_oneof_case() == kBoolVal) {
4938
0
    _impl_.const_oneof_.bool_val_ = false;
4939
0
    clear_has_const_oneof();
4940
0
  }
4941
0
}
4942
12.1k
inline bool Const::bool_val() const {
4943
  // @@protoc_insertion_point(field_get:ruby_fuzzer.Const.bool_val)
4944
12.1k
  return _internal_bool_val();
4945
12.1k
}
4946
0
inline void Const::set_bool_val(bool value) {
4947
0
  _internal_set_bool_val(value);
4948
0
  // @@protoc_insertion_point(field_set:ruby_fuzzer.Const.bool_val)
4949
0
}
4950
12.1k
inline bool Const::_internal_bool_val() const {
4951
12.1k
  if (const_oneof_case() == kBoolVal) {
4952
12.1k
    return _impl_.const_oneof_.bool_val_;
4953
12.1k
  }
4954
0
  return false;
4955
12.1k
}
4956
0
inline void Const::_internal_set_bool_val(bool value) {
4957
0
  if (const_oneof_case() != kBoolVal) {
4958
0
    clear_const_oneof();
4959
0
    set_has_bool_val();
4960
0
  }
4961
0
  _impl_.const_oneof_.bool_val_ = value;
4962
0
}
4963
4964
291k
inline bool Const::has_const_oneof() const {
4965
291k
  return const_oneof_case() != CONST_ONEOF_NOT_SET;
4966
291k
}
4967
291k
inline void Const::clear_has_const_oneof() {
4968
291k
  _impl_._oneof_case_[0] = CONST_ONEOF_NOT_SET;
4969
291k
}
4970
664k
inline Const::ConstOneofCase Const::const_oneof_case() const {
4971
664k
  return Const::ConstOneofCase(_impl_._oneof_case_[0]);
4972
664k
}
4973
// -------------------------------------------------------------------
4974
4975
// BinaryOp
4976
4977
// required .ruby_fuzzer.BinaryOp.Op op = 1;
4978
0
inline bool BinaryOp::has_op() const {
4979
0
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
4980
0
  return value;
4981
0
}
4982
0
inline void BinaryOp::clear_op() {
4983
0
  _impl_.op_ = 0;
4984
0
  _impl_._has_bits_[0] &= ~0x00000004u;
4985
0
}
4986
130k
inline ::ruby_fuzzer::BinaryOp_Op BinaryOp::op() const {
4987
  // @@protoc_insertion_point(field_get:ruby_fuzzer.BinaryOp.op)
4988
130k
  return _internal_op();
4989
130k
}
4990
0
inline void BinaryOp::set_op(::ruby_fuzzer::BinaryOp_Op value) {
4991
0
   _internal_set_op(value);
4992
0
  // @@protoc_insertion_point(field_set:ruby_fuzzer.BinaryOp.op)
4993
0
}
4994
130k
inline ::ruby_fuzzer::BinaryOp_Op BinaryOp::_internal_op() const {
4995
130k
  return static_cast<::ruby_fuzzer::BinaryOp_Op>(_impl_.op_);
4996
130k
}
4997
0
inline void BinaryOp::_internal_set_op(::ruby_fuzzer::BinaryOp_Op value) {
4998
0
  assert(::ruby_fuzzer::BinaryOp_Op_IsValid(value));
4999
0
  _impl_._has_bits_[0] |= 0x00000004u;
5000
0
  _impl_.op_ = value;
5001
0
}
5002
5003
// required .ruby_fuzzer.Rvalue left = 2;
5004
0
inline bool BinaryOp::has_left() const {
5005
0
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
5006
0
  PROTOBUF_ASSUME(!value || _impl_.left_ != nullptr);
5007
0
  return value;
5008
0
}
5009
0
inline void BinaryOp::clear_left() {
5010
0
  if (_impl_.left_ != nullptr) _impl_.left_->Clear();
5011
0
  _impl_._has_bits_[0] &= ~0x00000001u;
5012
0
}
5013
130k
inline const ::ruby_fuzzer::Rvalue& BinaryOp::_internal_left() const {
5014
130k
  const ::ruby_fuzzer::Rvalue* p = _impl_.left_;
5015
130k
  return p != nullptr ? *p : reinterpret_cast<const ::ruby_fuzzer::Rvalue&>(
5016
0
      ::ruby_fuzzer::_Rvalue_default_instance_);
5017
130k
}
5018
130k
inline const ::ruby_fuzzer::Rvalue& BinaryOp::left() const {
5019
  // @@protoc_insertion_point(field_get:ruby_fuzzer.BinaryOp.left)
5020
130k
  return _internal_left();
5021
130k
}
5022
inline void BinaryOp::unsafe_arena_set_allocated_left(
5023
0
    ::ruby_fuzzer::Rvalue* left) {
5024
0
  if (GetArenaForAllocation() == nullptr) {
5025
0
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.left_);
5026
0
  }
5027
0
  _impl_.left_ = left;
5028
0
  if (left) {
5029
0
    _impl_._has_bits_[0] |= 0x00000001u;
5030
0
  } else {
5031
0
    _impl_._has_bits_[0] &= ~0x00000001u;
5032
0
  }
5033
0
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ruby_fuzzer.BinaryOp.left)
5034
0
}
5035
0
inline ::ruby_fuzzer::Rvalue* BinaryOp::release_left() {
5036
0
  _impl_._has_bits_[0] &= ~0x00000001u;
5037
0
  ::ruby_fuzzer::Rvalue* temp = _impl_.left_;
5038
0
  _impl_.left_ = nullptr;
5039
0
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
5040
0
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
5041
0
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
5042
0
  if (GetArenaForAllocation() == nullptr) { delete old; }
5043
0
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
5044
0
  if (GetArenaForAllocation() != nullptr) {
5045
0
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
5046
0
  }
5047
0
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
5048
0
  return temp;
5049
0
}
5050
0
inline ::ruby_fuzzer::Rvalue* BinaryOp::unsafe_arena_release_left() {
5051
0
  // @@protoc_insertion_point(field_release:ruby_fuzzer.BinaryOp.left)
5052
0
  _impl_._has_bits_[0] &= ~0x00000001u;
5053
0
  ::ruby_fuzzer::Rvalue* temp = _impl_.left_;
5054
0
  _impl_.left_ = nullptr;
5055
0
  return temp;
5056
0
}
5057
0
inline ::ruby_fuzzer::Rvalue* BinaryOp::_internal_mutable_left() {
5058
0
  _impl_._has_bits_[0] |= 0x00000001u;
5059
0
  if (_impl_.left_ == nullptr) {
5060
0
    auto* p = CreateMaybeMessage<::ruby_fuzzer::Rvalue>(GetArenaForAllocation());
5061
0
    _impl_.left_ = p;
5062
0
  }
5063
0
  return _impl_.left_;
5064
0
}
5065
0
inline ::ruby_fuzzer::Rvalue* BinaryOp::mutable_left() {
5066
0
  ::ruby_fuzzer::Rvalue* _msg = _internal_mutable_left();
5067
0
  // @@protoc_insertion_point(field_mutable:ruby_fuzzer.BinaryOp.left)
5068
0
  return _msg;
5069
0
}
5070
0
inline void BinaryOp::set_allocated_left(::ruby_fuzzer::Rvalue* left) {
5071
0
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
5072
0
  if (message_arena == nullptr) {
5073
0
    delete _impl_.left_;
5074
0
  }
5075
0
  if (left) {
5076
0
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
5077
0
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(left);
5078
0
    if (message_arena != submessage_arena) {
5079
0
      left = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
5080
0
          message_arena, left, submessage_arena);
5081
0
    }
5082
0
    _impl_._has_bits_[0] |= 0x00000001u;
5083
0
  } else {
5084
0
    _impl_._has_bits_[0] &= ~0x00000001u;
5085
0
  }
5086
0
  _impl_.left_ = left;
5087
0
  // @@protoc_insertion_point(field_set_allocated:ruby_fuzzer.BinaryOp.left)
5088
0
}
5089
5090
// required .ruby_fuzzer.Rvalue right = 3;
5091
0
inline bool BinaryOp::has_right() const {
5092
0
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
5093
0
  PROTOBUF_ASSUME(!value || _impl_.right_ != nullptr);
5094
0
  return value;
5095
0
}
5096
0
inline void BinaryOp::clear_right() {
5097
0
  if (_impl_.right_ != nullptr) _impl_.right_->Clear();
5098
0
  _impl_._has_bits_[0] &= ~0x00000002u;
5099
0
}
5100
130k
inline const ::ruby_fuzzer::Rvalue& BinaryOp::_internal_right() const {
5101
130k
  const ::ruby_fuzzer::Rvalue* p = _impl_.right_;
5102
130k
  return p != nullptr ? *p : reinterpret_cast<const ::ruby_fuzzer::Rvalue&>(
5103
0
      ::ruby_fuzzer::_Rvalue_default_instance_);
5104
130k
}
5105
130k
inline const ::ruby_fuzzer::Rvalue& BinaryOp::right() const {
5106
  // @@protoc_insertion_point(field_get:ruby_fuzzer.BinaryOp.right)
5107
130k
  return _internal_right();
5108
130k
}
5109
inline void BinaryOp::unsafe_arena_set_allocated_right(
5110
0
    ::ruby_fuzzer::Rvalue* right) {
5111
0
  if (GetArenaForAllocation() == nullptr) {
5112
0
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.right_);
5113
0
  }
5114
0
  _impl_.right_ = right;
5115
0
  if (right) {
5116
0
    _impl_._has_bits_[0] |= 0x00000002u;
5117
0
  } else {
5118
0
    _impl_._has_bits_[0] &= ~0x00000002u;
5119
0
  }
5120
0
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ruby_fuzzer.BinaryOp.right)
5121
0
}
5122
0
inline ::ruby_fuzzer::Rvalue* BinaryOp::release_right() {
5123
0
  _impl_._has_bits_[0] &= ~0x00000002u;
5124
0
  ::ruby_fuzzer::Rvalue* temp = _impl_.right_;
5125
0
  _impl_.right_ = nullptr;
5126
0
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
5127
0
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
5128
0
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
5129
0
  if (GetArenaForAllocation() == nullptr) { delete old; }
5130
0
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
5131
0
  if (GetArenaForAllocation() != nullptr) {
5132
0
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
5133
0
  }
5134
0
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
5135
0
  return temp;
5136
0
}
5137
0
inline ::ruby_fuzzer::Rvalue* BinaryOp::unsafe_arena_release_right() {
5138
0
  // @@protoc_insertion_point(field_release:ruby_fuzzer.BinaryOp.right)
5139
0
  _impl_._has_bits_[0] &= ~0x00000002u;
5140
0
  ::ruby_fuzzer::Rvalue* temp = _impl_.right_;
5141
0
  _impl_.right_ = nullptr;
5142
0
  return temp;
5143
0
}
5144
0
inline ::ruby_fuzzer::Rvalue* BinaryOp::_internal_mutable_right() {
5145
0
  _impl_._has_bits_[0] |= 0x00000002u;
5146
0
  if (_impl_.right_ == nullptr) {
5147
0
    auto* p = CreateMaybeMessage<::ruby_fuzzer::Rvalue>(GetArenaForAllocation());
5148
0
    _impl_.right_ = p;
5149
0
  }
5150
0
  return _impl_.right_;
5151
0
}
5152
0
inline ::ruby_fuzzer::Rvalue* BinaryOp::mutable_right() {
5153
0
  ::ruby_fuzzer::Rvalue* _msg = _internal_mutable_right();
5154
0
  // @@protoc_insertion_point(field_mutable:ruby_fuzzer.BinaryOp.right)
5155
0
  return _msg;
5156
0
}
5157
0
inline void BinaryOp::set_allocated_right(::ruby_fuzzer::Rvalue* right) {
5158
0
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
5159
0
  if (message_arena == nullptr) {
5160
0
    delete _impl_.right_;
5161
0
  }
5162
0
  if (right) {
5163
0
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
5164
0
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(right);
5165
0
    if (message_arena != submessage_arena) {
5166
0
      right = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
5167
0
          message_arena, right, submessage_arena);
5168
0
    }
5169
0
    _impl_._has_bits_[0] |= 0x00000002u;
5170
0
  } else {
5171
0
    _impl_._has_bits_[0] &= ~0x00000002u;
5172
0
  }
5173
0
  _impl_.right_ = right;
5174
0
  // @@protoc_insertion_point(field_set_allocated:ruby_fuzzer.BinaryOp.right)
5175
0
}
5176
5177
// -------------------------------------------------------------------
5178
5179
// Rvalue
5180
5181
// .ruby_fuzzer.VarRef varref = 1;
5182
0
inline bool Rvalue::has_varref() const {
5183
0
  return rvalue_oneof_case() == kVarref;
5184
0
}
5185
0
inline bool Rvalue::_internal_has_varref() const {
5186
0
  return rvalue_oneof_case() == kVarref;
5187
0
}
5188
0
inline void Rvalue::set_has_varref() {
5189
0
  _impl_._oneof_case_[0] = kVarref;
5190
0
}
5191
0
inline void Rvalue::clear_varref() {
5192
0
  if (rvalue_oneof_case() == kVarref) {
5193
0
    if (GetArenaForAllocation() == nullptr) {
5194
0
      delete _impl_.rvalue_oneof_.varref_;
5195
0
    }
5196
0
    clear_has_rvalue_oneof();
5197
0
  }
5198
0
}
5199
0
inline ::ruby_fuzzer::VarRef* Rvalue::release_varref() {
5200
0
  // @@protoc_insertion_point(field_release:ruby_fuzzer.Rvalue.varref)
5201
0
  if (rvalue_oneof_case() == kVarref) {
5202
0
    clear_has_rvalue_oneof();
5203
0
    ::ruby_fuzzer::VarRef* temp = _impl_.rvalue_oneof_.varref_;
5204
0
    if (GetArenaForAllocation() != nullptr) {
5205
0
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
5206
0
    }
5207
0
    _impl_.rvalue_oneof_.varref_ = nullptr;
5208
0
    return temp;
5209
0
  } else {
5210
0
    return nullptr;
5211
0
  }
5212
0
}
5213
72.8k
inline const ::ruby_fuzzer::VarRef& Rvalue::_internal_varref() const {
5214
72.8k
  return rvalue_oneof_case() == kVarref
5215
72.8k
      ? *_impl_.rvalue_oneof_.varref_
5216
72.8k
      : reinterpret_cast< ::ruby_fuzzer::VarRef&>(::ruby_fuzzer::_VarRef_default_instance_);
5217
72.8k
}
5218
72.8k
inline const ::ruby_fuzzer::VarRef& Rvalue::varref() const {
5219
  // @@protoc_insertion_point(field_get:ruby_fuzzer.Rvalue.varref)
5220
72.8k
  return _internal_varref();
5221
72.8k
}
5222
0
inline ::ruby_fuzzer::VarRef* Rvalue::unsafe_arena_release_varref() {
5223
0
  // @@protoc_insertion_point(field_unsafe_arena_release:ruby_fuzzer.Rvalue.varref)
5224
0
  if (rvalue_oneof_case() == kVarref) {
5225
0
    clear_has_rvalue_oneof();
5226
0
    ::ruby_fuzzer::VarRef* temp = _impl_.rvalue_oneof_.varref_;
5227
0
    _impl_.rvalue_oneof_.varref_ = nullptr;
5228
0
    return temp;
5229
0
  } else {
5230
0
    return nullptr;
5231
0
  }
5232
0
}
5233
0
inline void Rvalue::unsafe_arena_set_allocated_varref(::ruby_fuzzer::VarRef* varref) {
5234
0
  clear_rvalue_oneof();
5235
0
  if (varref) {
5236
0
    set_has_varref();
5237
0
    _impl_.rvalue_oneof_.varref_ = varref;
5238
0
  }
5239
0
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ruby_fuzzer.Rvalue.varref)
5240
0
}
5241
0
inline ::ruby_fuzzer::VarRef* Rvalue::_internal_mutable_varref() {
5242
0
  if (rvalue_oneof_case() != kVarref) {
5243
0
    clear_rvalue_oneof();
5244
0
    set_has_varref();
5245
0
    _impl_.rvalue_oneof_.varref_ = CreateMaybeMessage< ::ruby_fuzzer::VarRef >(GetArenaForAllocation());
5246
0
  }
5247
0
  return _impl_.rvalue_oneof_.varref_;
5248
0
}
5249
0
inline ::ruby_fuzzer::VarRef* Rvalue::mutable_varref() {
5250
0
  ::ruby_fuzzer::VarRef* _msg = _internal_mutable_varref();
5251
0
  // @@protoc_insertion_point(field_mutable:ruby_fuzzer.Rvalue.varref)
5252
0
  return _msg;
5253
0
}
5254
5255
// .ruby_fuzzer.Const cons = 2;
5256
0
inline bool Rvalue::has_cons() const {
5257
0
  return rvalue_oneof_case() == kCons;
5258
0
}
5259
0
inline bool Rvalue::_internal_has_cons() const {
5260
0
  return rvalue_oneof_case() == kCons;
5261
0
}
5262
0
inline void Rvalue::set_has_cons() {
5263
0
  _impl_._oneof_case_[0] = kCons;
5264
0
}
5265
0
inline void Rvalue::clear_cons() {
5266
0
  if (rvalue_oneof_case() == kCons) {
5267
0
    if (GetArenaForAllocation() == nullptr) {
5268
0
      delete _impl_.rvalue_oneof_.cons_;
5269
0
    }
5270
0
    clear_has_rvalue_oneof();
5271
0
  }
5272
0
}
5273
0
inline ::ruby_fuzzer::Const* Rvalue::release_cons() {
5274
0
  // @@protoc_insertion_point(field_release:ruby_fuzzer.Rvalue.cons)
5275
0
  if (rvalue_oneof_case() == kCons) {
5276
0
    clear_has_rvalue_oneof();
5277
0
    ::ruby_fuzzer::Const* temp = _impl_.rvalue_oneof_.cons_;
5278
0
    if (GetArenaForAllocation() != nullptr) {
5279
0
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
5280
0
    }
5281
0
    _impl_.rvalue_oneof_.cons_ = nullptr;
5282
0
    return temp;
5283
0
  } else {
5284
0
    return nullptr;
5285
0
  }
5286
0
}
5287
38.2k
inline const ::ruby_fuzzer::Const& Rvalue::_internal_cons() const {
5288
38.2k
  return rvalue_oneof_case() == kCons
5289
38.2k
      ? *_impl_.rvalue_oneof_.cons_
5290
38.2k
      : reinterpret_cast< ::ruby_fuzzer::Const&>(::ruby_fuzzer::_Const_default_instance_);
5291
38.2k
}
5292
38.2k
inline const ::ruby_fuzzer::Const& Rvalue::cons() const {
5293
  // @@protoc_insertion_point(field_get:ruby_fuzzer.Rvalue.cons)
5294
38.2k
  return _internal_cons();
5295
38.2k
}
5296
0
inline ::ruby_fuzzer::Const* Rvalue::unsafe_arena_release_cons() {
5297
0
  // @@protoc_insertion_point(field_unsafe_arena_release:ruby_fuzzer.Rvalue.cons)
5298
0
  if (rvalue_oneof_case() == kCons) {
5299
0
    clear_has_rvalue_oneof();
5300
0
    ::ruby_fuzzer::Const* temp = _impl_.rvalue_oneof_.cons_;
5301
0
    _impl_.rvalue_oneof_.cons_ = nullptr;
5302
0
    return temp;
5303
0
  } else {
5304
0
    return nullptr;
5305
0
  }
5306
0
}
5307
0
inline void Rvalue::unsafe_arena_set_allocated_cons(::ruby_fuzzer::Const* cons) {
5308
0
  clear_rvalue_oneof();
5309
0
  if (cons) {
5310
0
    set_has_cons();
5311
0
    _impl_.rvalue_oneof_.cons_ = cons;
5312
0
  }
5313
0
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ruby_fuzzer.Rvalue.cons)
5314
0
}
5315
0
inline ::ruby_fuzzer::Const* Rvalue::_internal_mutable_cons() {
5316
0
  if (rvalue_oneof_case() != kCons) {
5317
0
    clear_rvalue_oneof();
5318
0
    set_has_cons();
5319
0
    _impl_.rvalue_oneof_.cons_ = CreateMaybeMessage< ::ruby_fuzzer::Const >(GetArenaForAllocation());
5320
0
  }
5321
0
  return _impl_.rvalue_oneof_.cons_;
5322
0
}
5323
0
inline ::ruby_fuzzer::Const* Rvalue::mutable_cons() {
5324
0
  ::ruby_fuzzer::Const* _msg = _internal_mutable_cons();
5325
0
  // @@protoc_insertion_point(field_mutable:ruby_fuzzer.Rvalue.cons)
5326
0
  return _msg;
5327
0
}
5328
5329
// .ruby_fuzzer.BinaryOp binop = 3;
5330
0
inline bool Rvalue::has_binop() const {
5331
0
  return rvalue_oneof_case() == kBinop;
5332
0
}
5333
0
inline bool Rvalue::_internal_has_binop() const {
5334
0
  return rvalue_oneof_case() == kBinop;
5335
0
}
5336
0
inline void Rvalue::set_has_binop() {
5337
0
  _impl_._oneof_case_[0] = kBinop;
5338
0
}
5339
0
inline void Rvalue::clear_binop() {
5340
0
  if (rvalue_oneof_case() == kBinop) {
5341
0
    if (GetArenaForAllocation() == nullptr) {
5342
0
      delete _impl_.rvalue_oneof_.binop_;
5343
0
    }
5344
0
    clear_has_rvalue_oneof();
5345
0
  }
5346
0
}
5347
0
inline ::ruby_fuzzer::BinaryOp* Rvalue::release_binop() {
5348
0
  // @@protoc_insertion_point(field_release:ruby_fuzzer.Rvalue.binop)
5349
0
  if (rvalue_oneof_case() == kBinop) {
5350
0
    clear_has_rvalue_oneof();
5351
0
    ::ruby_fuzzer::BinaryOp* temp = _impl_.rvalue_oneof_.binop_;
5352
0
    if (GetArenaForAllocation() != nullptr) {
5353
0
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
5354
0
    }
5355
0
    _impl_.rvalue_oneof_.binop_ = nullptr;
5356
0
    return temp;
5357
0
  } else {
5358
0
    return nullptr;
5359
0
  }
5360
0
}
5361
130k
inline const ::ruby_fuzzer::BinaryOp& Rvalue::_internal_binop() const {
5362
130k
  return rvalue_oneof_case() == kBinop
5363
130k
      ? *_impl_.rvalue_oneof_.binop_
5364
130k
      : reinterpret_cast< ::ruby_fuzzer::BinaryOp&>(::ruby_fuzzer::_BinaryOp_default_instance_);
5365
130k
}
5366
130k
inline const ::ruby_fuzzer::BinaryOp& Rvalue::binop() const {
5367
  // @@protoc_insertion_point(field_get:ruby_fuzzer.Rvalue.binop)
5368
130k
  return _internal_binop();
5369
130k
}
5370
0
inline ::ruby_fuzzer::BinaryOp* Rvalue::unsafe_arena_release_binop() {
5371
0
  // @@protoc_insertion_point(field_unsafe_arena_release:ruby_fuzzer.Rvalue.binop)
5372
0
  if (rvalue_oneof_case() == kBinop) {
5373
0
    clear_has_rvalue_oneof();
5374
0
    ::ruby_fuzzer::BinaryOp* temp = _impl_.rvalue_oneof_.binop_;
5375
0
    _impl_.rvalue_oneof_.binop_ = nullptr;
5376
0
    return temp;
5377
0
  } else {
5378
0
    return nullptr;
5379
0
  }
5380
0
}
5381
0
inline void Rvalue::unsafe_arena_set_allocated_binop(::ruby_fuzzer::BinaryOp* binop) {
5382
0
  clear_rvalue_oneof();
5383
0
  if (binop) {
5384
0
    set_has_binop();
5385
0
    _impl_.rvalue_oneof_.binop_ = binop;
5386
0
  }
5387
0
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ruby_fuzzer.Rvalue.binop)
5388
0
}
5389
0
inline ::ruby_fuzzer::BinaryOp* Rvalue::_internal_mutable_binop() {
5390
0
  if (rvalue_oneof_case() != kBinop) {
5391
0
    clear_rvalue_oneof();
5392
0
    set_has_binop();
5393
0
    _impl_.rvalue_oneof_.binop_ = CreateMaybeMessage< ::ruby_fuzzer::BinaryOp >(GetArenaForAllocation());
5394
0
  }
5395
0
  return _impl_.rvalue_oneof_.binop_;
5396
0
}
5397
0
inline ::ruby_fuzzer::BinaryOp* Rvalue::mutable_binop() {
5398
0
  ::ruby_fuzzer::BinaryOp* _msg = _internal_mutable_binop();
5399
0
  // @@protoc_insertion_point(field_mutable:ruby_fuzzer.Rvalue.binop)
5400
0
  return _msg;
5401
0
}
5402
5403
580k
inline bool Rvalue::has_rvalue_oneof() const {
5404
580k
  return rvalue_oneof_case() != RVALUE_ONEOF_NOT_SET;
5405
580k
}
5406
580k
inline void Rvalue::clear_has_rvalue_oneof() {
5407
580k
  _impl_._oneof_case_[0] = RVALUE_ONEOF_NOT_SET;
5408
580k
}
5409
1.64M
inline Rvalue::RvalueOneofCase Rvalue::rvalue_oneof_case() const {
5410
1.64M
  return Rvalue::RvalueOneofCase(_impl_._oneof_case_[0]);
5411
1.64M
}
5412
// -------------------------------------------------------------------
5413
5414
// AssignmentStatement
5415
5416
// required .ruby_fuzzer.Rvalue rvalue = 2;
5417
0
inline bool AssignmentStatement::has_rvalue() const {
5418
0
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
5419
0
  PROTOBUF_ASSUME(!value || _impl_.rvalue_ != nullptr);
5420
0
  return value;
5421
0
}
5422
0
inline void AssignmentStatement::clear_rvalue() {
5423
0
  if (_impl_.rvalue_ != nullptr) _impl_.rvalue_->Clear();
5424
0
  _impl_._has_bits_[0] &= ~0x00000001u;
5425
0
}
5426
212k
inline const ::ruby_fuzzer::Rvalue& AssignmentStatement::_internal_rvalue() const {
5427
212k
  const ::ruby_fuzzer::Rvalue* p = _impl_.rvalue_;
5428
212k
  return p != nullptr ? *p : reinterpret_cast<const ::ruby_fuzzer::Rvalue&>(
5429
0
      ::ruby_fuzzer::_Rvalue_default_instance_);
5430
212k
}
5431
212k
inline const ::ruby_fuzzer::Rvalue& AssignmentStatement::rvalue() const {
5432
  // @@protoc_insertion_point(field_get:ruby_fuzzer.AssignmentStatement.rvalue)
5433
212k
  return _internal_rvalue();
5434
212k
}
5435
inline void AssignmentStatement::unsafe_arena_set_allocated_rvalue(
5436
0
    ::ruby_fuzzer::Rvalue* rvalue) {
5437
0
  if (GetArenaForAllocation() == nullptr) {
5438
0
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.rvalue_);
5439
0
  }
5440
0
  _impl_.rvalue_ = rvalue;
5441
0
  if (rvalue) {
5442
0
    _impl_._has_bits_[0] |= 0x00000001u;
5443
0
  } else {
5444
0
    _impl_._has_bits_[0] &= ~0x00000001u;
5445
0
  }
5446
0
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ruby_fuzzer.AssignmentStatement.rvalue)
5447
0
}
5448
0
inline ::ruby_fuzzer::Rvalue* AssignmentStatement::release_rvalue() {
5449
0
  _impl_._has_bits_[0] &= ~0x00000001u;
5450
0
  ::ruby_fuzzer::Rvalue* temp = _impl_.rvalue_;
5451
0
  _impl_.rvalue_ = nullptr;
5452
0
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
5453
0
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
5454
0
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
5455
0
  if (GetArenaForAllocation() == nullptr) { delete old; }
5456
0
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
5457
0
  if (GetArenaForAllocation() != nullptr) {
5458
0
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
5459
0
  }
5460
0
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
5461
0
  return temp;
5462
0
}
5463
0
inline ::ruby_fuzzer::Rvalue* AssignmentStatement::unsafe_arena_release_rvalue() {
5464
0
  // @@protoc_insertion_point(field_release:ruby_fuzzer.AssignmentStatement.rvalue)
5465
0
  _impl_._has_bits_[0] &= ~0x00000001u;
5466
0
  ::ruby_fuzzer::Rvalue* temp = _impl_.rvalue_;
5467
0
  _impl_.rvalue_ = nullptr;
5468
0
  return temp;
5469
0
}
5470
0
inline ::ruby_fuzzer::Rvalue* AssignmentStatement::_internal_mutable_rvalue() {
5471
0
  _impl_._has_bits_[0] |= 0x00000001u;
5472
0
  if (_impl_.rvalue_ == nullptr) {
5473
0
    auto* p = CreateMaybeMessage<::ruby_fuzzer::Rvalue>(GetArenaForAllocation());
5474
0
    _impl_.rvalue_ = p;
5475
0
  }
5476
0
  return _impl_.rvalue_;
5477
0
}
5478
0
inline ::ruby_fuzzer::Rvalue* AssignmentStatement::mutable_rvalue() {
5479
0
  ::ruby_fuzzer::Rvalue* _msg = _internal_mutable_rvalue();
5480
0
  // @@protoc_insertion_point(field_mutable:ruby_fuzzer.AssignmentStatement.rvalue)
5481
0
  return _msg;
5482
0
}
5483
0
inline void AssignmentStatement::set_allocated_rvalue(::ruby_fuzzer::Rvalue* rvalue) {
5484
0
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
5485
0
  if (message_arena == nullptr) {
5486
0
    delete _impl_.rvalue_;
5487
0
  }
5488
0
  if (rvalue) {
5489
0
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
5490
0
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(rvalue);
5491
0
    if (message_arena != submessage_arena) {
5492
0
      rvalue = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
5493
0
          message_arena, rvalue, submessage_arena);
5494
0
    }
5495
0
    _impl_._has_bits_[0] |= 0x00000001u;
5496
0
  } else {
5497
0
    _impl_._has_bits_[0] &= ~0x00000001u;
5498
0
  }
5499
0
  _impl_.rvalue_ = rvalue;
5500
0
  // @@protoc_insertion_point(field_set_allocated:ruby_fuzzer.AssignmentStatement.rvalue)
5501
0
}
5502
5503
// -------------------------------------------------------------------
5504
5505
// IfElse
5506
5507
// required .ruby_fuzzer.Rvalue cond = 1;
5508
0
inline bool IfElse::has_cond() const {
5509
0
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
5510
0
  PROTOBUF_ASSUME(!value || _impl_.cond_ != nullptr);
5511
0
  return value;
5512
0
}
5513
0
inline void IfElse::clear_cond() {
5514
0
  if (_impl_.cond_ != nullptr) _impl_.cond_->Clear();
5515
0
  _impl_._has_bits_[0] &= ~0x00000001u;
5516
0
}
5517
17.5k
inline const ::ruby_fuzzer::Rvalue& IfElse::_internal_cond() const {
5518
17.5k
  const ::ruby_fuzzer::Rvalue* p = _impl_.cond_;
5519
17.5k
  return p != nullptr ? *p : reinterpret_cast<const ::ruby_fuzzer::Rvalue&>(
5520
0
      ::ruby_fuzzer::_Rvalue_default_instance_);
5521
17.5k
}
5522
17.5k
inline const ::ruby_fuzzer::Rvalue& IfElse::cond() const {
5523
  // @@protoc_insertion_point(field_get:ruby_fuzzer.IfElse.cond)
5524
17.5k
  return _internal_cond();
5525
17.5k
}
5526
inline void IfElse::unsafe_arena_set_allocated_cond(
5527
0
    ::ruby_fuzzer::Rvalue* cond) {
5528
0
  if (GetArenaForAllocation() == nullptr) {
5529
0
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.cond_);
5530
0
  }
5531
0
  _impl_.cond_ = cond;
5532
0
  if (cond) {
5533
0
    _impl_._has_bits_[0] |= 0x00000001u;
5534
0
  } else {
5535
0
    _impl_._has_bits_[0] &= ~0x00000001u;
5536
0
  }
5537
0
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ruby_fuzzer.IfElse.cond)
5538
0
}
5539
0
inline ::ruby_fuzzer::Rvalue* IfElse::release_cond() {
5540
0
  _impl_._has_bits_[0] &= ~0x00000001u;
5541
0
  ::ruby_fuzzer::Rvalue* temp = _impl_.cond_;
5542
0
  _impl_.cond_ = nullptr;
5543
0
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
5544
0
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
5545
0
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
5546
0
  if (GetArenaForAllocation() == nullptr) { delete old; }
5547
0
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
5548
0
  if (GetArenaForAllocation() != nullptr) {
5549
0
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
5550
0
  }
5551
0
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
5552
0
  return temp;
5553
0
}
5554
0
inline ::ruby_fuzzer::Rvalue* IfElse::unsafe_arena_release_cond() {
5555
0
  // @@protoc_insertion_point(field_release:ruby_fuzzer.IfElse.cond)
5556
0
  _impl_._has_bits_[0] &= ~0x00000001u;
5557
0
  ::ruby_fuzzer::Rvalue* temp = _impl_.cond_;
5558
0
  _impl_.cond_ = nullptr;
5559
0
  return temp;
5560
0
}
5561
0
inline ::ruby_fuzzer::Rvalue* IfElse::_internal_mutable_cond() {
5562
0
  _impl_._has_bits_[0] |= 0x00000001u;
5563
0
  if (_impl_.cond_ == nullptr) {
5564
0
    auto* p = CreateMaybeMessage<::ruby_fuzzer::Rvalue>(GetArenaForAllocation());
5565
0
    _impl_.cond_ = p;
5566
0
  }
5567
0
  return _impl_.cond_;
5568
0
}
5569
0
inline ::ruby_fuzzer::Rvalue* IfElse::mutable_cond() {
5570
0
  ::ruby_fuzzer::Rvalue* _msg = _internal_mutable_cond();
5571
0
  // @@protoc_insertion_point(field_mutable:ruby_fuzzer.IfElse.cond)
5572
0
  return _msg;
5573
0
}
5574
0
inline void IfElse::set_allocated_cond(::ruby_fuzzer::Rvalue* cond) {
5575
0
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
5576
0
  if (message_arena == nullptr) {
5577
0
    delete _impl_.cond_;
5578
0
  }
5579
0
  if (cond) {
5580
0
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
5581
0
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(cond);
5582
0
    if (message_arena != submessage_arena) {
5583
0
      cond = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
5584
0
          message_arena, cond, submessage_arena);
5585
0
    }
5586
0
    _impl_._has_bits_[0] |= 0x00000001u;
5587
0
  } else {
5588
0
    _impl_._has_bits_[0] &= ~0x00000001u;
5589
0
  }
5590
0
  _impl_.cond_ = cond;
5591
0
  // @@protoc_insertion_point(field_set_allocated:ruby_fuzzer.IfElse.cond)
5592
0
}
5593
5594
// required .ruby_fuzzer.StatementSeq if_body = 2;
5595
0
inline bool IfElse::has_if_body() const {
5596
0
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
5597
0
  PROTOBUF_ASSUME(!value || _impl_.if_body_ != nullptr);
5598
0
  return value;
5599
0
}
5600
0
inline void IfElse::clear_if_body() {
5601
0
  if (_impl_.if_body_ != nullptr) _impl_.if_body_->Clear();
5602
0
  _impl_._has_bits_[0] &= ~0x00000002u;
5603
0
}
5604
17.5k
inline const ::ruby_fuzzer::StatementSeq& IfElse::_internal_if_body() const {
5605
17.5k
  const ::ruby_fuzzer::StatementSeq* p = _impl_.if_body_;
5606
17.5k
  return p != nullptr ? *p : reinterpret_cast<const ::ruby_fuzzer::StatementSeq&>(
5607
0
      ::ruby_fuzzer::_StatementSeq_default_instance_);
5608
17.5k
}
5609
17.5k
inline const ::ruby_fuzzer::StatementSeq& IfElse::if_body() const {
5610
  // @@protoc_insertion_point(field_get:ruby_fuzzer.IfElse.if_body)
5611
17.5k
  return _internal_if_body();
5612
17.5k
}
5613
inline void IfElse::unsafe_arena_set_allocated_if_body(
5614
0
    ::ruby_fuzzer::StatementSeq* if_body) {
5615
0
  if (GetArenaForAllocation() == nullptr) {
5616
0
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.if_body_);
5617
0
  }
5618
0
  _impl_.if_body_ = if_body;
5619
0
  if (if_body) {
5620
0
    _impl_._has_bits_[0] |= 0x00000002u;
5621
0
  } else {
5622
0
    _impl_._has_bits_[0] &= ~0x00000002u;
5623
0
  }
5624
0
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ruby_fuzzer.IfElse.if_body)
5625
0
}
5626
0
inline ::ruby_fuzzer::StatementSeq* IfElse::release_if_body() {
5627
0
  _impl_._has_bits_[0] &= ~0x00000002u;
5628
0
  ::ruby_fuzzer::StatementSeq* temp = _impl_.if_body_;
5629
0
  _impl_.if_body_ = nullptr;
5630
0
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
5631
0
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
5632
0
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
5633
0
  if (GetArenaForAllocation() == nullptr) { delete old; }
5634
0
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
5635
0
  if (GetArenaForAllocation() != nullptr) {
5636
0
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
5637
0
  }
5638
0
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
5639
0
  return temp;
5640
0
}
5641
0
inline ::ruby_fuzzer::StatementSeq* IfElse::unsafe_arena_release_if_body() {
5642
0
  // @@protoc_insertion_point(field_release:ruby_fuzzer.IfElse.if_body)
5643
0
  _impl_._has_bits_[0] &= ~0x00000002u;
5644
0
  ::ruby_fuzzer::StatementSeq* temp = _impl_.if_body_;
5645
0
  _impl_.if_body_ = nullptr;
5646
0
  return temp;
5647
0
}
5648
0
inline ::ruby_fuzzer::StatementSeq* IfElse::_internal_mutable_if_body() {
5649
0
  _impl_._has_bits_[0] |= 0x00000002u;
5650
0
  if (_impl_.if_body_ == nullptr) {
5651
0
    auto* p = CreateMaybeMessage<::ruby_fuzzer::StatementSeq>(GetArenaForAllocation());
5652
0
    _impl_.if_body_ = p;
5653
0
  }
5654
0
  return _impl_.if_body_;
5655
0
}
5656
0
inline ::ruby_fuzzer::StatementSeq* IfElse::mutable_if_body() {
5657
0
  ::ruby_fuzzer::StatementSeq* _msg = _internal_mutable_if_body();
5658
0
  // @@protoc_insertion_point(field_mutable:ruby_fuzzer.IfElse.if_body)
5659
0
  return _msg;
5660
0
}
5661
0
inline void IfElse::set_allocated_if_body(::ruby_fuzzer::StatementSeq* if_body) {
5662
0
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
5663
0
  if (message_arena == nullptr) {
5664
0
    delete _impl_.if_body_;
5665
0
  }
5666
0
  if (if_body) {
5667
0
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
5668
0
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(if_body);
5669
0
    if (message_arena != submessage_arena) {
5670
0
      if_body = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
5671
0
          message_arena, if_body, submessage_arena);
5672
0
    }
5673
0
    _impl_._has_bits_[0] |= 0x00000002u;
5674
0
  } else {
5675
0
    _impl_._has_bits_[0] &= ~0x00000002u;
5676
0
  }
5677
0
  _impl_.if_body_ = if_body;
5678
0
  // @@protoc_insertion_point(field_set_allocated:ruby_fuzzer.IfElse.if_body)
5679
0
}
5680
5681
// required .ruby_fuzzer.StatementSeq else_body = 3;
5682
0
inline bool IfElse::has_else_body() const {
5683
0
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
5684
0
  PROTOBUF_ASSUME(!value || _impl_.else_body_ != nullptr);
5685
0
  return value;
5686
0
}
5687
0
inline void IfElse::clear_else_body() {
5688
0
  if (_impl_.else_body_ != nullptr) _impl_.else_body_->Clear();
5689
0
  _impl_._has_bits_[0] &= ~0x00000004u;
5690
0
}
5691
17.5k
inline const ::ruby_fuzzer::StatementSeq& IfElse::_internal_else_body() const {
5692
17.5k
  const ::ruby_fuzzer::StatementSeq* p = _impl_.else_body_;
5693
17.5k
  return p != nullptr ? *p : reinterpret_cast<const ::ruby_fuzzer::StatementSeq&>(
5694
0
      ::ruby_fuzzer::_StatementSeq_default_instance_);
5695
17.5k
}
5696
17.5k
inline const ::ruby_fuzzer::StatementSeq& IfElse::else_body() const {
5697
  // @@protoc_insertion_point(field_get:ruby_fuzzer.IfElse.else_body)
5698
17.5k
  return _internal_else_body();
5699
17.5k
}
5700
inline void IfElse::unsafe_arena_set_allocated_else_body(
5701
0
    ::ruby_fuzzer::StatementSeq* else_body) {
5702
0
  if (GetArenaForAllocation() == nullptr) {
5703
0
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.else_body_);
5704
0
  }
5705
0
  _impl_.else_body_ = else_body;
5706
0
  if (else_body) {
5707
0
    _impl_._has_bits_[0] |= 0x00000004u;
5708
0
  } else {
5709
0
    _impl_._has_bits_[0] &= ~0x00000004u;
5710
0
  }
5711
0
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ruby_fuzzer.IfElse.else_body)
5712
0
}
5713
0
inline ::ruby_fuzzer::StatementSeq* IfElse::release_else_body() {
5714
0
  _impl_._has_bits_[0] &= ~0x00000004u;
5715
0
  ::ruby_fuzzer::StatementSeq* temp = _impl_.else_body_;
5716
0
  _impl_.else_body_ = nullptr;
5717
0
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
5718
0
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
5719
0
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
5720
0
  if (GetArenaForAllocation() == nullptr) { delete old; }
5721
0
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
5722
0
  if (GetArenaForAllocation() != nullptr) {
5723
0
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
5724
0
  }
5725
0
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
5726
0
  return temp;
5727
0
}
5728
0
inline ::ruby_fuzzer::StatementSeq* IfElse::unsafe_arena_release_else_body() {
5729
0
  // @@protoc_insertion_point(field_release:ruby_fuzzer.IfElse.else_body)
5730
0
  _impl_._has_bits_[0] &= ~0x00000004u;
5731
0
  ::ruby_fuzzer::StatementSeq* temp = _impl_.else_body_;
5732
0
  _impl_.else_body_ = nullptr;
5733
0
  return temp;
5734
0
}
5735
0
inline ::ruby_fuzzer::StatementSeq* IfElse::_internal_mutable_else_body() {
5736
0
  _impl_._has_bits_[0] |= 0x00000004u;
5737
0
  if (_impl_.else_body_ == nullptr) {
5738
0
    auto* p = CreateMaybeMessage<::ruby_fuzzer::StatementSeq>(GetArenaForAllocation());
5739
0
    _impl_.else_body_ = p;
5740
0
  }
5741
0
  return _impl_.else_body_;
5742
0
}
5743
0
inline ::ruby_fuzzer::StatementSeq* IfElse::mutable_else_body() {
5744
0
  ::ruby_fuzzer::StatementSeq* _msg = _internal_mutable_else_body();
5745
0
  // @@protoc_insertion_point(field_mutable:ruby_fuzzer.IfElse.else_body)
5746
0
  return _msg;
5747
0
}
5748
0
inline void IfElse::set_allocated_else_body(::ruby_fuzzer::StatementSeq* else_body) {
5749
0
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
5750
0
  if (message_arena == nullptr) {
5751
0
    delete _impl_.else_body_;
5752
0
  }
5753
0
  if (else_body) {
5754
0
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
5755
0
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(else_body);
5756
0
    if (message_arena != submessage_arena) {
5757
0
      else_body = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
5758
0
          message_arena, else_body, submessage_arena);
5759
0
    }
5760
0
    _impl_._has_bits_[0] |= 0x00000004u;
5761
0
  } else {
5762
0
    _impl_._has_bits_[0] &= ~0x00000004u;
5763
0
  }
5764
0
  _impl_.else_body_ = else_body;
5765
0
  // @@protoc_insertion_point(field_set_allocated:ruby_fuzzer.IfElse.else_body)
5766
0
}
5767
5768
// -------------------------------------------------------------------
5769
5770
// Ternary
5771
5772
// required .ruby_fuzzer.Rvalue tern_cond = 1;
5773
0
inline bool Ternary::has_tern_cond() const {
5774
0
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
5775
0
  PROTOBUF_ASSUME(!value || _impl_.tern_cond_ != nullptr);
5776
0
  return value;
5777
0
}
5778
0
inline void Ternary::clear_tern_cond() {
5779
0
  if (_impl_.tern_cond_ != nullptr) _impl_.tern_cond_->Clear();
5780
0
  _impl_._has_bits_[0] &= ~0x00000001u;
5781
0
}
5782
8.56k
inline const ::ruby_fuzzer::Rvalue& Ternary::_internal_tern_cond() const {
5783
8.56k
  const ::ruby_fuzzer::Rvalue* p = _impl_.tern_cond_;
5784
8.56k
  return p != nullptr ? *p : reinterpret_cast<const ::ruby_fuzzer::Rvalue&>(
5785
0
      ::ruby_fuzzer::_Rvalue_default_instance_);
5786
8.56k
}
5787
8.56k
inline const ::ruby_fuzzer::Rvalue& Ternary::tern_cond() const {
5788
  // @@protoc_insertion_point(field_get:ruby_fuzzer.Ternary.tern_cond)
5789
8.56k
  return _internal_tern_cond();
5790
8.56k
}
5791
inline void Ternary::unsafe_arena_set_allocated_tern_cond(
5792
0
    ::ruby_fuzzer::Rvalue* tern_cond) {
5793
0
  if (GetArenaForAllocation() == nullptr) {
5794
0
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.tern_cond_);
5795
0
  }
5796
0
  _impl_.tern_cond_ = tern_cond;
5797
0
  if (tern_cond) {
5798
0
    _impl_._has_bits_[0] |= 0x00000001u;
5799
0
  } else {
5800
0
    _impl_._has_bits_[0] &= ~0x00000001u;
5801
0
  }
5802
0
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ruby_fuzzer.Ternary.tern_cond)
5803
0
}
5804
0
inline ::ruby_fuzzer::Rvalue* Ternary::release_tern_cond() {
5805
0
  _impl_._has_bits_[0] &= ~0x00000001u;
5806
0
  ::ruby_fuzzer::Rvalue* temp = _impl_.tern_cond_;
5807
0
  _impl_.tern_cond_ = nullptr;
5808
0
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
5809
0
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
5810
0
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
5811
0
  if (GetArenaForAllocation() == nullptr) { delete old; }
5812
0
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
5813
0
  if (GetArenaForAllocation() != nullptr) {
5814
0
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
5815
0
  }
5816
0
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
5817
0
  return temp;
5818
0
}
5819
0
inline ::ruby_fuzzer::Rvalue* Ternary::unsafe_arena_release_tern_cond() {
5820
0
  // @@protoc_insertion_point(field_release:ruby_fuzzer.Ternary.tern_cond)
5821
0
  _impl_._has_bits_[0] &= ~0x00000001u;
5822
0
  ::ruby_fuzzer::Rvalue* temp = _impl_.tern_cond_;
5823
0
  _impl_.tern_cond_ = nullptr;
5824
0
  return temp;
5825
0
}
5826
0
inline ::ruby_fuzzer::Rvalue* Ternary::_internal_mutable_tern_cond() {
5827
0
  _impl_._has_bits_[0] |= 0x00000001u;
5828
0
  if (_impl_.tern_cond_ == nullptr) {
5829
0
    auto* p = CreateMaybeMessage<::ruby_fuzzer::Rvalue>(GetArenaForAllocation());
5830
0
    _impl_.tern_cond_ = p;
5831
0
  }
5832
0
  return _impl_.tern_cond_;
5833
0
}
5834
0
inline ::ruby_fuzzer::Rvalue* Ternary::mutable_tern_cond() {
5835
0
  ::ruby_fuzzer::Rvalue* _msg = _internal_mutable_tern_cond();
5836
0
  // @@protoc_insertion_point(field_mutable:ruby_fuzzer.Ternary.tern_cond)
5837
0
  return _msg;
5838
0
}
5839
0
inline void Ternary::set_allocated_tern_cond(::ruby_fuzzer::Rvalue* tern_cond) {
5840
0
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
5841
0
  if (message_arena == nullptr) {
5842
0
    delete _impl_.tern_cond_;
5843
0
  }
5844
0
  if (tern_cond) {
5845
0
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
5846
0
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(tern_cond);
5847
0
    if (message_arena != submessage_arena) {
5848
0
      tern_cond = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
5849
0
          message_arena, tern_cond, submessage_arena);
5850
0
    }
5851
0
    _impl_._has_bits_[0] |= 0x00000001u;
5852
0
  } else {
5853
0
    _impl_._has_bits_[0] &= ~0x00000001u;
5854
0
  }
5855
0
  _impl_.tern_cond_ = tern_cond;
5856
0
  // @@protoc_insertion_point(field_set_allocated:ruby_fuzzer.Ternary.tern_cond)
5857
0
}
5858
5859
// required .ruby_fuzzer.Rvalue t_branch = 2;
5860
0
inline bool Ternary::has_t_branch() const {
5861
0
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
5862
0
  PROTOBUF_ASSUME(!value || _impl_.t_branch_ != nullptr);
5863
0
  return value;
5864
0
}
5865
0
inline void Ternary::clear_t_branch() {
5866
0
  if (_impl_.t_branch_ != nullptr) _impl_.t_branch_->Clear();
5867
0
  _impl_._has_bits_[0] &= ~0x00000002u;
5868
0
}
5869
8.56k
inline const ::ruby_fuzzer::Rvalue& Ternary::_internal_t_branch() const {
5870
8.56k
  const ::ruby_fuzzer::Rvalue* p = _impl_.t_branch_;
5871
8.56k
  return p != nullptr ? *p : reinterpret_cast<const ::ruby_fuzzer::Rvalue&>(
5872
0
      ::ruby_fuzzer::_Rvalue_default_instance_);
5873
8.56k
}
5874
8.56k
inline const ::ruby_fuzzer::Rvalue& Ternary::t_branch() const {
5875
  // @@protoc_insertion_point(field_get:ruby_fuzzer.Ternary.t_branch)
5876
8.56k
  return _internal_t_branch();
5877
8.56k
}
5878
inline void Ternary::unsafe_arena_set_allocated_t_branch(
5879
0
    ::ruby_fuzzer::Rvalue* t_branch) {
5880
0
  if (GetArenaForAllocation() == nullptr) {
5881
0
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.t_branch_);
5882
0
  }
5883
0
  _impl_.t_branch_ = t_branch;
5884
0
  if (t_branch) {
5885
0
    _impl_._has_bits_[0] |= 0x00000002u;
5886
0
  } else {
5887
0
    _impl_._has_bits_[0] &= ~0x00000002u;
5888
0
  }
5889
0
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ruby_fuzzer.Ternary.t_branch)
5890
0
}
5891
0
inline ::ruby_fuzzer::Rvalue* Ternary::release_t_branch() {
5892
0
  _impl_._has_bits_[0] &= ~0x00000002u;
5893
0
  ::ruby_fuzzer::Rvalue* temp = _impl_.t_branch_;
5894
0
  _impl_.t_branch_ = nullptr;
5895
0
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
5896
0
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
5897
0
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
5898
0
  if (GetArenaForAllocation() == nullptr) { delete old; }
5899
0
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
5900
0
  if (GetArenaForAllocation() != nullptr) {
5901
0
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
5902
0
  }
5903
0
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
5904
0
  return temp;
5905
0
}
5906
0
inline ::ruby_fuzzer::Rvalue* Ternary::unsafe_arena_release_t_branch() {
5907
0
  // @@protoc_insertion_point(field_release:ruby_fuzzer.Ternary.t_branch)
5908
0
  _impl_._has_bits_[0] &= ~0x00000002u;
5909
0
  ::ruby_fuzzer::Rvalue* temp = _impl_.t_branch_;
5910
0
  _impl_.t_branch_ = nullptr;
5911
0
  return temp;
5912
0
}
5913
0
inline ::ruby_fuzzer::Rvalue* Ternary::_internal_mutable_t_branch() {
5914
0
  _impl_._has_bits_[0] |= 0x00000002u;
5915
0
  if (_impl_.t_branch_ == nullptr) {
5916
0
    auto* p = CreateMaybeMessage<::ruby_fuzzer::Rvalue>(GetArenaForAllocation());
5917
0
    _impl_.t_branch_ = p;
5918
0
  }
5919
0
  return _impl_.t_branch_;
5920
0
}
5921
0
inline ::ruby_fuzzer::Rvalue* Ternary::mutable_t_branch() {
5922
0
  ::ruby_fuzzer::Rvalue* _msg = _internal_mutable_t_branch();
5923
0
  // @@protoc_insertion_point(field_mutable:ruby_fuzzer.Ternary.t_branch)
5924
0
  return _msg;
5925
0
}
5926
0
inline void Ternary::set_allocated_t_branch(::ruby_fuzzer::Rvalue* t_branch) {
5927
0
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
5928
0
  if (message_arena == nullptr) {
5929
0
    delete _impl_.t_branch_;
5930
0
  }
5931
0
  if (t_branch) {
5932
0
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
5933
0
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(t_branch);
5934
0
    if (message_arena != submessage_arena) {
5935
0
      t_branch = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
5936
0
          message_arena, t_branch, submessage_arena);
5937
0
    }
5938
0
    _impl_._has_bits_[0] |= 0x00000002u;
5939
0
  } else {
5940
0
    _impl_._has_bits_[0] &= ~0x00000002u;
5941
0
  }
5942
0
  _impl_.t_branch_ = t_branch;
5943
0
  // @@protoc_insertion_point(field_set_allocated:ruby_fuzzer.Ternary.t_branch)
5944
0
}
5945
5946
// required .ruby_fuzzer.Rvalue f_branch = 3;
5947
0
inline bool Ternary::has_f_branch() const {
5948
0
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
5949
0
  PROTOBUF_ASSUME(!value || _impl_.f_branch_ != nullptr);
5950
0
  return value;
5951
0
}
5952
0
inline void Ternary::clear_f_branch() {
5953
0
  if (_impl_.f_branch_ != nullptr) _impl_.f_branch_->Clear();
5954
0
  _impl_._has_bits_[0] &= ~0x00000004u;
5955
0
}
5956
8.56k
inline const ::ruby_fuzzer::Rvalue& Ternary::_internal_f_branch() const {
5957
8.56k
  const ::ruby_fuzzer::Rvalue* p = _impl_.f_branch_;
5958
8.56k
  return p != nullptr ? *p : reinterpret_cast<const ::ruby_fuzzer::Rvalue&>(
5959
0
      ::ruby_fuzzer::_Rvalue_default_instance_);
5960
8.56k
}
5961
8.56k
inline const ::ruby_fuzzer::Rvalue& Ternary::f_branch() const {
5962
  // @@protoc_insertion_point(field_get:ruby_fuzzer.Ternary.f_branch)
5963
8.56k
  return _internal_f_branch();
5964
8.56k
}
5965
inline void Ternary::unsafe_arena_set_allocated_f_branch(
5966
0
    ::ruby_fuzzer::Rvalue* f_branch) {
5967
0
  if (GetArenaForAllocation() == nullptr) {
5968
0
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.f_branch_);
5969
0
  }
5970
0
  _impl_.f_branch_ = f_branch;
5971
0
  if (f_branch) {
5972
0
    _impl_._has_bits_[0] |= 0x00000004u;
5973
0
  } else {
5974
0
    _impl_._has_bits_[0] &= ~0x00000004u;
5975
0
  }
5976
0
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ruby_fuzzer.Ternary.f_branch)
5977
0
}
5978
0
inline ::ruby_fuzzer::Rvalue* Ternary::release_f_branch() {
5979
0
  _impl_._has_bits_[0] &= ~0x00000004u;
5980
0
  ::ruby_fuzzer::Rvalue* temp = _impl_.f_branch_;
5981
0
  _impl_.f_branch_ = nullptr;
5982
0
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
5983
0
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
5984
0
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
5985
0
  if (GetArenaForAllocation() == nullptr) { delete old; }
5986
0
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
5987
0
  if (GetArenaForAllocation() != nullptr) {
5988
0
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
5989
0
  }
5990
0
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
5991
0
  return temp;
5992
0
}
5993
0
inline ::ruby_fuzzer::Rvalue* Ternary::unsafe_arena_release_f_branch() {
5994
0
  // @@protoc_insertion_point(field_release:ruby_fuzzer.Ternary.f_branch)
5995
0
  _impl_._has_bits_[0] &= ~0x00000004u;
5996
0
  ::ruby_fuzzer::Rvalue* temp = _impl_.f_branch_;
5997
0
  _impl_.f_branch_ = nullptr;
5998
0
  return temp;
5999
0
}
6000
0
inline ::ruby_fuzzer::Rvalue* Ternary::_internal_mutable_f_branch() {
6001
0
  _impl_._has_bits_[0] |= 0x00000004u;
6002
0
  if (_impl_.f_branch_ == nullptr) {
6003
0
    auto* p = CreateMaybeMessage<::ruby_fuzzer::Rvalue>(GetArenaForAllocation());
6004
0
    _impl_.f_branch_ = p;
6005
0
  }
6006
0
  return _impl_.f_branch_;
6007
0
}
6008
0
inline ::ruby_fuzzer::Rvalue* Ternary::mutable_f_branch() {
6009
0
  ::ruby_fuzzer::Rvalue* _msg = _internal_mutable_f_branch();
6010
0
  // @@protoc_insertion_point(field_mutable:ruby_fuzzer.Ternary.f_branch)
6011
0
  return _msg;
6012
0
}
6013
0
inline void Ternary::set_allocated_f_branch(::ruby_fuzzer::Rvalue* f_branch) {
6014
0
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
6015
0
  if (message_arena == nullptr) {
6016
0
    delete _impl_.f_branch_;
6017
0
  }
6018
0
  if (f_branch) {
6019
0
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
6020
0
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(f_branch);
6021
0
    if (message_arena != submessage_arena) {
6022
0
      f_branch = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
6023
0
          message_arena, f_branch, submessage_arena);
6024
0
    }
6025
0
    _impl_._has_bits_[0] |= 0x00000004u;
6026
0
  } else {
6027
0
    _impl_._has_bits_[0] &= ~0x00000004u;
6028
0
  }
6029
0
  _impl_.f_branch_ = f_branch;
6030
0
  // @@protoc_insertion_point(field_set_allocated:ruby_fuzzer.Ternary.f_branch)
6031
0
}
6032
6033
// -------------------------------------------------------------------
6034
6035
// ObjectSpace
6036
6037
// required .ruby_fuzzer.ObjectSpace.OS_methods os_func = 1;
6038
0
inline bool ObjectSpace::has_os_func() const {
6039
0
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
6040
0
  return value;
6041
0
}
6042
0
inline void ObjectSpace::clear_os_func() {
6043
0
  _impl_.os_func_ = 1;
6044
0
  _impl_._has_bits_[0] &= ~0x00000002u;
6045
0
}
6046
20.6k
inline ::ruby_fuzzer::ObjectSpace_OS_methods ObjectSpace::os_func() const {
6047
  // @@protoc_insertion_point(field_get:ruby_fuzzer.ObjectSpace.os_func)
6048
20.6k
  return _internal_os_func();
6049
20.6k
}
6050
0
inline void ObjectSpace::set_os_func(::ruby_fuzzer::ObjectSpace_OS_methods value) {
6051
0
   _internal_set_os_func(value);
6052
0
  // @@protoc_insertion_point(field_set:ruby_fuzzer.ObjectSpace.os_func)
6053
0
}
6054
20.6k
inline ::ruby_fuzzer::ObjectSpace_OS_methods ObjectSpace::_internal_os_func() const {
6055
20.6k
  return static_cast<::ruby_fuzzer::ObjectSpace_OS_methods>(_impl_.os_func_);
6056
20.6k
}
6057
0
inline void ObjectSpace::_internal_set_os_func(::ruby_fuzzer::ObjectSpace_OS_methods value) {
6058
0
  assert(::ruby_fuzzer::ObjectSpace_OS_methods_IsValid(value));
6059
0
  _impl_._has_bits_[0] |= 0x00000002u;
6060
0
  _impl_.os_func_ = value;
6061
0
}
6062
6063
// required .ruby_fuzzer.HashType os_arg = 2;
6064
0
inline bool ObjectSpace::has_os_arg() const {
6065
0
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
6066
0
  PROTOBUF_ASSUME(!value || _impl_.os_arg_ != nullptr);
6067
0
  return value;
6068
0
}
6069
0
inline void ObjectSpace::clear_os_arg() {
6070
0
  if (_impl_.os_arg_ != nullptr) _impl_.os_arg_->Clear();
6071
0
  _impl_._has_bits_[0] &= ~0x00000001u;
6072
0
}
6073
20.6k
inline const ::ruby_fuzzer::HashType& ObjectSpace::_internal_os_arg() const {
6074
20.6k
  const ::ruby_fuzzer::HashType* p = _impl_.os_arg_;
6075
20.6k
  return p != nullptr ? *p : reinterpret_cast<const ::ruby_fuzzer::HashType&>(
6076
0
      ::ruby_fuzzer::_HashType_default_instance_);
6077
20.6k
}
6078
20.6k
inline const ::ruby_fuzzer::HashType& ObjectSpace::os_arg() const {
6079
  // @@protoc_insertion_point(field_get:ruby_fuzzer.ObjectSpace.os_arg)
6080
20.6k
  return _internal_os_arg();
6081
20.6k
}
6082
inline void ObjectSpace::unsafe_arena_set_allocated_os_arg(
6083
0
    ::ruby_fuzzer::HashType* os_arg) {
6084
0
  if (GetArenaForAllocation() == nullptr) {
6085
0
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.os_arg_);
6086
0
  }
6087
0
  _impl_.os_arg_ = os_arg;
6088
0
  if (os_arg) {
6089
0
    _impl_._has_bits_[0] |= 0x00000001u;
6090
0
  } else {
6091
0
    _impl_._has_bits_[0] &= ~0x00000001u;
6092
0
  }
6093
0
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ruby_fuzzer.ObjectSpace.os_arg)
6094
0
}
6095
0
inline ::ruby_fuzzer::HashType* ObjectSpace::release_os_arg() {
6096
0
  _impl_._has_bits_[0] &= ~0x00000001u;
6097
0
  ::ruby_fuzzer::HashType* temp = _impl_.os_arg_;
6098
0
  _impl_.os_arg_ = nullptr;
6099
0
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
6100
0
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
6101
0
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
6102
0
  if (GetArenaForAllocation() == nullptr) { delete old; }
6103
0
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
6104
0
  if (GetArenaForAllocation() != nullptr) {
6105
0
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
6106
0
  }
6107
0
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
6108
0
  return temp;
6109
0
}
6110
0
inline ::ruby_fuzzer::HashType* ObjectSpace::unsafe_arena_release_os_arg() {
6111
0
  // @@protoc_insertion_point(field_release:ruby_fuzzer.ObjectSpace.os_arg)
6112
0
  _impl_._has_bits_[0] &= ~0x00000001u;
6113
0
  ::ruby_fuzzer::HashType* temp = _impl_.os_arg_;
6114
0
  _impl_.os_arg_ = nullptr;
6115
0
  return temp;
6116
0
}
6117
0
inline ::ruby_fuzzer::HashType* ObjectSpace::_internal_mutable_os_arg() {
6118
0
  _impl_._has_bits_[0] |= 0x00000001u;
6119
0
  if (_impl_.os_arg_ == nullptr) {
6120
0
    auto* p = CreateMaybeMessage<::ruby_fuzzer::HashType>(GetArenaForAllocation());
6121
0
    _impl_.os_arg_ = p;
6122
0
  }
6123
0
  return _impl_.os_arg_;
6124
0
}
6125
0
inline ::ruby_fuzzer::HashType* ObjectSpace::mutable_os_arg() {
6126
0
  ::ruby_fuzzer::HashType* _msg = _internal_mutable_os_arg();
6127
0
  // @@protoc_insertion_point(field_mutable:ruby_fuzzer.ObjectSpace.os_arg)
6128
0
  return _msg;
6129
0
}
6130
0
inline void ObjectSpace::set_allocated_os_arg(::ruby_fuzzer::HashType* os_arg) {
6131
0
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
6132
0
  if (message_arena == nullptr) {
6133
0
    delete _impl_.os_arg_;
6134
0
  }
6135
0
  if (os_arg) {
6136
0
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
6137
0
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(os_arg);
6138
0
    if (message_arena != submessage_arena) {
6139
0
      os_arg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
6140
0
          message_arena, os_arg, submessage_arena);
6141
0
    }
6142
0
    _impl_._has_bits_[0] |= 0x00000001u;
6143
0
  } else {
6144
0
    _impl_._has_bits_[0] &= ~0x00000001u;
6145
0
  }
6146
0
  _impl_.os_arg_ = os_arg;
6147
0
  // @@protoc_insertion_point(field_set_allocated:ruby_fuzzer.ObjectSpace.os_arg)
6148
0
}
6149
6150
// -------------------------------------------------------------------
6151
6152
// Time
6153
6154
// required .ruby_fuzzer.Time.T_methods t_func = 1;
6155
0
inline bool Time::has_t_func() const {
6156
0
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
6157
0
  return value;
6158
0
}
6159
0
inline void Time::clear_t_func() {
6160
0
  _impl_.t_func_ = 1;
6161
0
  _impl_._has_bits_[0] &= ~0x00000002u;
6162
0
}
6163
10.2k
inline ::ruby_fuzzer::Time_T_methods Time::t_func() const {
6164
  // @@protoc_insertion_point(field_get:ruby_fuzzer.Time.t_func)
6165
10.2k
  return _internal_t_func();
6166
10.2k
}
6167
0
inline void Time::set_t_func(::ruby_fuzzer::Time_T_methods value) {
6168
0
   _internal_set_t_func(value);
6169
0
  // @@protoc_insertion_point(field_set:ruby_fuzzer.Time.t_func)
6170
0
}
6171
10.2k
inline ::ruby_fuzzer::Time_T_methods Time::_internal_t_func() const {
6172
10.2k
  return static_cast<::ruby_fuzzer::Time_T_methods>(_impl_.t_func_);
6173
10.2k
}
6174
0
inline void Time::_internal_set_t_func(::ruby_fuzzer::Time_T_methods value) {
6175
0
  assert(::ruby_fuzzer::Time_T_methods_IsValid(value));
6176
0
  _impl_._has_bits_[0] |= 0x00000002u;
6177
0
  _impl_.t_func_ = value;
6178
0
}
6179
6180
// required uint32 t_arg = 2;
6181
0
inline bool Time::has_t_arg() const {
6182
0
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
6183
0
  return value;
6184
0
}
6185
0
inline void Time::clear_t_arg() {
6186
0
  _impl_.t_arg_ = 0u;
6187
0
  _impl_._has_bits_[0] &= ~0x00000001u;
6188
0
}
6189
10.2k
inline ::uint32_t Time::t_arg() const {
6190
  // @@protoc_insertion_point(field_get:ruby_fuzzer.Time.t_arg)
6191
10.2k
  return _internal_t_arg();
6192
10.2k
}
6193
0
inline void Time::set_t_arg(::uint32_t value) {
6194
0
  _internal_set_t_arg(value);
6195
0
  // @@protoc_insertion_point(field_set:ruby_fuzzer.Time.t_arg)
6196
0
}
6197
10.2k
inline ::uint32_t Time::_internal_t_arg() const {
6198
10.2k
  return _impl_.t_arg_;
6199
10.2k
}
6200
0
inline void Time::_internal_set_t_arg(::uint32_t value) {
6201
0
  _impl_._has_bits_[0] |= 0x00000001u;
6202
0
  _impl_.t_arg_ = value;
6203
0
}
6204
6205
// -------------------------------------------------------------------
6206
6207
// Array
6208
6209
// required .ruby_fuzzer.Array.Arr_methods arr_func = 1;
6210
0
inline bool Array::has_arr_func() const {
6211
0
  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
6212
0
  return value;
6213
0
}
6214
0
inline void Array::clear_arr_func() {
6215
0
  _impl_.arr_func_ = 1;
6216
0
  _impl_._has_bits_[0] &= ~0x00000004u;
6217
0
}
6218
55.7k
inline ::ruby_fuzzer::Array_Arr_methods Array::arr_func() const {
6219
  // @@protoc_insertion_point(field_get:ruby_fuzzer.Array.arr_func)
6220
55.7k
  return _internal_arr_func();
6221
55.7k
}
6222
0
inline void Array::set_arr_func(::ruby_fuzzer::Array_Arr_methods value) {
6223
0
   _internal_set_arr_func(value);
6224
0
  // @@protoc_insertion_point(field_set:ruby_fuzzer.Array.arr_func)
6225
0
}
6226
55.7k
inline ::ruby_fuzzer::Array_Arr_methods Array::_internal_arr_func() const {
6227
55.7k
  return static_cast<::ruby_fuzzer::Array_Arr_methods>(_impl_.arr_func_);
6228
55.7k
}
6229
0
inline void Array::_internal_set_arr_func(::ruby_fuzzer::Array_Arr_methods value) {
6230
0
  assert(::ruby_fuzzer::Array_Arr_methods_IsValid(value));
6231
0
  _impl_._has_bits_[0] |= 0x00000004u;
6232
0
  _impl_.arr_func_ = value;
6233
0
}
6234
6235
// required .ruby_fuzzer.ArrType arr_arg = 2;
6236
0
inline bool Array::has_arr_arg() const {
6237
0
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
6238
0
  PROTOBUF_ASSUME(!value || _impl_.arr_arg_ != nullptr);
6239
0
  return value;
6240
0
}
6241
0
inline void Array::clear_arr_arg() {
6242
0
  if (_impl_.arr_arg_ != nullptr) _impl_.arr_arg_->Clear();
6243
0
  _impl_._has_bits_[0] &= ~0x00000001u;
6244
0
}
6245
55.7k
inline const ::ruby_fuzzer::ArrType& Array::_internal_arr_arg() const {
6246
55.7k
  const ::ruby_fuzzer::ArrType* p = _impl_.arr_arg_;
6247
55.7k
  return p != nullptr ? *p : reinterpret_cast<const ::ruby_fuzzer::ArrType&>(
6248
0
      ::ruby_fuzzer::_ArrType_default_instance_);
6249
55.7k
}
6250
55.7k
inline const ::ruby_fuzzer::ArrType& Array::arr_arg() const {
6251
  // @@protoc_insertion_point(field_get:ruby_fuzzer.Array.arr_arg)
6252
55.7k
  return _internal_arr_arg();
6253
55.7k
}
6254
inline void Array::unsafe_arena_set_allocated_arr_arg(
6255
0
    ::ruby_fuzzer::ArrType* arr_arg) {
6256
0
  if (GetArenaForAllocation() == nullptr) {
6257
0
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.arr_arg_);
6258
0
  }
6259
0
  _impl_.arr_arg_ = arr_arg;
6260
0
  if (arr_arg) {
6261
0
    _impl_._has_bits_[0] |= 0x00000001u;
6262
0
  } else {
6263
0
    _impl_._has_bits_[0] &= ~0x00000001u;
6264
0
  }
6265
0
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ruby_fuzzer.Array.arr_arg)
6266
0
}
6267
0
inline ::ruby_fuzzer::ArrType* Array::release_arr_arg() {
6268
0
  _impl_._has_bits_[0] &= ~0x00000001u;
6269
0
  ::ruby_fuzzer::ArrType* temp = _impl_.arr_arg_;
6270
0
  _impl_.arr_arg_ = nullptr;
6271
0
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
6272
0
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
6273
0
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
6274
0
  if (GetArenaForAllocation() == nullptr) { delete old; }
6275
0
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
6276
0
  if (GetArenaForAllocation() != nullptr) {
6277
0
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
6278
0
  }
6279
0
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
6280
0
  return temp;
6281
0
}
6282
0
inline ::ruby_fuzzer::ArrType* Array::unsafe_arena_release_arr_arg() {
6283
0
  // @@protoc_insertion_point(field_release:ruby_fuzzer.Array.arr_arg)
6284
0
  _impl_._has_bits_[0] &= ~0x00000001u;
6285
0
  ::ruby_fuzzer::ArrType* temp = _impl_.arr_arg_;
6286
0
  _impl_.arr_arg_ = nullptr;
6287
0
  return temp;
6288
0
}
6289
0
inline ::ruby_fuzzer::ArrType* Array::_internal_mutable_arr_arg() {
6290
0
  _impl_._has_bits_[0] |= 0x00000001u;
6291
0
  if (_impl_.arr_arg_ == nullptr) {
6292
0
    auto* p = CreateMaybeMessage<::ruby_fuzzer::ArrType>(GetArenaForAllocation());
6293
0
    _impl_.arr_arg_ = p;
6294
0
  }
6295
0
  return _impl_.arr_arg_;
6296
0
}
6297
0
inline ::ruby_fuzzer::ArrType* Array::mutable_arr_arg() {
6298
0
  ::ruby_fuzzer::ArrType* _msg = _internal_mutable_arr_arg();
6299
0
  // @@protoc_insertion_point(field_mutable:ruby_fuzzer.Array.arr_arg)
6300
0
  return _msg;
6301
0
}
6302
0
inline void Array::set_allocated_arr_arg(::ruby_fuzzer::ArrType* arr_arg) {
6303
0
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
6304
0
  if (message_arena == nullptr) {
6305
0
    delete _impl_.arr_arg_;
6306
0
  }
6307
0
  if (arr_arg) {
6308
0
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
6309
0
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(arr_arg);
6310
0
    if (message_arena != submessage_arena) {
6311
0
      arr_arg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
6312
0
          message_arena, arr_arg, submessage_arena);
6313
0
    }
6314
0
    _impl_._has_bits_[0] |= 0x00000001u;
6315
0
  } else {
6316
0
    _impl_._has_bits_[0] &= ~0x00000001u;
6317
0
  }
6318
0
  _impl_.arr_arg_ = arr_arg;
6319
0
  // @@protoc_insertion_point(field_set_allocated:ruby_fuzzer.Array.arr_arg)
6320
0
}
6321
6322
// required .ruby_fuzzer.Rvalue val_arg = 3;
6323
0
inline bool Array::has_val_arg() const {
6324
0
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
6325
0
  PROTOBUF_ASSUME(!value || _impl_.val_arg_ != nullptr);
6326
0
  return value;
6327
0
}
6328
0
inline void Array::clear_val_arg() {
6329
0
  if (_impl_.val_arg_ != nullptr) _impl_.val_arg_->Clear();
6330
0
  _impl_._has_bits_[0] &= ~0x00000002u;
6331
0
}
6332
55.7k
inline const ::ruby_fuzzer::Rvalue& Array::_internal_val_arg() const {
6333
55.7k
  const ::ruby_fuzzer::Rvalue* p = _impl_.val_arg_;
6334
55.7k
  return p != nullptr ? *p : reinterpret_cast<const ::ruby_fuzzer::Rvalue&>(
6335
0
      ::ruby_fuzzer::_Rvalue_default_instance_);
6336
55.7k
}
6337
55.7k
inline const ::ruby_fuzzer::Rvalue& Array::val_arg() const {
6338
  // @@protoc_insertion_point(field_get:ruby_fuzzer.Array.val_arg)
6339
55.7k
  return _internal_val_arg();
6340
55.7k
}
6341
inline void Array::unsafe_arena_set_allocated_val_arg(
6342
0
    ::ruby_fuzzer::Rvalue* val_arg) {
6343
0
  if (GetArenaForAllocation() == nullptr) {
6344
0
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.val_arg_);
6345
0
  }
6346
0
  _impl_.val_arg_ = val_arg;
6347
0
  if (val_arg) {
6348
0
    _impl_._has_bits_[0] |= 0x00000002u;
6349
0
  } else {
6350
0
    _impl_._has_bits_[0] &= ~0x00000002u;
6351
0
  }
6352
0
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ruby_fuzzer.Array.val_arg)
6353
0
}
6354
0
inline ::ruby_fuzzer::Rvalue* Array::release_val_arg() {
6355
0
  _impl_._has_bits_[0] &= ~0x00000002u;
6356
0
  ::ruby_fuzzer::Rvalue* temp = _impl_.val_arg_;
6357
0
  _impl_.val_arg_ = nullptr;
6358
0
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
6359
0
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
6360
0
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
6361
0
  if (GetArenaForAllocation() == nullptr) { delete old; }
6362
0
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
6363
0
  if (GetArenaForAllocation() != nullptr) {
6364
0
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
6365
0
  }
6366
0
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
6367
0
  return temp;
6368
0
}
6369
0
inline ::ruby_fuzzer::Rvalue* Array::unsafe_arena_release_val_arg() {
6370
0
  // @@protoc_insertion_point(field_release:ruby_fuzzer.Array.val_arg)
6371
0
  _impl_._has_bits_[0] &= ~0x00000002u;
6372
0
  ::ruby_fuzzer::Rvalue* temp = _impl_.val_arg_;
6373
0
  _impl_.val_arg_ = nullptr;
6374
0
  return temp;
6375
0
}
6376
0
inline ::ruby_fuzzer::Rvalue* Array::_internal_mutable_val_arg() {
6377
0
  _impl_._has_bits_[0] |= 0x00000002u;
6378
0
  if (_impl_.val_arg_ == nullptr) {
6379
0
    auto* p = CreateMaybeMessage<::ruby_fuzzer::Rvalue>(GetArenaForAllocation());
6380
0
    _impl_.val_arg_ = p;
6381
0
  }
6382
0
  return _impl_.val_arg_;
6383
0
}
6384
0
inline ::ruby_fuzzer::Rvalue* Array::mutable_val_arg() {
6385
0
  ::ruby_fuzzer::Rvalue* _msg = _internal_mutable_val_arg();
6386
0
  // @@protoc_insertion_point(field_mutable:ruby_fuzzer.Array.val_arg)
6387
0
  return _msg;
6388
0
}
6389
0
inline void Array::set_allocated_val_arg(::ruby_fuzzer::Rvalue* val_arg) {
6390
0
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
6391
0
  if (message_arena == nullptr) {
6392
0
    delete _impl_.val_arg_;
6393
0
  }
6394
0
  if (val_arg) {
6395
0
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
6396
0
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(val_arg);
6397
0
    if (message_arena != submessage_arena) {
6398
0
      val_arg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
6399
0
          message_arena, val_arg, submessage_arena);
6400
0
    }
6401
0
    _impl_._has_bits_[0] |= 0x00000002u;
6402
0
  } else {
6403
0
    _impl_._has_bits_[0] &= ~0x00000002u;
6404
0
  }
6405
0
  _impl_.val_arg_ = val_arg;
6406
0
  // @@protoc_insertion_point(field_set_allocated:ruby_fuzzer.Array.val_arg)
6407
0
}
6408
6409
// -------------------------------------------------------------------
6410
6411
// MathType
6412
6413
// .ruby_fuzzer.Rvalue math_rval = 2;
6414
0
inline bool MathType::has_math_rval() const {
6415
0
  return math_arg_oneof_case() == kMathRval;
6416
0
}
6417
0
inline bool MathType::_internal_has_math_rval() const {
6418
0
  return math_arg_oneof_case() == kMathRval;
6419
0
}
6420
0
inline void MathType::set_has_math_rval() {
6421
0
  _impl_._oneof_case_[0] = kMathRval;
6422
0
}
6423
0
inline void MathType::clear_math_rval() {
6424
0
  if (math_arg_oneof_case() == kMathRval) {
6425
0
    if (GetArenaForAllocation() == nullptr) {
6426
0
      delete _impl_.math_arg_oneof_.math_rval_;
6427
0
    }
6428
0
    clear_has_math_arg_oneof();
6429
0
  }
6430
0
}
6431
0
inline ::ruby_fuzzer::Rvalue* MathType::release_math_rval() {
6432
0
  // @@protoc_insertion_point(field_release:ruby_fuzzer.MathType.math_rval)
6433
0
  if (math_arg_oneof_case() == kMathRval) {
6434
0
    clear_has_math_arg_oneof();
6435
0
    ::ruby_fuzzer::Rvalue* temp = _impl_.math_arg_oneof_.math_rval_;
6436
0
    if (GetArenaForAllocation() != nullptr) {
6437
0
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
6438
0
    }
6439
0
    _impl_.math_arg_oneof_.math_rval_ = nullptr;
6440
0
    return temp;
6441
0
  } else {
6442
0
    return nullptr;
6443
0
  }
6444
0
}
6445
1.32k
inline const ::ruby_fuzzer::Rvalue& MathType::_internal_math_rval() const {
6446
1.32k
  return math_arg_oneof_case() == kMathRval
6447
1.32k
      ? *_impl_.math_arg_oneof_.math_rval_
6448
1.32k
      : reinterpret_cast< ::ruby_fuzzer::Rvalue&>(::ruby_fuzzer::_Rvalue_default_instance_);
6449
1.32k
}
6450
1.32k
inline const ::ruby_fuzzer::Rvalue& MathType::math_rval() const {
6451
  // @@protoc_insertion_point(field_get:ruby_fuzzer.MathType.math_rval)
6452
1.32k
  return _internal_math_rval();
6453
1.32k
}
6454
0
inline ::ruby_fuzzer::Rvalue* MathType::unsafe_arena_release_math_rval() {
6455
0
  // @@protoc_insertion_point(field_unsafe_arena_release:ruby_fuzzer.MathType.math_rval)
6456
0
  if (math_arg_oneof_case() == kMathRval) {
6457
0
    clear_has_math_arg_oneof();
6458
0
    ::ruby_fuzzer::Rvalue* temp = _impl_.math_arg_oneof_.math_rval_;
6459
0
    _impl_.math_arg_oneof_.math_rval_ = nullptr;
6460
0
    return temp;
6461
0
  } else {
6462
0
    return nullptr;
6463
0
  }
6464
0
}
6465
0
inline void MathType::unsafe_arena_set_allocated_math_rval(::ruby_fuzzer::Rvalue* math_rval) {
6466
0
  clear_math_arg_oneof();
6467
0
  if (math_rval) {
6468
0
    set_has_math_rval();
6469
0
    _impl_.math_arg_oneof_.math_rval_ = math_rval;
6470
0
  }
6471
0
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ruby_fuzzer.MathType.math_rval)
6472
0
}
6473
0
inline ::ruby_fuzzer::Rvalue* MathType::_internal_mutable_math_rval() {
6474
0
  if (math_arg_oneof_case() != kMathRval) {
6475
0
    clear_math_arg_oneof();
6476
0
    set_has_math_rval();
6477
0
    _impl_.math_arg_oneof_.math_rval_ = CreateMaybeMessage< ::ruby_fuzzer::Rvalue >(GetArenaForAllocation());
6478
0
  }
6479
0
  return _impl_.math_arg_oneof_.math_rval_;
6480
0
}
6481
0
inline ::ruby_fuzzer::Rvalue* MathType::mutable_math_rval() {
6482
0
  ::ruby_fuzzer::Rvalue* _msg = _internal_mutable_math_rval();
6483
0
  // @@protoc_insertion_point(field_mutable:ruby_fuzzer.MathType.math_rval)
6484
0
  return _msg;
6485
0
}
6486
6487
// .ruby_fuzzer.MathConst math_const = 3;
6488
0
inline bool MathType::has_math_const() const {
6489
0
  return math_arg_oneof_case() == kMathConst;
6490
0
}
6491
0
inline bool MathType::_internal_has_math_const() const {
6492
0
  return math_arg_oneof_case() == kMathConst;
6493
0
}
6494
0
inline void MathType::set_has_math_const() {
6495
0
  _impl_._oneof_case_[0] = kMathConst;
6496
0
}
6497
0
inline void MathType::clear_math_const() {
6498
0
  if (math_arg_oneof_case() == kMathConst) {
6499
0
    if (GetArenaForAllocation() == nullptr) {
6500
0
      delete _impl_.math_arg_oneof_.math_const_;
6501
0
    }
6502
0
    clear_has_math_arg_oneof();
6503
0
  }
6504
0
}
6505
0
inline ::ruby_fuzzer::MathConst* MathType::release_math_const() {
6506
0
  // @@protoc_insertion_point(field_release:ruby_fuzzer.MathType.math_const)
6507
0
  if (math_arg_oneof_case() == kMathConst) {
6508
0
    clear_has_math_arg_oneof();
6509
0
    ::ruby_fuzzer::MathConst* temp = _impl_.math_arg_oneof_.math_const_;
6510
0
    if (GetArenaForAllocation() != nullptr) {
6511
0
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
6512
0
    }
6513
0
    _impl_.math_arg_oneof_.math_const_ = nullptr;
6514
0
    return temp;
6515
0
  } else {
6516
0
    return nullptr;
6517
0
  }
6518
0
}
6519
3.08k
inline const ::ruby_fuzzer::MathConst& MathType::_internal_math_const() const {
6520
3.08k
  return math_arg_oneof_case() == kMathConst
6521
3.08k
      ? *_impl_.math_arg_oneof_.math_const_
6522
3.08k
      : reinterpret_cast< ::ruby_fuzzer::MathConst&>(::ruby_fuzzer::_MathConst_default_instance_);
6523
3.08k
}
6524
3.08k
inline const ::ruby_fuzzer::MathConst& MathType::math_const() const {
6525
  // @@protoc_insertion_point(field_get:ruby_fuzzer.MathType.math_const)
6526
3.08k
  return _internal_math_const();
6527
3.08k
}
6528
0
inline ::ruby_fuzzer::MathConst* MathType::unsafe_arena_release_math_const() {
6529
0
  // @@protoc_insertion_point(field_unsafe_arena_release:ruby_fuzzer.MathType.math_const)
6530
0
  if (math_arg_oneof_case() == kMathConst) {
6531
0
    clear_has_math_arg_oneof();
6532
0
    ::ruby_fuzzer::MathConst* temp = _impl_.math_arg_oneof_.math_const_;
6533
0
    _impl_.math_arg_oneof_.math_const_ = nullptr;
6534
0
    return temp;
6535
0
  } else {
6536
0
    return nullptr;
6537
0
  }
6538
0
}
6539
0
inline void MathType::unsafe_arena_set_allocated_math_const(::ruby_fuzzer::MathConst* math_const) {
6540
0
  clear_math_arg_oneof();
6541
0
  if (math_const) {
6542
0
    set_has_math_const();
6543
0
    _impl_.math_arg_oneof_.math_const_ = math_const;
6544
0
  }
6545
0
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ruby_fuzzer.MathType.math_const)
6546
0
}
6547
0
inline ::ruby_fuzzer::MathConst* MathType::_internal_mutable_math_const() {
6548
0
  if (math_arg_oneof_case() != kMathConst) {
6549
0
    clear_math_arg_oneof();
6550
0
    set_has_math_const();
6551
0
    _impl_.math_arg_oneof_.math_const_ = CreateMaybeMessage< ::ruby_fuzzer::MathConst >(GetArenaForAllocation());
6552
0
  }
6553
0
  return _impl_.math_arg_oneof_.math_const_;
6554
0
}
6555
0
inline ::ruby_fuzzer::MathConst* MathType::mutable_math_const() {
6556
0
  ::ruby_fuzzer::MathConst* _msg = _internal_mutable_math_const();
6557
0
  // @@protoc_insertion_point(field_mutable:ruby_fuzzer.MathType.math_const)
6558
0
  return _msg;
6559
0
}
6560
6561
9.45k
inline bool MathType::has_math_arg_oneof() const {
6562
9.45k
  return math_arg_oneof_case() != MATH_ARG_ONEOF_NOT_SET;
6563
9.45k
}
6564
9.45k
inline void MathType::clear_has_math_arg_oneof() {
6565
9.45k
  _impl_._oneof_case_[0] = MATH_ARG_ONEOF_NOT_SET;
6566
9.45k
}
6567
27.8k
inline MathType::MathArgOneofCase MathType::math_arg_oneof_case() const {
6568
27.8k
  return MathType::MathArgOneofCase(_impl_._oneof_case_[0]);
6569
27.8k
}
6570
// -------------------------------------------------------------------
6571
6572
// MathOps
6573
6574
// required .ruby_fuzzer.MathOps.Mops math_op = 1;
6575
0
inline bool MathOps::has_math_op() const {
6576
0
  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
6577
0
  return value;
6578
0
}
6579
0
inline void MathOps::clear_math_op() {
6580
0
  _impl_.math_op_ = 1;
6581
0
  _impl_._has_bits_[0] &= ~0x00000002u;
6582
0
}
6583
9.19k
inline ::ruby_fuzzer::MathOps_Mops MathOps::math_op() const {
6584
  // @@protoc_insertion_point(field_get:ruby_fuzzer.MathOps.math_op)
6585
9.19k
  return _internal_math_op();
6586
9.19k
}
6587
0
inline void MathOps::set_math_op(::ruby_fuzzer::MathOps_Mops value) {
6588
0
   _internal_set_math_op(value);
6589
0
  // @@protoc_insertion_point(field_set:ruby_fuzzer.MathOps.math_op)
6590
0
}
6591
9.19k
inline ::ruby_fuzzer::MathOps_Mops MathOps::_internal_math_op() const {
6592
9.19k
  return static_cast<::ruby_fuzzer::MathOps_Mops>(_impl_.math_op_);
6593
9.19k
}
6594
0
inline void MathOps::_internal_set_math_op(::ruby_fuzzer::MathOps_Mops value) {
6595
0
  assert(::ruby_fuzzer::MathOps_Mops_IsValid(value));
6596
0
  _impl_._has_bits_[0] |= 0x00000002u;
6597
0
  _impl_.math_op_ = value;
6598
0
}
6599
6600
// required .ruby_fuzzer.MathType math_arg = 2;
6601
0
inline bool MathOps::has_math_arg() const {
6602
0
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
6603
0
  PROTOBUF_ASSUME(!value || _impl_.math_arg_ != nullptr);
6604
0
  return value;
6605
0
}
6606
0
inline void MathOps::clear_math_arg() {
6607
0
  if (_impl_.math_arg_ != nullptr) _impl_.math_arg_->Clear();
6608
0
  _impl_._has_bits_[0] &= ~0x00000001u;
6609
0
}
6610
9.19k
inline const ::ruby_fuzzer::MathType& MathOps::_internal_math_arg() const {
6611
9.19k
  const ::ruby_fuzzer::MathType* p = _impl_.math_arg_;
6612
9.19k
  return p != nullptr ? *p : reinterpret_cast<const ::ruby_fuzzer::MathType&>(
6613
0
      ::ruby_fuzzer::_MathType_default_instance_);
6614
9.19k
}
6615
9.19k
inline const ::ruby_fuzzer::MathType& MathOps::math_arg() const {
6616
  // @@protoc_insertion_point(field_get:ruby_fuzzer.MathOps.math_arg)
6617
9.19k
  return _internal_math_arg();
6618
9.19k
}
6619
inline void MathOps::unsafe_arena_set_allocated_math_arg(
6620
0
    ::ruby_fuzzer::MathType* math_arg) {
6621
0
  if (GetArenaForAllocation() == nullptr) {
6622
0
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.math_arg_);
6623
0
  }
6624
0
  _impl_.math_arg_ = math_arg;
6625
0
  if (math_arg) {
6626
0
    _impl_._has_bits_[0] |= 0x00000001u;
6627
0
  } else {
6628
0
    _impl_._has_bits_[0] &= ~0x00000001u;
6629
0
  }
6630
0
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ruby_fuzzer.MathOps.math_arg)
6631
0
}
6632
0
inline ::ruby_fuzzer::MathType* MathOps::release_math_arg() {
6633
0
  _impl_._has_bits_[0] &= ~0x00000001u;
6634
0
  ::ruby_fuzzer::MathType* temp = _impl_.math_arg_;
6635
0
  _impl_.math_arg_ = nullptr;
6636
0
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
6637
0
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
6638
0
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
6639
0
  if (GetArenaForAllocation() == nullptr) { delete old; }
6640
0
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
6641
0
  if (GetArenaForAllocation() != nullptr) {
6642
0
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
6643
0
  }
6644
0
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
6645
0
  return temp;
6646
0
}
6647
0
inline ::ruby_fuzzer::MathType* MathOps::unsafe_arena_release_math_arg() {
6648
0
  // @@protoc_insertion_point(field_release:ruby_fuzzer.MathOps.math_arg)
6649
0
  _impl_._has_bits_[0] &= ~0x00000001u;
6650
0
  ::ruby_fuzzer::MathType* temp = _impl_.math_arg_;
6651
0
  _impl_.math_arg_ = nullptr;
6652
0
  return temp;
6653
0
}
6654
0
inline ::ruby_fuzzer::MathType* MathOps::_internal_mutable_math_arg() {
6655
0
  _impl_._has_bits_[0] |= 0x00000001u;
6656
0
  if (_impl_.math_arg_ == nullptr) {
6657
0
    auto* p = CreateMaybeMessage<::ruby_fuzzer::MathType>(GetArenaForAllocation());
6658
0
    _impl_.math_arg_ = p;
6659
0
  }
6660
0
  return _impl_.math_arg_;
6661
0
}
6662
0
inline ::ruby_fuzzer::MathType* MathOps::mutable_math_arg() {
6663
0
  ::ruby_fuzzer::MathType* _msg = _internal_mutable_math_arg();
6664
0
  // @@protoc_insertion_point(field_mutable:ruby_fuzzer.MathOps.math_arg)
6665
0
  return _msg;
6666
0
}
6667
0
inline void MathOps::set_allocated_math_arg(::ruby_fuzzer::MathType* math_arg) {
6668
0
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
6669
0
  if (message_arena == nullptr) {
6670
0
    delete _impl_.math_arg_;
6671
0
  }
6672
0
  if (math_arg) {
6673
0
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
6674
0
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(math_arg);
6675
0
    if (message_arena != submessage_arena) {
6676
0
      math_arg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
6677
0
          message_arena, math_arg, submessage_arena);
6678
0
    }
6679
0
    _impl_._has_bits_[0] |= 0x00000001u;
6680
0
  } else {
6681
0
    _impl_._has_bits_[0] &= ~0x00000001u;
6682
0
  }
6683
0
  _impl_.math_arg_ = math_arg;
6684
0
  // @@protoc_insertion_point(field_set_allocated:ruby_fuzzer.MathOps.math_arg)
6685
0
}
6686
6687
// -------------------------------------------------------------------
6688
6689
// BuiltinFuncs
6690
6691
// .ruby_fuzzer.ObjectSpace os = 1;
6692
0
inline bool BuiltinFuncs::has_os() const {
6693
0
  return bifunc_oneof_case() == kOs;
6694
0
}
6695
0
inline bool BuiltinFuncs::_internal_has_os() const {
6696
0
  return bifunc_oneof_case() == kOs;
6697
0
}
6698
0
inline void BuiltinFuncs::set_has_os() {
6699
0
  _impl_._oneof_case_[0] = kOs;
6700
0
}
6701
0
inline void BuiltinFuncs::clear_os() {
6702
0
  if (bifunc_oneof_case() == kOs) {
6703
0
    if (GetArenaForAllocation() == nullptr) {
6704
0
      delete _impl_.bifunc_oneof_.os_;
6705
0
    }
6706
0
    clear_has_bifunc_oneof();
6707
0
  }
6708
0
}
6709
0
inline ::ruby_fuzzer::ObjectSpace* BuiltinFuncs::release_os() {
6710
0
  // @@protoc_insertion_point(field_release:ruby_fuzzer.BuiltinFuncs.os)
6711
0
  if (bifunc_oneof_case() == kOs) {
6712
0
    clear_has_bifunc_oneof();
6713
0
    ::ruby_fuzzer::ObjectSpace* temp = _impl_.bifunc_oneof_.os_;
6714
0
    if (GetArenaForAllocation() != nullptr) {
6715
0
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
6716
0
    }
6717
0
    _impl_.bifunc_oneof_.os_ = nullptr;
6718
0
    return temp;
6719
0
  } else {
6720
0
    return nullptr;
6721
0
  }
6722
0
}
6723
20.6k
inline const ::ruby_fuzzer::ObjectSpace& BuiltinFuncs::_internal_os() const {
6724
20.6k
  return bifunc_oneof_case() == kOs
6725
20.6k
      ? *_impl_.bifunc_oneof_.os_
6726
20.6k
      : reinterpret_cast< ::ruby_fuzzer::ObjectSpace&>(::ruby_fuzzer::_ObjectSpace_default_instance_);
6727
20.6k
}
6728
20.6k
inline const ::ruby_fuzzer::ObjectSpace& BuiltinFuncs::os() const {
6729
  // @@protoc_insertion_point(field_get:ruby_fuzzer.BuiltinFuncs.os)
6730
20.6k
  return _internal_os();
6731
20.6k
}
6732
0
inline ::ruby_fuzzer::ObjectSpace* BuiltinFuncs::unsafe_arena_release_os() {
6733
0
  // @@protoc_insertion_point(field_unsafe_arena_release:ruby_fuzzer.BuiltinFuncs.os)
6734
0
  if (bifunc_oneof_case() == kOs) {
6735
0
    clear_has_bifunc_oneof();
6736
0
    ::ruby_fuzzer::ObjectSpace* temp = _impl_.bifunc_oneof_.os_;
6737
0
    _impl_.bifunc_oneof_.os_ = nullptr;
6738
0
    return temp;
6739
0
  } else {
6740
0
    return nullptr;
6741
0
  }
6742
0
}
6743
0
inline void BuiltinFuncs::unsafe_arena_set_allocated_os(::ruby_fuzzer::ObjectSpace* os) {
6744
0
  clear_bifunc_oneof();
6745
0
  if (os) {
6746
0
    set_has_os();
6747
0
    _impl_.bifunc_oneof_.os_ = os;
6748
0
  }
6749
0
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ruby_fuzzer.BuiltinFuncs.os)
6750
0
}
6751
0
inline ::ruby_fuzzer::ObjectSpace* BuiltinFuncs::_internal_mutable_os() {
6752
0
  if (bifunc_oneof_case() != kOs) {
6753
0
    clear_bifunc_oneof();
6754
0
    set_has_os();
6755
0
    _impl_.bifunc_oneof_.os_ = CreateMaybeMessage< ::ruby_fuzzer::ObjectSpace >(GetArenaForAllocation());
6756
0
  }
6757
0
  return _impl_.bifunc_oneof_.os_;
6758
0
}
6759
0
inline ::ruby_fuzzer::ObjectSpace* BuiltinFuncs::mutable_os() {
6760
0
  ::ruby_fuzzer::ObjectSpace* _msg = _internal_mutable_os();
6761
0
  // @@protoc_insertion_point(field_mutable:ruby_fuzzer.BuiltinFuncs.os)
6762
0
  return _msg;
6763
0
}
6764
6765
// .ruby_fuzzer.Time time = 2;
6766
0
inline bool BuiltinFuncs::has_time() const {
6767
0
  return bifunc_oneof_case() == kTime;
6768
0
}
6769
0
inline bool BuiltinFuncs::_internal_has_time() const {
6770
0
  return bifunc_oneof_case() == kTime;
6771
0
}
6772
0
inline void BuiltinFuncs::set_has_time() {
6773
0
  _impl_._oneof_case_[0] = kTime;
6774
0
}
6775
0
inline void BuiltinFuncs::clear_time() {
6776
0
  if (bifunc_oneof_case() == kTime) {
6777
0
    if (GetArenaForAllocation() == nullptr) {
6778
0
      delete _impl_.bifunc_oneof_.time_;
6779
0
    }
6780
0
    clear_has_bifunc_oneof();
6781
0
  }
6782
0
}
6783
0
inline ::ruby_fuzzer::Time* BuiltinFuncs::release_time() {
6784
0
  // @@protoc_insertion_point(field_release:ruby_fuzzer.BuiltinFuncs.time)
6785
0
  if (bifunc_oneof_case() == kTime) {
6786
0
    clear_has_bifunc_oneof();
6787
0
    ::ruby_fuzzer::Time* temp = _impl_.bifunc_oneof_.time_;
6788
0
    if (GetArenaForAllocation() != nullptr) {
6789
0
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
6790
0
    }
6791
0
    _impl_.bifunc_oneof_.time_ = nullptr;
6792
0
    return temp;
6793
0
  } else {
6794
0
    return nullptr;
6795
0
  }
6796
0
}
6797
10.2k
inline const ::ruby_fuzzer::Time& BuiltinFuncs::_internal_time() const {
6798
10.2k
  return bifunc_oneof_case() == kTime
6799
10.2k
      ? *_impl_.bifunc_oneof_.time_
6800
10.2k
      : reinterpret_cast< ::ruby_fuzzer::Time&>(::ruby_fuzzer::_Time_default_instance_);
6801
10.2k
}
6802
10.2k
inline const ::ruby_fuzzer::Time& BuiltinFuncs::time() const {
6803
  // @@protoc_insertion_point(field_get:ruby_fuzzer.BuiltinFuncs.time)
6804
10.2k
  return _internal_time();
6805
10.2k
}
6806
0
inline ::ruby_fuzzer::Time* BuiltinFuncs::unsafe_arena_release_time() {
6807
0
  // @@protoc_insertion_point(field_unsafe_arena_release:ruby_fuzzer.BuiltinFuncs.time)
6808
0
  if (bifunc_oneof_case() == kTime) {
6809
0
    clear_has_bifunc_oneof();
6810
0
    ::ruby_fuzzer::Time* temp = _impl_.bifunc_oneof_.time_;
6811
0
    _impl_.bifunc_oneof_.time_ = nullptr;
6812
0
    return temp;
6813
0
  } else {
6814
0
    return nullptr;
6815
0
  }
6816
0
}
6817
0
inline void BuiltinFuncs::unsafe_arena_set_allocated_time(::ruby_fuzzer::Time* time) {
6818
0
  clear_bifunc_oneof();
6819
0
  if (time) {
6820
0
    set_has_time();
6821
0
    _impl_.bifunc_oneof_.time_ = time;
6822
0
  }
6823
0
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ruby_fuzzer.BuiltinFuncs.time)
6824
0
}
6825
0
inline ::ruby_fuzzer::Time* BuiltinFuncs::_internal_mutable_time() {
6826
0
  if (bifunc_oneof_case() != kTime) {
6827
0
    clear_bifunc_oneof();
6828
0
    set_has_time();
6829
0
    _impl_.bifunc_oneof_.time_ = CreateMaybeMessage< ::ruby_fuzzer::Time >(GetArenaForAllocation());
6830
0
  }
6831
0
  return _impl_.bifunc_oneof_.time_;
6832
0
}
6833
0
inline ::ruby_fuzzer::Time* BuiltinFuncs::mutable_time() {
6834
0
  ::ruby_fuzzer::Time* _msg = _internal_mutable_time();
6835
0
  // @@protoc_insertion_point(field_mutable:ruby_fuzzer.BuiltinFuncs.time)
6836
0
  return _msg;
6837
0
}
6838
6839
// .ruby_fuzzer.Array arr = 3;
6840
0
inline bool BuiltinFuncs::has_arr() const {
6841
0
  return bifunc_oneof_case() == kArr;
6842
0
}
6843
0
inline bool BuiltinFuncs::_internal_has_arr() const {
6844
0
  return bifunc_oneof_case() == kArr;
6845
0
}
6846
0
inline void BuiltinFuncs::set_has_arr() {
6847
0
  _impl_._oneof_case_[0] = kArr;
6848
0
}
6849
0
inline void BuiltinFuncs::clear_arr() {
6850
0
  if (bifunc_oneof_case() == kArr) {
6851
0
    if (GetArenaForAllocation() == nullptr) {
6852
0
      delete _impl_.bifunc_oneof_.arr_;
6853
0
    }
6854
0
    clear_has_bifunc_oneof();
6855
0
  }
6856
0
}
6857
0
inline ::ruby_fuzzer::Array* BuiltinFuncs::release_arr() {
6858
0
  // @@protoc_insertion_point(field_release:ruby_fuzzer.BuiltinFuncs.arr)
6859
0
  if (bifunc_oneof_case() == kArr) {
6860
0
    clear_has_bifunc_oneof();
6861
0
    ::ruby_fuzzer::Array* temp = _impl_.bifunc_oneof_.arr_;
6862
0
    if (GetArenaForAllocation() != nullptr) {
6863
0
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
6864
0
    }
6865
0
    _impl_.bifunc_oneof_.arr_ = nullptr;
6866
0
    return temp;
6867
0
  } else {
6868
0
    return nullptr;
6869
0
  }
6870
0
}
6871
55.7k
inline const ::ruby_fuzzer::Array& BuiltinFuncs::_internal_arr() const {
6872
55.7k
  return bifunc_oneof_case() == kArr
6873
55.7k
      ? *_impl_.bifunc_oneof_.arr_
6874
55.7k
      : reinterpret_cast< ::ruby_fuzzer::Array&>(::ruby_fuzzer::_Array_default_instance_);
6875
55.7k
}
6876
55.7k
inline const ::ruby_fuzzer::Array& BuiltinFuncs::arr() const {
6877
  // @@protoc_insertion_point(field_get:ruby_fuzzer.BuiltinFuncs.arr)
6878
55.7k
  return _internal_arr();
6879
55.7k
}
6880
0
inline ::ruby_fuzzer::Array* BuiltinFuncs::unsafe_arena_release_arr() {
6881
0
  // @@protoc_insertion_point(field_unsafe_arena_release:ruby_fuzzer.BuiltinFuncs.arr)
6882
0
  if (bifunc_oneof_case() == kArr) {
6883
0
    clear_has_bifunc_oneof();
6884
0
    ::ruby_fuzzer::Array* temp = _impl_.bifunc_oneof_.arr_;
6885
0
    _impl_.bifunc_oneof_.arr_ = nullptr;
6886
0
    return temp;
6887
0
  } else {
6888
0
    return nullptr;
6889
0
  }
6890
0
}
6891
0
inline void BuiltinFuncs::unsafe_arena_set_allocated_arr(::ruby_fuzzer::Array* arr) {
6892
0
  clear_bifunc_oneof();
6893
0
  if (arr) {
6894
0
    set_has_arr();
6895
0
    _impl_.bifunc_oneof_.arr_ = arr;
6896
0
  }
6897
0
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ruby_fuzzer.BuiltinFuncs.arr)
6898
0
}
6899
0
inline ::ruby_fuzzer::Array* BuiltinFuncs::_internal_mutable_arr() {
6900
0
  if (bifunc_oneof_case() != kArr) {
6901
0
    clear_bifunc_oneof();
6902
0
    set_has_arr();
6903
0
    _impl_.bifunc_oneof_.arr_ = CreateMaybeMessage< ::ruby_fuzzer::Array >(GetArenaForAllocation());
6904
0
  }
6905
0
  return _impl_.bifunc_oneof_.arr_;
6906
0
}
6907
0
inline ::ruby_fuzzer::Array* BuiltinFuncs::mutable_arr() {
6908
0
  ::ruby_fuzzer::Array* _msg = _internal_mutable_arr();
6909
0
  // @@protoc_insertion_point(field_mutable:ruby_fuzzer.BuiltinFuncs.arr)
6910
0
  return _msg;
6911
0
}
6912
6913
// .ruby_fuzzer.MathOps mops = 4;
6914
0
inline bool BuiltinFuncs::has_mops() const {
6915
0
  return bifunc_oneof_case() == kMops;
6916
0
}
6917
0
inline bool BuiltinFuncs::_internal_has_mops() const {
6918
0
  return bifunc_oneof_case() == kMops;
6919
0
}
6920
0
inline void BuiltinFuncs::set_has_mops() {
6921
0
  _impl_._oneof_case_[0] = kMops;
6922
0
}
6923
0
inline void BuiltinFuncs::clear_mops() {
6924
0
  if (bifunc_oneof_case() == kMops) {
6925
0
    if (GetArenaForAllocation() == nullptr) {
6926
0
      delete _impl_.bifunc_oneof_.mops_;
6927
0
    }
6928
0
    clear_has_bifunc_oneof();
6929
0
  }
6930
0
}
6931
0
inline ::ruby_fuzzer::MathOps* BuiltinFuncs::release_mops() {
6932
0
  // @@protoc_insertion_point(field_release:ruby_fuzzer.BuiltinFuncs.mops)
6933
0
  if (bifunc_oneof_case() == kMops) {
6934
0
    clear_has_bifunc_oneof();
6935
0
    ::ruby_fuzzer::MathOps* temp = _impl_.bifunc_oneof_.mops_;
6936
0
    if (GetArenaForAllocation() != nullptr) {
6937
0
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
6938
0
    }
6939
0
    _impl_.bifunc_oneof_.mops_ = nullptr;
6940
0
    return temp;
6941
0
  } else {
6942
0
    return nullptr;
6943
0
  }
6944
0
}
6945
9.19k
inline const ::ruby_fuzzer::MathOps& BuiltinFuncs::_internal_mops() const {
6946
9.19k
  return bifunc_oneof_case() == kMops
6947
9.19k
      ? *_impl_.bifunc_oneof_.mops_
6948
9.19k
      : reinterpret_cast< ::ruby_fuzzer::MathOps&>(::ruby_fuzzer::_MathOps_default_instance_);
6949
9.19k
}
6950
9.19k
inline const ::ruby_fuzzer::MathOps& BuiltinFuncs::mops() const {
6951
  // @@protoc_insertion_point(field_get:ruby_fuzzer.BuiltinFuncs.mops)
6952
9.19k
  return _internal_mops();
6953
9.19k
}
6954
0
inline ::ruby_fuzzer::MathOps* BuiltinFuncs::unsafe_arena_release_mops() {
6955
0
  // @@protoc_insertion_point(field_unsafe_arena_release:ruby_fuzzer.BuiltinFuncs.mops)
6956
0
  if (bifunc_oneof_case() == kMops) {
6957
0
    clear_has_bifunc_oneof();
6958
0
    ::ruby_fuzzer::MathOps* temp = _impl_.bifunc_oneof_.mops_;
6959
0
    _impl_.bifunc_oneof_.mops_ = nullptr;
6960
0
    return temp;
6961
0
  } else {
6962
0
    return nullptr;
6963
0
  }
6964
0
}
6965
0
inline void BuiltinFuncs::unsafe_arena_set_allocated_mops(::ruby_fuzzer::MathOps* mops) {
6966
0
  clear_bifunc_oneof();
6967
0
  if (mops) {
6968
0
    set_has_mops();
6969
0
    _impl_.bifunc_oneof_.mops_ = mops;
6970
0
  }
6971
0
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ruby_fuzzer.BuiltinFuncs.mops)
6972
0
}
6973
0
inline ::ruby_fuzzer::MathOps* BuiltinFuncs::_internal_mutable_mops() {
6974
0
  if (bifunc_oneof_case() != kMops) {
6975
0
    clear_bifunc_oneof();
6976
0
    set_has_mops();
6977
0
    _impl_.bifunc_oneof_.mops_ = CreateMaybeMessage< ::ruby_fuzzer::MathOps >(GetArenaForAllocation());
6978
0
  }
6979
0
  return _impl_.bifunc_oneof_.mops_;
6980
0
}
6981
0
inline ::ruby_fuzzer::MathOps* BuiltinFuncs::mutable_mops() {
6982
0
  ::ruby_fuzzer::MathOps* _msg = _internal_mutable_mops();
6983
0
  // @@protoc_insertion_point(field_mutable:ruby_fuzzer.BuiltinFuncs.mops)
6984
0
  return _msg;
6985
0
}
6986
6987
119k
inline bool BuiltinFuncs::has_bifunc_oneof() const {
6988
119k
  return bifunc_oneof_case() != BIFUNC_ONEOF_NOT_SET;
6989
119k
}
6990
119k
inline void BuiltinFuncs::clear_has_bifunc_oneof() {
6991
119k
  _impl_._oneof_case_[0] = BIFUNC_ONEOF_NOT_SET;
6992
119k
}
6993
431k
inline BuiltinFuncs::BifuncOneofCase BuiltinFuncs::bifunc_oneof_case() const {
6994
431k
  return BuiltinFuncs::BifuncOneofCase(_impl_._oneof_case_[0]);
6995
431k
}
6996
// -------------------------------------------------------------------
6997
6998
// Statement
6999
7000
// .ruby_fuzzer.AssignmentStatement assignment = 1;
7001
0
inline bool Statement::has_assignment() const {
7002
0
  return stmt_oneof_case() == kAssignment;
7003
0
}
7004
0
inline bool Statement::_internal_has_assignment() const {
7005
0
  return stmt_oneof_case() == kAssignment;
7006
0
}
7007
0
inline void Statement::set_has_assignment() {
7008
0
  _impl_._oneof_case_[0] = kAssignment;
7009
0
}
7010
0
inline void Statement::clear_assignment() {
7011
0
  if (stmt_oneof_case() == kAssignment) {
7012
0
    if (GetArenaForAllocation() == nullptr) {
7013
0
      delete _impl_.stmt_oneof_.assignment_;
7014
0
    }
7015
0
    clear_has_stmt_oneof();
7016
0
  }
7017
0
}
7018
0
inline ::ruby_fuzzer::AssignmentStatement* Statement::release_assignment() {
7019
0
  // @@protoc_insertion_point(field_release:ruby_fuzzer.Statement.assignment)
7020
0
  if (stmt_oneof_case() == kAssignment) {
7021
0
    clear_has_stmt_oneof();
7022
0
    ::ruby_fuzzer::AssignmentStatement* temp = _impl_.stmt_oneof_.assignment_;
7023
0
    if (GetArenaForAllocation() != nullptr) {
7024
0
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
7025
0
    }
7026
0
    _impl_.stmt_oneof_.assignment_ = nullptr;
7027
0
    return temp;
7028
0
  } else {
7029
0
    return nullptr;
7030
0
  }
7031
0
}
7032
212k
inline const ::ruby_fuzzer::AssignmentStatement& Statement::_internal_assignment() const {
7033
212k
  return stmt_oneof_case() == kAssignment
7034
212k
      ? *_impl_.stmt_oneof_.assignment_
7035
212k
      : reinterpret_cast< ::ruby_fuzzer::AssignmentStatement&>(::ruby_fuzzer::_AssignmentStatement_default_instance_);
7036
212k
}
7037
212k
inline const ::ruby_fuzzer::AssignmentStatement& Statement::assignment() const {
7038
  // @@protoc_insertion_point(field_get:ruby_fuzzer.Statement.assignment)
7039
212k
  return _internal_assignment();
7040
212k
}
7041
0
inline ::ruby_fuzzer::AssignmentStatement* Statement::unsafe_arena_release_assignment() {
7042
0
  // @@protoc_insertion_point(field_unsafe_arena_release:ruby_fuzzer.Statement.assignment)
7043
0
  if (stmt_oneof_case() == kAssignment) {
7044
0
    clear_has_stmt_oneof();
7045
0
    ::ruby_fuzzer::AssignmentStatement* temp = _impl_.stmt_oneof_.assignment_;
7046
0
    _impl_.stmt_oneof_.assignment_ = nullptr;
7047
0
    return temp;
7048
0
  } else {
7049
0
    return nullptr;
7050
0
  }
7051
0
}
7052
0
inline void Statement::unsafe_arena_set_allocated_assignment(::ruby_fuzzer::AssignmentStatement* assignment) {
7053
0
  clear_stmt_oneof();
7054
0
  if (assignment) {
7055
0
    set_has_assignment();
7056
0
    _impl_.stmt_oneof_.assignment_ = assignment;
7057
0
  }
7058
0
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ruby_fuzzer.Statement.assignment)
7059
0
}
7060
0
inline ::ruby_fuzzer::AssignmentStatement* Statement::_internal_mutable_assignment() {
7061
0
  if (stmt_oneof_case() != kAssignment) {
7062
0
    clear_stmt_oneof();
7063
0
    set_has_assignment();
7064
0
    _impl_.stmt_oneof_.assignment_ = CreateMaybeMessage< ::ruby_fuzzer::AssignmentStatement >(GetArenaForAllocation());
7065
0
  }
7066
0
  return _impl_.stmt_oneof_.assignment_;
7067
0
}
7068
0
inline ::ruby_fuzzer::AssignmentStatement* Statement::mutable_assignment() {
7069
0
  ::ruby_fuzzer::AssignmentStatement* _msg = _internal_mutable_assignment();
7070
0
  // @@protoc_insertion_point(field_mutable:ruby_fuzzer.Statement.assignment)
7071
0
  return _msg;
7072
0
}
7073
7074
// .ruby_fuzzer.IfElse ifelse = 2;
7075
0
inline bool Statement::has_ifelse() const {
7076
0
  return stmt_oneof_case() == kIfelse;
7077
0
}
7078
0
inline bool Statement::_internal_has_ifelse() const {
7079
0
  return stmt_oneof_case() == kIfelse;
7080
0
}
7081
0
inline void Statement::set_has_ifelse() {
7082
0
  _impl_._oneof_case_[0] = kIfelse;
7083
0
}
7084
0
inline void Statement::clear_ifelse() {
7085
0
  if (stmt_oneof_case() == kIfelse) {
7086
0
    if (GetArenaForAllocation() == nullptr) {
7087
0
      delete _impl_.stmt_oneof_.ifelse_;
7088
0
    }
7089
0
    clear_has_stmt_oneof();
7090
0
  }
7091
0
}
7092
0
inline ::ruby_fuzzer::IfElse* Statement::release_ifelse() {
7093
0
  // @@protoc_insertion_point(field_release:ruby_fuzzer.Statement.ifelse)
7094
0
  if (stmt_oneof_case() == kIfelse) {
7095
0
    clear_has_stmt_oneof();
7096
0
    ::ruby_fuzzer::IfElse* temp = _impl_.stmt_oneof_.ifelse_;
7097
0
    if (GetArenaForAllocation() != nullptr) {
7098
0
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
7099
0
    }
7100
0
    _impl_.stmt_oneof_.ifelse_ = nullptr;
7101
0
    return temp;
7102
0
  } else {
7103
0
    return nullptr;
7104
0
  }
7105
0
}
7106
17.5k
inline const ::ruby_fuzzer::IfElse& Statement::_internal_ifelse() const {
7107
17.5k
  return stmt_oneof_case() == kIfelse
7108
17.5k
      ? *_impl_.stmt_oneof_.ifelse_
7109
17.5k
      : reinterpret_cast< ::ruby_fuzzer::IfElse&>(::ruby_fuzzer::_IfElse_default_instance_);
7110
17.5k
}
7111
17.5k
inline const ::ruby_fuzzer::IfElse& Statement::ifelse() const {
7112
  // @@protoc_insertion_point(field_get:ruby_fuzzer.Statement.ifelse)
7113
17.5k
  return _internal_ifelse();
7114
17.5k
}
7115
0
inline ::ruby_fuzzer::IfElse* Statement::unsafe_arena_release_ifelse() {
7116
0
  // @@protoc_insertion_point(field_unsafe_arena_release:ruby_fuzzer.Statement.ifelse)
7117
0
  if (stmt_oneof_case() == kIfelse) {
7118
0
    clear_has_stmt_oneof();
7119
0
    ::ruby_fuzzer::IfElse* temp = _impl_.stmt_oneof_.ifelse_;
7120
0
    _impl_.stmt_oneof_.ifelse_ = nullptr;
7121
0
    return temp;
7122
0
  } else {
7123
0
    return nullptr;
7124
0
  }
7125
0
}
7126
0
inline void Statement::unsafe_arena_set_allocated_ifelse(::ruby_fuzzer::IfElse* ifelse) {
7127
0
  clear_stmt_oneof();
7128
0
  if (ifelse) {
7129
0
    set_has_ifelse();
7130
0
    _impl_.stmt_oneof_.ifelse_ = ifelse;
7131
0
  }
7132
0
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ruby_fuzzer.Statement.ifelse)
7133
0
}
7134
0
inline ::ruby_fuzzer::IfElse* Statement::_internal_mutable_ifelse() {
7135
0
  if (stmt_oneof_case() != kIfelse) {
7136
0
    clear_stmt_oneof();
7137
0
    set_has_ifelse();
7138
0
    _impl_.stmt_oneof_.ifelse_ = CreateMaybeMessage< ::ruby_fuzzer::IfElse >(GetArenaForAllocation());
7139
0
  }
7140
0
  return _impl_.stmt_oneof_.ifelse_;
7141
0
}
7142
0
inline ::ruby_fuzzer::IfElse* Statement::mutable_ifelse() {
7143
0
  ::ruby_fuzzer::IfElse* _msg = _internal_mutable_ifelse();
7144
0
  // @@protoc_insertion_point(field_mutable:ruby_fuzzer.Statement.ifelse)
7145
0
  return _msg;
7146
0
}
7147
7148
// .ruby_fuzzer.Ternary ternary_stmt = 3;
7149
0
inline bool Statement::has_ternary_stmt() const {
7150
0
  return stmt_oneof_case() == kTernaryStmt;
7151
0
}
7152
0
inline bool Statement::_internal_has_ternary_stmt() const {
7153
0
  return stmt_oneof_case() == kTernaryStmt;
7154
0
}
7155
0
inline void Statement::set_has_ternary_stmt() {
7156
0
  _impl_._oneof_case_[0] = kTernaryStmt;
7157
0
}
7158
0
inline void Statement::clear_ternary_stmt() {
7159
0
  if (stmt_oneof_case() == kTernaryStmt) {
7160
0
    if (GetArenaForAllocation() == nullptr) {
7161
0
      delete _impl_.stmt_oneof_.ternary_stmt_;
7162
0
    }
7163
0
    clear_has_stmt_oneof();
7164
0
  }
7165
0
}
7166
0
inline ::ruby_fuzzer::Ternary* Statement::release_ternary_stmt() {
7167
0
  // @@protoc_insertion_point(field_release:ruby_fuzzer.Statement.ternary_stmt)
7168
0
  if (stmt_oneof_case() == kTernaryStmt) {
7169
0
    clear_has_stmt_oneof();
7170
0
    ::ruby_fuzzer::Ternary* temp = _impl_.stmt_oneof_.ternary_stmt_;
7171
0
    if (GetArenaForAllocation() != nullptr) {
7172
0
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
7173
0
    }
7174
0
    _impl_.stmt_oneof_.ternary_stmt_ = nullptr;
7175
0
    return temp;
7176
0
  } else {
7177
0
    return nullptr;
7178
0
  }
7179
0
}
7180
8.56k
inline const ::ruby_fuzzer::Ternary& Statement::_internal_ternary_stmt() const {
7181
8.56k
  return stmt_oneof_case() == kTernaryStmt
7182
8.56k
      ? *_impl_.stmt_oneof_.ternary_stmt_
7183
8.56k
      : reinterpret_cast< ::ruby_fuzzer::Ternary&>(::ruby_fuzzer::_Ternary_default_instance_);
7184
8.56k
}
7185
8.56k
inline const ::ruby_fuzzer::Ternary& Statement::ternary_stmt() const {
7186
  // @@protoc_insertion_point(field_get:ruby_fuzzer.Statement.ternary_stmt)
7187
8.56k
  return _internal_ternary_stmt();
7188
8.56k
}
7189
0
inline ::ruby_fuzzer::Ternary* Statement::unsafe_arena_release_ternary_stmt() {
7190
0
  // @@protoc_insertion_point(field_unsafe_arena_release:ruby_fuzzer.Statement.ternary_stmt)
7191
0
  if (stmt_oneof_case() == kTernaryStmt) {
7192
0
    clear_has_stmt_oneof();
7193
0
    ::ruby_fuzzer::Ternary* temp = _impl_.stmt_oneof_.ternary_stmt_;
7194
0
    _impl_.stmt_oneof_.ternary_stmt_ = nullptr;
7195
0
    return temp;
7196
0
  } else {
7197
0
    return nullptr;
7198
0
  }
7199
0
}
7200
0
inline void Statement::unsafe_arena_set_allocated_ternary_stmt(::ruby_fuzzer::Ternary* ternary_stmt) {
7201
0
  clear_stmt_oneof();
7202
0
  if (ternary_stmt) {
7203
0
    set_has_ternary_stmt();
7204
0
    _impl_.stmt_oneof_.ternary_stmt_ = ternary_stmt;
7205
0
  }
7206
0
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ruby_fuzzer.Statement.ternary_stmt)
7207
0
}
7208
0
inline ::ruby_fuzzer::Ternary* Statement::_internal_mutable_ternary_stmt() {
7209
0
  if (stmt_oneof_case() != kTernaryStmt) {
7210
0
    clear_stmt_oneof();
7211
0
    set_has_ternary_stmt();
7212
0
    _impl_.stmt_oneof_.ternary_stmt_ = CreateMaybeMessage< ::ruby_fuzzer::Ternary >(GetArenaForAllocation());
7213
0
  }
7214
0
  return _impl_.stmt_oneof_.ternary_stmt_;
7215
0
}
7216
0
inline ::ruby_fuzzer::Ternary* Statement::mutable_ternary_stmt() {
7217
0
  ::ruby_fuzzer::Ternary* _msg = _internal_mutable_ternary_stmt();
7218
0
  // @@protoc_insertion_point(field_mutable:ruby_fuzzer.Statement.ternary_stmt)
7219
0
  return _msg;
7220
0
}
7221
7222
// .ruby_fuzzer.BuiltinFuncs builtins = 4;
7223
0
inline bool Statement::has_builtins() const {
7224
0
  return stmt_oneof_case() == kBuiltins;
7225
0
}
7226
0
inline bool Statement::_internal_has_builtins() const {
7227
0
  return stmt_oneof_case() == kBuiltins;
7228
0
}
7229
0
inline void Statement::set_has_builtins() {
7230
0
  _impl_._oneof_case_[0] = kBuiltins;
7231
0
}
7232
0
inline void Statement::clear_builtins() {
7233
0
  if (stmt_oneof_case() == kBuiltins) {
7234
0
    if (GetArenaForAllocation() == nullptr) {
7235
0
      delete _impl_.stmt_oneof_.builtins_;
7236
0
    }
7237
0
    clear_has_stmt_oneof();
7238
0
  }
7239
0
}
7240
0
inline ::ruby_fuzzer::BuiltinFuncs* Statement::release_builtins() {
7241
0
  // @@protoc_insertion_point(field_release:ruby_fuzzer.Statement.builtins)
7242
0
  if (stmt_oneof_case() == kBuiltins) {
7243
0
    clear_has_stmt_oneof();
7244
0
    ::ruby_fuzzer::BuiltinFuncs* temp = _impl_.stmt_oneof_.builtins_;
7245
0
    if (GetArenaForAllocation() != nullptr) {
7246
0
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
7247
0
    }
7248
0
    _impl_.stmt_oneof_.builtins_ = nullptr;
7249
0
    return temp;
7250
0
  } else {
7251
0
    return nullptr;
7252
0
  }
7253
0
}
7254
118k
inline const ::ruby_fuzzer::BuiltinFuncs& Statement::_internal_builtins() const {
7255
118k
  return stmt_oneof_case() == kBuiltins
7256
118k
      ? *_impl_.stmt_oneof_.builtins_
7257
118k
      : reinterpret_cast< ::ruby_fuzzer::BuiltinFuncs&>(::ruby_fuzzer::_BuiltinFuncs_default_instance_);
7258
118k
}
7259
118k
inline const ::ruby_fuzzer::BuiltinFuncs& Statement::builtins() const {
7260
  // @@protoc_insertion_point(field_get:ruby_fuzzer.Statement.builtins)
7261
118k
  return _internal_builtins();
7262
118k
}
7263
0
inline ::ruby_fuzzer::BuiltinFuncs* Statement::unsafe_arena_release_builtins() {
7264
0
  // @@protoc_insertion_point(field_unsafe_arena_release:ruby_fuzzer.Statement.builtins)
7265
0
  if (stmt_oneof_case() == kBuiltins) {
7266
0
    clear_has_stmt_oneof();
7267
0
    ::ruby_fuzzer::BuiltinFuncs* temp = _impl_.stmt_oneof_.builtins_;
7268
0
    _impl_.stmt_oneof_.builtins_ = nullptr;
7269
0
    return temp;
7270
0
  } else {
7271
0
    return nullptr;
7272
0
  }
7273
0
}
7274
0
inline void Statement::unsafe_arena_set_allocated_builtins(::ruby_fuzzer::BuiltinFuncs* builtins) {
7275
0
  clear_stmt_oneof();
7276
0
  if (builtins) {
7277
0
    set_has_builtins();
7278
0
    _impl_.stmt_oneof_.builtins_ = builtins;
7279
0
  }
7280
0
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ruby_fuzzer.Statement.builtins)
7281
0
}
7282
0
inline ::ruby_fuzzer::BuiltinFuncs* Statement::_internal_mutable_builtins() {
7283
0
  if (stmt_oneof_case() != kBuiltins) {
7284
0
    clear_stmt_oneof();
7285
0
    set_has_builtins();
7286
0
    _impl_.stmt_oneof_.builtins_ = CreateMaybeMessage< ::ruby_fuzzer::BuiltinFuncs >(GetArenaForAllocation());
7287
0
  }
7288
0
  return _impl_.stmt_oneof_.builtins_;
7289
0
}
7290
0
inline ::ruby_fuzzer::BuiltinFuncs* Statement::mutable_builtins() {
7291
0
  ::ruby_fuzzer::BuiltinFuncs* _msg = _internal_mutable_builtins();
7292
0
  // @@protoc_insertion_point(field_mutable:ruby_fuzzer.Statement.builtins)
7293
0
  return _msg;
7294
0
}
7295
7296
// .ruby_fuzzer.StatementSeq blockstmt = 5;
7297
0
inline bool Statement::has_blockstmt() const {
7298
0
  return stmt_oneof_case() == kBlockstmt;
7299
0
}
7300
0
inline bool Statement::_internal_has_blockstmt() const {
7301
0
  return stmt_oneof_case() == kBlockstmt;
7302
0
}
7303
0
inline void Statement::set_has_blockstmt() {
7304
0
  _impl_._oneof_case_[0] = kBlockstmt;
7305
0
}
7306
0
inline void Statement::clear_blockstmt() {
7307
0
  if (stmt_oneof_case() == kBlockstmt) {
7308
0
    if (GetArenaForAllocation() == nullptr) {
7309
0
      delete _impl_.stmt_oneof_.blockstmt_;
7310
0
    }
7311
0
    clear_has_stmt_oneof();
7312
0
  }
7313
0
}
7314
0
inline ::ruby_fuzzer::StatementSeq* Statement::release_blockstmt() {
7315
0
  // @@protoc_insertion_point(field_release:ruby_fuzzer.Statement.blockstmt)
7316
0
  if (stmt_oneof_case() == kBlockstmt) {
7317
0
    clear_has_stmt_oneof();
7318
0
    ::ruby_fuzzer::StatementSeq* temp = _impl_.stmt_oneof_.blockstmt_;
7319
0
    if (GetArenaForAllocation() != nullptr) {
7320
0
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
7321
0
    }
7322
0
    _impl_.stmt_oneof_.blockstmt_ = nullptr;
7323
0
    return temp;
7324
0
  } else {
7325
0
    return nullptr;
7326
0
  }
7327
0
}
7328
33.0k
inline const ::ruby_fuzzer::StatementSeq& Statement::_internal_blockstmt() const {
7329
33.0k
  return stmt_oneof_case() == kBlockstmt
7330
33.0k
      ? *_impl_.stmt_oneof_.blockstmt_
7331
33.0k
      : reinterpret_cast< ::ruby_fuzzer::StatementSeq&>(::ruby_fuzzer::_StatementSeq_default_instance_);
7332
33.0k
}
7333
33.0k
inline const ::ruby_fuzzer::StatementSeq& Statement::blockstmt() const {
7334
  // @@protoc_insertion_point(field_get:ruby_fuzzer.Statement.blockstmt)
7335
33.0k
  return _internal_blockstmt();
7336
33.0k
}
7337
0
inline ::ruby_fuzzer::StatementSeq* Statement::unsafe_arena_release_blockstmt() {
7338
0
  // @@protoc_insertion_point(field_unsafe_arena_release:ruby_fuzzer.Statement.blockstmt)
7339
0
  if (stmt_oneof_case() == kBlockstmt) {
7340
0
    clear_has_stmt_oneof();
7341
0
    ::ruby_fuzzer::StatementSeq* temp = _impl_.stmt_oneof_.blockstmt_;
7342
0
    _impl_.stmt_oneof_.blockstmt_ = nullptr;
7343
0
    return temp;
7344
0
  } else {
7345
0
    return nullptr;
7346
0
  }
7347
0
}
7348
0
inline void Statement::unsafe_arena_set_allocated_blockstmt(::ruby_fuzzer::StatementSeq* blockstmt) {
7349
0
  clear_stmt_oneof();
7350
0
  if (blockstmt) {
7351
0
    set_has_blockstmt();
7352
0
    _impl_.stmt_oneof_.blockstmt_ = blockstmt;
7353
0
  }
7354
0
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ruby_fuzzer.Statement.blockstmt)
7355
0
}
7356
0
inline ::ruby_fuzzer::StatementSeq* Statement::_internal_mutable_blockstmt() {
7357
0
  if (stmt_oneof_case() != kBlockstmt) {
7358
0
    clear_stmt_oneof();
7359
0
    set_has_blockstmt();
7360
0
    _impl_.stmt_oneof_.blockstmt_ = CreateMaybeMessage< ::ruby_fuzzer::StatementSeq >(GetArenaForAllocation());
7361
0
  }
7362
0
  return _impl_.stmt_oneof_.blockstmt_;
7363
0
}
7364
0
inline ::ruby_fuzzer::StatementSeq* Statement::mutable_blockstmt() {
7365
0
  ::ruby_fuzzer::StatementSeq* _msg = _internal_mutable_blockstmt();
7366
0
  // @@protoc_insertion_point(field_mutable:ruby_fuzzer.Statement.blockstmt)
7367
0
  return _msg;
7368
0
}
7369
7370
554k
inline bool Statement::has_stmt_oneof() const {
7371
554k
  return stmt_oneof_case() != STMT_ONEOF_NOT_SET;
7372
554k
}
7373
554k
inline void Statement::clear_has_stmt_oneof() {
7374
554k
  _impl_._oneof_case_[0] = STMT_ONEOF_NOT_SET;
7375
554k
}
7376
1.89M
inline Statement::StmtOneofCase Statement::stmt_oneof_case() const {
7377
1.89M
  return Statement::StmtOneofCase(_impl_._oneof_case_[0]);
7378
1.89M
}
7379
// -------------------------------------------------------------------
7380
7381
// StatementSeq
7382
7383
// repeated .ruby_fuzzer.Statement statements = 1;
7384
69.8k
inline int StatementSeq::_internal_statements_size() const {
7385
69.8k
  return _impl_.statements_.size();
7386
69.8k
}
7387
69.8k
inline int StatementSeq::statements_size() const {
7388
69.8k
  return _internal_statements_size();
7389
69.8k
}
7390
0
inline void StatementSeq::clear_statements() {
7391
0
  _impl_.statements_.Clear();
7392
0
}
7393
0
inline ::ruby_fuzzer::Statement* StatementSeq::mutable_statements(int index) {
7394
0
  // @@protoc_insertion_point(field_mutable:ruby_fuzzer.StatementSeq.statements)
7395
0
  return _impl_.statements_.Mutable(index);
7396
0
}
7397
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::ruby_fuzzer::Statement >*
7398
0
StatementSeq::mutable_statements() {
7399
0
  // @@protoc_insertion_point(field_mutable_list:ruby_fuzzer.StatementSeq.statements)
7400
0
  return &_impl_.statements_;
7401
0
}
7402
0
inline const ::ruby_fuzzer::Statement& StatementSeq::_internal_statements(int index) const {
7403
0
  return _impl_.statements_.Get(index);
7404
0
}
7405
0
inline const ::ruby_fuzzer::Statement& StatementSeq::statements(int index) const {
7406
0
  // @@protoc_insertion_point(field_get:ruby_fuzzer.StatementSeq.statements)
7407
0
  return _internal_statements(index);
7408
0
}
7409
0
inline ::ruby_fuzzer::Statement* StatementSeq::_internal_add_statements() {
7410
0
  return _impl_.statements_.Add();
7411
0
}
7412
0
inline ::ruby_fuzzer::Statement* StatementSeq::add_statements() {
7413
0
  ::ruby_fuzzer::Statement* _add = _internal_add_statements();
7414
0
  // @@protoc_insertion_point(field_add:ruby_fuzzer.StatementSeq.statements)
7415
0
  return _add;
7416
0
}
7417
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::ruby_fuzzer::Statement >&
7418
31.8k
StatementSeq::statements() const {
7419
  // @@protoc_insertion_point(field_list:ruby_fuzzer.StatementSeq.statements)
7420
31.8k
  return _impl_.statements_;
7421
31.8k
}
7422
7423
// -------------------------------------------------------------------
7424
7425
// Function
7426
7427
// required .ruby_fuzzer.StatementSeq statements = 1;
7428
0
inline bool Function::has_statements() const {
7429
0
  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
7430
0
  PROTOBUF_ASSUME(!value || _impl_.statements_ != nullptr);
7431
0
  return value;
7432
0
}
7433
0
inline void Function::clear_statements() {
7434
0
  if (_impl_.statements_ != nullptr) _impl_.statements_->Clear();
7435
0
  _impl_._has_bits_[0] &= ~0x00000001u;
7436
0
}
7437
1.74k
inline const ::ruby_fuzzer::StatementSeq& Function::_internal_statements() const {
7438
1.74k
  const ::ruby_fuzzer::StatementSeq* p = _impl_.statements_;
7439
1.74k
  return p != nullptr ? *p : reinterpret_cast<const ::ruby_fuzzer::StatementSeq&>(
7440
0
      ::ruby_fuzzer::_StatementSeq_default_instance_);
7441
1.74k
}
7442
1.74k
inline const ::ruby_fuzzer::StatementSeq& Function::statements() const {
7443
  // @@protoc_insertion_point(field_get:ruby_fuzzer.Function.statements)
7444
1.74k
  return _internal_statements();
7445
1.74k
}
7446
inline void Function::unsafe_arena_set_allocated_statements(
7447
0
    ::ruby_fuzzer::StatementSeq* statements) {
7448
0
  if (GetArenaForAllocation() == nullptr) {
7449
0
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.statements_);
7450
0
  }
7451
0
  _impl_.statements_ = statements;
7452
0
  if (statements) {
7453
0
    _impl_._has_bits_[0] |= 0x00000001u;
7454
0
  } else {
7455
0
    _impl_._has_bits_[0] &= ~0x00000001u;
7456
0
  }
7457
0
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:ruby_fuzzer.Function.statements)
7458
0
}
7459
0
inline ::ruby_fuzzer::StatementSeq* Function::release_statements() {
7460
0
  _impl_._has_bits_[0] &= ~0x00000001u;
7461
0
  ::ruby_fuzzer::StatementSeq* temp = _impl_.statements_;
7462
0
  _impl_.statements_ = nullptr;
7463
0
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
7464
0
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
7465
0
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
7466
0
  if (GetArenaForAllocation() == nullptr) { delete old; }
7467
0
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
7468
0
  if (GetArenaForAllocation() != nullptr) {
7469
0
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
7470
0
  }
7471
0
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
7472
0
  return temp;
7473
0
}
7474
0
inline ::ruby_fuzzer::StatementSeq* Function::unsafe_arena_release_statements() {
7475
0
  // @@protoc_insertion_point(field_release:ruby_fuzzer.Function.statements)
7476
0
  _impl_._has_bits_[0] &= ~0x00000001u;
7477
0
  ::ruby_fuzzer::StatementSeq* temp = _impl_.statements_;
7478
0
  _impl_.statements_ = nullptr;
7479
0
  return temp;
7480
0
}
7481
0
inline ::ruby_fuzzer::StatementSeq* Function::_internal_mutable_statements() {
7482
0
  _impl_._has_bits_[0] |= 0x00000001u;
7483
0
  if (_impl_.statements_ == nullptr) {
7484
0
    auto* p = CreateMaybeMessage<::ruby_fuzzer::StatementSeq>(GetArenaForAllocation());
7485
0
    _impl_.statements_ = p;
7486
0
  }
7487
0
  return _impl_.statements_;
7488
0
}
7489
0
inline ::ruby_fuzzer::StatementSeq* Function::mutable_statements() {
7490
0
  ::ruby_fuzzer::StatementSeq* _msg = _internal_mutable_statements();
7491
0
  // @@protoc_insertion_point(field_mutable:ruby_fuzzer.Function.statements)
7492
0
  return _msg;
7493
0
}
7494
0
inline void Function::set_allocated_statements(::ruby_fuzzer::StatementSeq* statements) {
7495
0
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
7496
0
  if (message_arena == nullptr) {
7497
0
    delete _impl_.statements_;
7498
0
  }
7499
0
  if (statements) {
7500
0
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
7501
0
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(statements);
7502
0
    if (message_arena != submessage_arena) {
7503
0
      statements = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
7504
0
          message_arena, statements, submessage_arena);
7505
0
    }
7506
0
    _impl_._has_bits_[0] |= 0x00000001u;
7507
0
  } else {
7508
0
    _impl_._has_bits_[0] &= ~0x00000001u;
7509
0
  }
7510
0
  _impl_.statements_ = statements;
7511
0
  // @@protoc_insertion_point(field_set_allocated:ruby_fuzzer.Function.statements)
7512
0
}
7513
7514
#ifdef __GNUC__
7515
#pragma GCC diagnostic pop
7516
#endif  // __GNUC__
7517
7518
// @@protoc_insertion_point(namespace_scope)
7519
}  // namespace ruby_fuzzer
7520
7521
7522
PROTOBUF_NAMESPACE_OPEN
7523
7524
template <>
7525
struct is_proto_enum<::ruby_fuzzer::StringExtNoArg_StrExtOp> : std::true_type {};
7526
template <>
7527
0
inline const EnumDescriptor* GetEnumDescriptor<::ruby_fuzzer::StringExtNoArg_StrExtOp>() {
7528
0
  return ::ruby_fuzzer::StringExtNoArg_StrExtOp_descriptor();
7529
0
}
7530
template <>
7531
struct is_proto_enum<::ruby_fuzzer::MathConst_MathConstLit> : std::true_type {};
7532
template <>
7533
0
inline const EnumDescriptor* GetEnumDescriptor<::ruby_fuzzer::MathConst_MathConstLit>() {
7534
0
  return ::ruby_fuzzer::MathConst_MathConstLit_descriptor();
7535
0
}
7536
template <>
7537
struct is_proto_enum<::ruby_fuzzer::BinaryOp_Op> : std::true_type {};
7538
template <>
7539
0
inline const EnumDescriptor* GetEnumDescriptor<::ruby_fuzzer::BinaryOp_Op>() {
7540
0
  return ::ruby_fuzzer::BinaryOp_Op_descriptor();
7541
0
}
7542
template <>
7543
struct is_proto_enum<::ruby_fuzzer::ObjectSpace_OS_methods> : std::true_type {};
7544
template <>
7545
0
inline const EnumDescriptor* GetEnumDescriptor<::ruby_fuzzer::ObjectSpace_OS_methods>() {
7546
0
  return ::ruby_fuzzer::ObjectSpace_OS_methods_descriptor();
7547
0
}
7548
template <>
7549
struct is_proto_enum<::ruby_fuzzer::Time_T_methods> : std::true_type {};
7550
template <>
7551
0
inline const EnumDescriptor* GetEnumDescriptor<::ruby_fuzzer::Time_T_methods>() {
7552
0
  return ::ruby_fuzzer::Time_T_methods_descriptor();
7553
0
}
7554
template <>
7555
struct is_proto_enum<::ruby_fuzzer::Array_Arr_methods> : std::true_type {};
7556
template <>
7557
0
inline const EnumDescriptor* GetEnumDescriptor<::ruby_fuzzer::Array_Arr_methods>() {
7558
0
  return ::ruby_fuzzer::Array_Arr_methods_descriptor();
7559
0
}
7560
template <>
7561
struct is_proto_enum<::ruby_fuzzer::MathOps_Mops> : std::true_type {};
7562
template <>
7563
0
inline const EnumDescriptor* GetEnumDescriptor<::ruby_fuzzer::MathOps_Mops>() {
7564
0
  return ::ruby_fuzzer::MathOps_Mops_descriptor();
7565
0
}
7566
7567
PROTOBUF_NAMESPACE_CLOSE
7568
7569
// @@protoc_insertion_point(global_scope)
7570
7571
#include "google/protobuf/port_undef.inc"
7572
7573
#endif  // GOOGLE_PROTOBUF_INCLUDED_ruby_2eproto_2epb_2eh