// Generated by the protocol buffer compiler.  DO NOT EDIT!

// source: yulProto.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_yulProto_2eproto

#define GOOGLE_PROTOBUF_INCLUDED_yulProto_2eproto

#include <limits>

#include <string>

#include <google/protobuf/port_def.inc>

#if PROTOBUF_VERSION < 3021000

#error This file was generated by a newer version of protoc which is

#error incompatible with your Protocol Buffer headers. Please update

#error your headers.

#endif

#if 3021007 < PROTOBUF_MIN_PROTOC_VERSION

#error This file was generated by an older version of protoc which is

#error incompatible with your Protocol Buffer headers. Please

#error regenerate this file with a newer version of protoc.

#endif

#include <google/protobuf/port_undef.inc>

#include <google/protobuf/io/coded_stream.h>

#include <google/protobuf/arena.h>

#include <google/protobuf/arenastring.h>

#include <google/protobuf/generated_message_bases.h>

#include <google/protobuf/generated_message_util.h>

#include <google/protobuf/metadata_lite.h>

#include <google/protobuf/generated_message_reflection.h>

#include <google/protobuf/message.h>

#include <google/protobuf/repeated_field.h>  // IWYU pragma: export

#include <google/protobuf/extension_set.h>  // IWYU pragma: export

#include <google/protobuf/generated_enum_reflection.h>

#include <google/protobuf/unknown_field_set.h>

// @@protoc_insertion_point(includes)

#include <google/protobuf/port_def.inc>

#define PROTOBUF_INTERNAL_EXPORT_yulProto_2eproto

PROTOBUF_NAMESPACE_OPEN

namespace internal {

class AnyMetadata;

}  // namespace internal

PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.

struct TableStruct_yulProto_2eproto {

  static const uint32_t offsets[];

};

extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_yulProto_2eproto;

namespace solidity {

namespace yul {

namespace test {

namespace yul_fuzzer {

class AssignmentStatement;

struct AssignmentStatementDefaultTypeInternal;

extern AssignmentStatementDefaultTypeInternal _AssignmentStatement_default_instance_;

class BinaryOp;

struct BinaryOpDefaultTypeInternal;

extern BinaryOpDefaultTypeInternal _BinaryOp_default_instance_;

class Block;

struct BlockDefaultTypeInternal;

extern BlockDefaultTypeInternal _Block_default_instance_;

class BoundedForStmt;

struct BoundedForStmtDefaultTypeInternal;

extern BoundedForStmtDefaultTypeInternal _BoundedForStmt_default_instance_;

class BreakStmt;

struct BreakStmtDefaultTypeInternal;

extern BreakStmtDefaultTypeInternal _BreakStmt_default_instance_;

class CaseStmt;

struct CaseStmtDefaultTypeInternal;

extern CaseStmtDefaultTypeInternal _CaseStmt_default_instance_;

class Code;

struct CodeDefaultTypeInternal;

extern CodeDefaultTypeInternal _Code_default_instance_;

class ContinueStmt;

struct ContinueStmtDefaultTypeInternal;

extern ContinueStmtDefaultTypeInternal _ContinueStmt_default_instance_;

class CopyFunc;

struct CopyFuncDefaultTypeInternal;

extern CopyFuncDefaultTypeInternal _CopyFunc_default_instance_;

class Create;

struct CreateDefaultTypeInternal;

extern CreateDefaultTypeInternal _Create_default_instance_;

class Data;

struct DataDefaultTypeInternal;

extern DataDefaultTypeInternal _Data_default_instance_;

class Expression;

struct ExpressionDefaultTypeInternal;

extern ExpressionDefaultTypeInternal _Expression_default_instance_;

class ExtCodeCopy;

struct ExtCodeCopyDefaultTypeInternal;

extern ExtCodeCopyDefaultTypeInternal _ExtCodeCopy_default_instance_;

class ForStmt;

struct ForStmtDefaultTypeInternal;

extern ForStmtDefaultTypeInternal _ForStmt_default_instance_;

class FunctionCall;

struct FunctionCallDefaultTypeInternal;

extern FunctionCallDefaultTypeInternal _FunctionCall_default_instance_;

class FunctionDef;

struct FunctionDefDefaultTypeInternal;

extern FunctionDefDefaultTypeInternal _FunctionDef_default_instance_;

class IfStmt;

struct IfStmtDefaultTypeInternal;

extern IfStmtDefaultTypeInternal _IfStmt_default_instance_;

class LeaveStmt;

struct LeaveStmtDefaultTypeInternal;

extern LeaveStmtDefaultTypeInternal _LeaveStmt_default_instance_;

class Literal;

struct LiteralDefaultTypeInternal;

extern LiteralDefaultTypeInternal _Literal_default_instance_;

class LogFunc;

struct LogFuncDefaultTypeInternal;

extern LogFuncDefaultTypeInternal _LogFunc_default_instance_;

class LowLevelCall;

struct LowLevelCallDefaultTypeInternal;

extern LowLevelCallDefaultTypeInternal _LowLevelCall_default_instance_;

class MultiVarDecl;

struct MultiVarDeclDefaultTypeInternal;

extern MultiVarDeclDefaultTypeInternal _MultiVarDecl_default_instance_;

class NullaryOp;

struct NullaryOpDefaultTypeInternal;

extern NullaryOpDefaultTypeInternal _NullaryOp_default_instance_;

class Object;

struct ObjectDefaultTypeInternal;

extern ObjectDefaultTypeInternal _Object_default_instance_;

class PopStmt;

struct PopStmtDefaultTypeInternal;

extern PopStmtDefaultTypeInternal _PopStmt_default_instance_;

class Program;

struct ProgramDefaultTypeInternal;

extern ProgramDefaultTypeInternal _Program_default_instance_;

class RetRevStmt;

struct RetRevStmtDefaultTypeInternal;

extern RetRevStmtDefaultTypeInternal _RetRevStmt_default_instance_;

class SelfDestructStmt;

struct SelfDestructStmtDefaultTypeInternal;

extern SelfDestructStmtDefaultTypeInternal _SelfDestructStmt_default_instance_;

class Statement;

struct StatementDefaultTypeInternal;

extern StatementDefaultTypeInternal _Statement_default_instance_;

class StopInvalidStmt;

struct StopInvalidStmtDefaultTypeInternal;

extern StopInvalidStmtDefaultTypeInternal _StopInvalidStmt_default_instance_;

class StoreFunc;

struct StoreFuncDefaultTypeInternal;

extern StoreFuncDefaultTypeInternal _StoreFunc_default_instance_;

class SwitchStmt;

struct SwitchStmtDefaultTypeInternal;

extern SwitchStmtDefaultTypeInternal _SwitchStmt_default_instance_;

class TerminatingStmt;

struct TerminatingStmtDefaultTypeInternal;

extern TerminatingStmtDefaultTypeInternal _TerminatingStmt_default_instance_;

class TernaryOp;

struct TernaryOpDefaultTypeInternal;

extern TernaryOpDefaultTypeInternal _TernaryOp_default_instance_;

class TypedLiteral;

struct TypedLiteralDefaultTypeInternal;

extern TypedLiteralDefaultTypeInternal _TypedLiteral_default_instance_;

class TypedVarDecl;

struct TypedVarDeclDefaultTypeInternal;

extern TypedVarDeclDefaultTypeInternal _TypedVarDecl_default_instance_;

class UnaryOp;

struct UnaryOpDefaultTypeInternal;

extern UnaryOpDefaultTypeInternal _UnaryOp_default_instance_;

class UnaryOpData;

struct UnaryOpDataDefaultTypeInternal;

extern UnaryOpDataDefaultTypeInternal _UnaryOpData_default_instance_;

class VarDecl;

struct VarDeclDefaultTypeInternal;

extern VarDeclDefaultTypeInternal _VarDecl_default_instance_;

class VarRef;

struct VarRefDefaultTypeInternal;

extern VarRefDefaultTypeInternal _VarRef_default_instance_;

}  // namespace yul_fuzzer

}  // namespace test

}  // namespace yul

}  // namespace solidity

PROTOBUF_NAMESPACE_OPEN

template<> ::solidity::yul::test::yul_fuzzer::AssignmentStatement* Arena::CreateMaybeMessage<::solidity::yul::test::yul_fuzzer::AssignmentStatement>(Arena*);

template<> ::solidity::yul::test::yul_fuzzer::BinaryOp* Arena::CreateMaybeMessage<::solidity::yul::test::yul_fuzzer::BinaryOp>(Arena*);

template<> ::solidity::yul::test::yul_fuzzer::Block* Arena::CreateMaybeMessage<::solidity::yul::test::yul_fuzzer::Block>(Arena*);

template<> ::solidity::yul::test::yul_fuzzer::BoundedForStmt* Arena::CreateMaybeMessage<::solidity::yul::test::yul_fuzzer::BoundedForStmt>(Arena*);

template<> ::solidity::yul::test::yul_fuzzer::BreakStmt* Arena::CreateMaybeMessage<::solidity::yul::test::yul_fuzzer::BreakStmt>(Arena*);

template<> ::solidity::yul::test::yul_fuzzer::CaseStmt* Arena::CreateMaybeMessage<::solidity::yul::test::yul_fuzzer::CaseStmt>(Arena*);

template<> ::solidity::yul::test::yul_fuzzer::Code* Arena::CreateMaybeMessage<::solidity::yul::test::yul_fuzzer::Code>(Arena*);

template<> ::solidity::yul::test::yul_fuzzer::ContinueStmt* Arena::CreateMaybeMessage<::solidity::yul::test::yul_fuzzer::ContinueStmt>(Arena*);

template<> ::solidity::yul::test::yul_fuzzer::CopyFunc* Arena::CreateMaybeMessage<::solidity::yul::test::yul_fuzzer::CopyFunc>(Arena*);

template<> ::solidity::yul::test::yul_fuzzer::Create* Arena::CreateMaybeMessage<::solidity::yul::test::yul_fuzzer::Create>(Arena*);

template<> ::solidity::yul::test::yul_fuzzer::Data* Arena::CreateMaybeMessage<::solidity::yul::test::yul_fuzzer::Data>(Arena*);

template<> ::solidity::yul::test::yul_fuzzer::Expression* Arena::CreateMaybeMessage<::solidity::yul::test::yul_fuzzer::Expression>(Arena*);

template<> ::solidity::yul::test::yul_fuzzer::ExtCodeCopy* Arena::CreateMaybeMessage<::solidity::yul::test::yul_fuzzer::ExtCodeCopy>(Arena*);

template<> ::solidity::yul::test::yul_fuzzer::ForStmt* Arena::CreateMaybeMessage<::solidity::yul::test::yul_fuzzer::ForStmt>(Arena*);

template<> ::solidity::yul::test::yul_fuzzer::FunctionCall* Arena::CreateMaybeMessage<::solidity::yul::test::yul_fuzzer::FunctionCall>(Arena*);

template<> ::solidity::yul::test::yul_fuzzer::FunctionDef* Arena::CreateMaybeMessage<::solidity::yul::test::yul_fuzzer::FunctionDef>(Arena*);

template<> ::solidity::yul::test::yul_fuzzer::IfStmt* Arena::CreateMaybeMessage<::solidity::yul::test::yul_fuzzer::IfStmt>(Arena*);

template<> ::solidity::yul::test::yul_fuzzer::LeaveStmt* Arena::CreateMaybeMessage<::solidity::yul::test::yul_fuzzer::LeaveStmt>(Arena*);

template<> ::solidity::yul::test::yul_fuzzer::Literal* Arena::CreateMaybeMessage<::solidity::yul::test::yul_fuzzer::Literal>(Arena*);

template<> ::solidity::yul::test::yul_fuzzer::LogFunc* Arena::CreateMaybeMessage<::solidity::yul::test::yul_fuzzer::LogFunc>(Arena*);

template<> ::solidity::yul::test::yul_fuzzer::LowLevelCall* Arena::CreateMaybeMessage<::solidity::yul::test::yul_fuzzer::LowLevelCall>(Arena*);

template<> ::solidity::yul::test::yul_fuzzer::MultiVarDecl* Arena::CreateMaybeMessage<::solidity::yul::test::yul_fuzzer::MultiVarDecl>(Arena*);

template<> ::solidity::yul::test::yul_fuzzer::NullaryOp* Arena::CreateMaybeMessage<::solidity::yul::test::yul_fuzzer::NullaryOp>(Arena*);

template<> ::solidity::yul::test::yul_fuzzer::Object* Arena::CreateMaybeMessage<::solidity::yul::test::yul_fuzzer::Object>(Arena*);

template<> ::solidity::yul::test::yul_fuzzer::PopStmt* Arena::CreateMaybeMessage<::solidity::yul::test::yul_fuzzer::PopStmt>(Arena*);

template<> ::solidity::yul::test::yul_fuzzer::Program* Arena::CreateMaybeMessage<::solidity::yul::test::yul_fuzzer::Program>(Arena*);

template<> ::solidity::yul::test::yul_fuzzer::RetRevStmt* Arena::CreateMaybeMessage<::solidity::yul::test::yul_fuzzer::RetRevStmt>(Arena*);

template<> ::solidity::yul::test::yul_fuzzer::SelfDestructStmt* Arena::CreateMaybeMessage<::solidity::yul::test::yul_fuzzer::SelfDestructStmt>(Arena*);

template<> ::solidity::yul::test::yul_fuzzer::Statement* Arena::CreateMaybeMessage<::solidity::yul::test::yul_fuzzer::Statement>(Arena*);

template<> ::solidity::yul::test::yul_fuzzer::StopInvalidStmt* Arena::CreateMaybeMessage<::solidity::yul::test::yul_fuzzer::StopInvalidStmt>(Arena*);

template<> ::solidity::yul::test::yul_fuzzer::StoreFunc* Arena::CreateMaybeMessage<::solidity::yul::test::yul_fuzzer::StoreFunc>(Arena*);

template<> ::solidity::yul::test::yul_fuzzer::SwitchStmt* Arena::CreateMaybeMessage<::solidity::yul::test::yul_fuzzer::SwitchStmt>(Arena*);

template<> ::solidity::yul::test::yul_fuzzer::TerminatingStmt* Arena::CreateMaybeMessage<::solidity::yul::test::yul_fuzzer::TerminatingStmt>(Arena*);

template<> ::solidity::yul::test::yul_fuzzer::TernaryOp* Arena::CreateMaybeMessage<::solidity::yul::test::yul_fuzzer::TernaryOp>(Arena*);

template<> ::solidity::yul::test::yul_fuzzer::TypedLiteral* Arena::CreateMaybeMessage<::solidity::yul::test::yul_fuzzer::TypedLiteral>(Arena*);

template<> ::solidity::yul::test::yul_fuzzer::TypedVarDecl* Arena::CreateMaybeMessage<::solidity::yul::test::yul_fuzzer::TypedVarDecl>(Arena*);

template<> ::solidity::yul::test::yul_fuzzer::UnaryOp* Arena::CreateMaybeMessage<::solidity::yul::test::yul_fuzzer::UnaryOp>(Arena*);

template<> ::solidity::yul::test::yul_fuzzer::UnaryOpData* Arena::CreateMaybeMessage<::solidity::yul::test::yul_fuzzer::UnaryOpData>(Arena*);

template<> ::solidity::yul::test::yul_fuzzer::VarDecl* Arena::CreateMaybeMessage<::solidity::yul::test::yul_fuzzer::VarDecl>(Arena*);

template<> ::solidity::yul::test::yul_fuzzer::VarRef* Arena::CreateMaybeMessage<::solidity::yul::test::yul_fuzzer::VarRef>(Arena*);

PROTOBUF_NAMESPACE_CLOSE

namespace solidity {

namespace yul {

namespace test {

namespace yul_fuzzer {

enum LowLevelCall_Type : int {

  LowLevelCall_Type_CALL = 0,

  LowLevelCall_Type_CALLCODE = 1,

  LowLevelCall_Type_DELEGATECALL = 2,

  LowLevelCall_Type_STATICCALL = 3

};

bool LowLevelCall_Type_IsValid(int value);

constexpr LowLevelCall_Type LowLevelCall_Type_Type_MIN = LowLevelCall_Type_CALL;

constexpr LowLevelCall_Type LowLevelCall_Type_Type_MAX = LowLevelCall_Type_STATICCALL;

constexpr int LowLevelCall_Type_Type_ARRAYSIZE = LowLevelCall_Type_Type_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LowLevelCall_Type_descriptor();

template<typename T>

inline const std::string& LowLevelCall_Type_Name(T enum_t_value) {

  static_assert(::std::is_same<T, LowLevelCall_Type>::value ||

    ::std::is_integral<T>::value,

    "Incorrect type passed to function LowLevelCall_Type_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    LowLevelCall_Type_descriptor(), enum_t_value);

}

inline bool LowLevelCall_Type_Parse(

    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LowLevelCall_Type* value) {

  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<LowLevelCall_Type>(

    LowLevelCall_Type_descriptor(), name, value);

}

enum Create_Type : int {

  Create_Type_CREATE = 0,

  Create_Type_CREATE2 = 1

};

bool Create_Type_IsValid(int value);

constexpr Create_Type Create_Type_Type_MIN = Create_Type_CREATE;

constexpr Create_Type Create_Type_Type_MAX = Create_Type_CREATE2;

constexpr int Create_Type_Type_ARRAYSIZE = Create_Type_Type_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Create_Type_descriptor();

template<typename T>

inline const std::string& Create_Type_Name(T enum_t_value) {

  static_assert(::std::is_same<T, Create_Type>::value ||

    ::std::is_integral<T>::value,

    "Incorrect type passed to function Create_Type_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    Create_Type_descriptor(), enum_t_value);

}

inline bool Create_Type_Parse(

    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Create_Type* value) {

  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Create_Type>(

    Create_Type_descriptor(), name, value);

}

enum TypedVarDecl_TypeName : int {

  TypedVarDecl_TypeName_BOOL = 1,

  TypedVarDecl_TypeName_U8 = 2,

  TypedVarDecl_TypeName_U32 = 3,

  TypedVarDecl_TypeName_U64 = 4,

  TypedVarDecl_TypeName_U128 = 5,

  TypedVarDecl_TypeName_U256 = 6,

  TypedVarDecl_TypeName_S8 = 7,

  TypedVarDecl_TypeName_S32 = 8,

  TypedVarDecl_TypeName_S64 = 9,

  TypedVarDecl_TypeName_S128 = 10,

  TypedVarDecl_TypeName_S256 = 11

};

bool TypedVarDecl_TypeName_IsValid(int value);

constexpr TypedVarDecl_TypeName TypedVarDecl_TypeName_TypeName_MIN = TypedVarDecl_TypeName_BOOL;

constexpr TypedVarDecl_TypeName TypedVarDecl_TypeName_TypeName_MAX = TypedVarDecl_TypeName_S256;

constexpr int TypedVarDecl_TypeName_TypeName_ARRAYSIZE = TypedVarDecl_TypeName_TypeName_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TypedVarDecl_TypeName_descriptor();

template<typename T>

inline const std::string& TypedVarDecl_TypeName_Name(T enum_t_value) {

  static_assert(::std::is_same<T, TypedVarDecl_TypeName>::value ||

    ::std::is_integral<T>::value,

    "Incorrect type passed to function TypedVarDecl_TypeName_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    TypedVarDecl_TypeName_descriptor(), enum_t_value);

}

inline bool TypedVarDecl_TypeName_Parse(

    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TypedVarDecl_TypeName* value) {

  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<TypedVarDecl_TypeName>(

    TypedVarDecl_TypeName_descriptor(), name, value);

}

enum TypedLiteral_TypeName : int {

  TypedLiteral_TypeName_BOOL = 1,

  TypedLiteral_TypeName_U8 = 2,

  TypedLiteral_TypeName_U32 = 3,

  TypedLiteral_TypeName_U64 = 4,

  TypedLiteral_TypeName_U128 = 5,

  TypedLiteral_TypeName_U256 = 6,

  TypedLiteral_TypeName_S8 = 7,

  TypedLiteral_TypeName_S32 = 8,

  TypedLiteral_TypeName_S64 = 9,

  TypedLiteral_TypeName_S128 = 10,

  TypedLiteral_TypeName_S256 = 11

};

bool TypedLiteral_TypeName_IsValid(int value);

constexpr TypedLiteral_TypeName TypedLiteral_TypeName_TypeName_MIN = TypedLiteral_TypeName_BOOL;

constexpr TypedLiteral_TypeName TypedLiteral_TypeName_TypeName_MAX = TypedLiteral_TypeName_S256;

constexpr int TypedLiteral_TypeName_TypeName_ARRAYSIZE = TypedLiteral_TypeName_TypeName_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TypedLiteral_TypeName_descriptor();

template<typename T>

inline const std::string& TypedLiteral_TypeName_Name(T enum_t_value) {

  static_assert(::std::is_same<T, TypedLiteral_TypeName>::value ||

    ::std::is_integral<T>::value,

    "Incorrect type passed to function TypedLiteral_TypeName_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    TypedLiteral_TypeName_descriptor(), enum_t_value);

}

inline bool TypedLiteral_TypeName_Parse(

    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TypedLiteral_TypeName* value) {

  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<TypedLiteral_TypeName>(

    TypedLiteral_TypeName_descriptor(), name, value);

}

enum BinaryOp_BOp : int {

  BinaryOp_BOp_ADD = 0,

  BinaryOp_BOp_SUB = 1,

  BinaryOp_BOp_MUL = 2,

  BinaryOp_BOp_DIV = 3,

  BinaryOp_BOp_MOD = 4,

  BinaryOp_BOp_XOR = 5,

  BinaryOp_BOp_AND = 6,

  BinaryOp_BOp_OR = 7,

  BinaryOp_BOp_EQ = 8,

  BinaryOp_BOp_LT = 9,

  BinaryOp_BOp_GT = 10,

  BinaryOp_BOp_SHR = 11,

  BinaryOp_BOp_SHL = 12,

  BinaryOp_BOp_SAR = 13,

  BinaryOp_BOp_SDIV = 14,

  BinaryOp_BOp_SMOD = 15,

  BinaryOp_BOp_EXP = 16,

  BinaryOp_BOp_SLT = 17,

  BinaryOp_BOp_SGT = 18,

  BinaryOp_BOp_BYTE = 19,

  BinaryOp_BOp_SI = 20,

  BinaryOp_BOp_KECCAK = 21

};

bool BinaryOp_BOp_IsValid(int value);

constexpr BinaryOp_BOp BinaryOp_BOp_BOp_MIN = BinaryOp_BOp_ADD;

constexpr BinaryOp_BOp BinaryOp_BOp_BOp_MAX = BinaryOp_BOp_KECCAK;

constexpr int BinaryOp_BOp_BOp_ARRAYSIZE = BinaryOp_BOp_BOp_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BinaryOp_BOp_descriptor();

template<typename T>

inline const std::string& BinaryOp_BOp_Name(T enum_t_value) {

  static_assert(::std::is_same<T, BinaryOp_BOp>::value ||

    ::std::is_integral<T>::value,

    "Incorrect type passed to function BinaryOp_BOp_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    BinaryOp_BOp_descriptor(), enum_t_value);

}

inline bool BinaryOp_BOp_Parse(

    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BinaryOp_BOp* value) {

  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<BinaryOp_BOp>(

    BinaryOp_BOp_descriptor(), name, value);

}

enum UnaryOp_UOp : int {

  UnaryOp_UOp_NOT = 0,

  UnaryOp_UOp_MLOAD = 1,

  UnaryOp_UOp_SLOAD = 2,

  UnaryOp_UOp_TLOAD = 3,

  UnaryOp_UOp_ISZERO = 4,

  UnaryOp_UOp_CALLDATALOAD = 5,

  UnaryOp_UOp_EXTCODESIZE = 6,

  UnaryOp_UOp_EXTCODEHASH = 7,

  UnaryOp_UOp_BALANCE = 8,

  UnaryOp_UOp_BLOCKHASH = 9,

  UnaryOp_UOp_BLOBHASH = 10

};

bool UnaryOp_UOp_IsValid(int value);

constexpr UnaryOp_UOp UnaryOp_UOp_UOp_MIN = UnaryOp_UOp_NOT;

constexpr UnaryOp_UOp UnaryOp_UOp_UOp_MAX = UnaryOp_UOp_BLOBHASH;

constexpr int UnaryOp_UOp_UOp_ARRAYSIZE = UnaryOp_UOp_UOp_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* UnaryOp_UOp_descriptor();

template<typename T>

inline const std::string& UnaryOp_UOp_Name(T enum_t_value) {

  static_assert(::std::is_same<T, UnaryOp_UOp>::value ||

    ::std::is_integral<T>::value,

    "Incorrect type passed to function UnaryOp_UOp_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    UnaryOp_UOp_descriptor(), enum_t_value);

}

inline bool UnaryOp_UOp_Parse(

    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, UnaryOp_UOp* value) {

  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<UnaryOp_UOp>(

    UnaryOp_UOp_descriptor(), name, value);

}

enum UnaryOpData_UOpData : int {

  UnaryOpData_UOpData_SIZE = 1,

  UnaryOpData_UOpData_OFFSET = 2

};

bool UnaryOpData_UOpData_IsValid(int value);

constexpr UnaryOpData_UOpData UnaryOpData_UOpData_UOpData_MIN = UnaryOpData_UOpData_SIZE;

constexpr UnaryOpData_UOpData UnaryOpData_UOpData_UOpData_MAX = UnaryOpData_UOpData_OFFSET;

constexpr int UnaryOpData_UOpData_UOpData_ARRAYSIZE = UnaryOpData_UOpData_UOpData_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* UnaryOpData_UOpData_descriptor();

template<typename T>

inline const std::string& UnaryOpData_UOpData_Name(T enum_t_value) {

  static_assert(::std::is_same<T, UnaryOpData_UOpData>::value ||

    ::std::is_integral<T>::value,

    "Incorrect type passed to function UnaryOpData_UOpData_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    UnaryOpData_UOpData_descriptor(), enum_t_value);

}

inline bool UnaryOpData_UOpData_Parse(

    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, UnaryOpData_UOpData* value) {

  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<UnaryOpData_UOpData>(

    UnaryOpData_UOpData_descriptor(), name, value);

}

enum TernaryOp_TOp : int {

  TernaryOp_TOp_ADDM = 0,

  TernaryOp_TOp_MULM = 1

};

bool TernaryOp_TOp_IsValid(int value);

constexpr TernaryOp_TOp TernaryOp_TOp_TOp_MIN = TernaryOp_TOp_ADDM;

constexpr TernaryOp_TOp TernaryOp_TOp_TOp_MAX = TernaryOp_TOp_MULM;

constexpr int TernaryOp_TOp_TOp_ARRAYSIZE = TernaryOp_TOp_TOp_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TernaryOp_TOp_descriptor();

template<typename T>

inline const std::string& TernaryOp_TOp_Name(T enum_t_value) {

  static_assert(::std::is_same<T, TernaryOp_TOp>::value ||

    ::std::is_integral<T>::value,

    "Incorrect type passed to function TernaryOp_TOp_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    TernaryOp_TOp_descriptor(), enum_t_value);

}

inline bool TernaryOp_TOp_Parse(

    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TernaryOp_TOp* value) {

  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<TernaryOp_TOp>(

    TernaryOp_TOp_descriptor(), name, value);

}

enum CopyFunc_CopyType : int {

  CopyFunc_CopyType_CALLDATA = 0,

  CopyFunc_CopyType_CODE = 1,

  CopyFunc_CopyType_RETURNDATA = 2,

  CopyFunc_CopyType_DATA = 3,

  CopyFunc_CopyType_MEMORY = 4

};

bool CopyFunc_CopyType_IsValid(int value);

constexpr CopyFunc_CopyType CopyFunc_CopyType_CopyType_MIN = CopyFunc_CopyType_CALLDATA;

constexpr CopyFunc_CopyType CopyFunc_CopyType_CopyType_MAX = CopyFunc_CopyType_MEMORY;

constexpr int CopyFunc_CopyType_CopyType_ARRAYSIZE = CopyFunc_CopyType_CopyType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CopyFunc_CopyType_descriptor();

template<typename T>

inline const std::string& CopyFunc_CopyType_Name(T enum_t_value) {

  static_assert(::std::is_same<T, CopyFunc_CopyType>::value ||

    ::std::is_integral<T>::value,

    "Incorrect type passed to function CopyFunc_CopyType_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    CopyFunc_CopyType_descriptor(), enum_t_value);

}

inline bool CopyFunc_CopyType_Parse(

    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CopyFunc_CopyType* value) {

  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<CopyFunc_CopyType>(

    CopyFunc_CopyType_descriptor(), name, value);

}

enum NullaryOp_NOp : int {

  NullaryOp_NOp_MSIZE = 1,

  NullaryOp_NOp_GAS = 2,

  NullaryOp_NOp_CALLDATASIZE = 3,

  NullaryOp_NOp_CODESIZE = 4,

  NullaryOp_NOp_RETURNDATASIZE = 5,

  NullaryOp_NOp_ADDRESS = 6,

  NullaryOp_NOp_ORIGIN = 7,

  NullaryOp_NOp_CALLER = 8,

  NullaryOp_NOp_CALLVALUE = 9,

  NullaryOp_NOp_GASPRICE = 10,

  NullaryOp_NOp_COINBASE = 11,

  NullaryOp_NOp_TIMESTAMP = 12,

  NullaryOp_NOp_NUMBER = 13,

  NullaryOp_NOp_DIFFICULTY = 14,

  NullaryOp_NOp_GASLIMIT = 15,

  NullaryOp_NOp_SELFBALANCE = 16,

  NullaryOp_NOp_CHAINID = 17,

  NullaryOp_NOp_BASEFEE = 18,

  NullaryOp_NOp_BLOBBASEFEE = 19,

  NullaryOp_NOp_SLOTNUM = 20

};

bool NullaryOp_NOp_IsValid(int value);

constexpr NullaryOp_NOp NullaryOp_NOp_NOp_MIN = NullaryOp_NOp_MSIZE;

constexpr NullaryOp_NOp NullaryOp_NOp_NOp_MAX = NullaryOp_NOp_SLOTNUM;

constexpr int NullaryOp_NOp_NOp_ARRAYSIZE = NullaryOp_NOp_NOp_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* NullaryOp_NOp_descriptor();

template<typename T>

inline const std::string& NullaryOp_NOp_Name(T enum_t_value) {

  static_assert(::std::is_same<T, NullaryOp_NOp>::value ||

    ::std::is_integral<T>::value,

    "Incorrect type passed to function NullaryOp_NOp_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    NullaryOp_NOp_descriptor(), enum_t_value);

}

inline bool NullaryOp_NOp_Parse(

    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, NullaryOp_NOp* value) {

  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<NullaryOp_NOp>(

    NullaryOp_NOp_descriptor(), name, value);

}

enum StoreFunc_Storage : int {

  StoreFunc_Storage_MSTORE = 0,

  StoreFunc_Storage_SSTORE = 1,

  StoreFunc_Storage_MSTORE8 = 2,

  StoreFunc_Storage_TSTORE = 3

};

bool StoreFunc_Storage_IsValid(int value);

constexpr StoreFunc_Storage StoreFunc_Storage_Storage_MIN = StoreFunc_Storage_MSTORE;

constexpr StoreFunc_Storage StoreFunc_Storage_Storage_MAX = StoreFunc_Storage_TSTORE;

constexpr int StoreFunc_Storage_Storage_ARRAYSIZE = StoreFunc_Storage_Storage_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* StoreFunc_Storage_descriptor();

template<typename T>

inline const std::string& StoreFunc_Storage_Name(T enum_t_value) {

  static_assert(::std::is_same<T, StoreFunc_Storage>::value ||

    ::std::is_integral<T>::value,

    "Incorrect type passed to function StoreFunc_Storage_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    StoreFunc_Storage_descriptor(), enum_t_value);

}

inline bool StoreFunc_Storage_Parse(

    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StoreFunc_Storage* value) {

  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<StoreFunc_Storage>(

    StoreFunc_Storage_descriptor(), name, value);

}

enum LogFunc_NumTopics : int {

  LogFunc_NumTopics_ZERO = 0,

  LogFunc_NumTopics_ONE = 1,

  LogFunc_NumTopics_TWO = 2,

  LogFunc_NumTopics_THREE = 3,

  LogFunc_NumTopics_FOUR = 4

};

bool LogFunc_NumTopics_IsValid(int value);

constexpr LogFunc_NumTopics LogFunc_NumTopics_NumTopics_MIN = LogFunc_NumTopics_ZERO;

constexpr LogFunc_NumTopics LogFunc_NumTopics_NumTopics_MAX = LogFunc_NumTopics_FOUR;

constexpr int LogFunc_NumTopics_NumTopics_ARRAYSIZE = LogFunc_NumTopics_NumTopics_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LogFunc_NumTopics_descriptor();

template<typename T>

inline const std::string& LogFunc_NumTopics_Name(T enum_t_value) {

  static_assert(::std::is_same<T, LogFunc_NumTopics>::value ||

    ::std::is_integral<T>::value,

    "Incorrect type passed to function LogFunc_NumTopics_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    LogFunc_NumTopics_descriptor(), enum_t_value);

}

inline bool LogFunc_NumTopics_Parse(

    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LogFunc_NumTopics* value) {

  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<LogFunc_NumTopics>(

    LogFunc_NumTopics_descriptor(), name, value);

}

enum StopInvalidStmt_Type : int {

  StopInvalidStmt_Type_STOP = 0,

  StopInvalidStmt_Type_INVALID = 1

};

bool StopInvalidStmt_Type_IsValid(int value);

constexpr StopInvalidStmt_Type StopInvalidStmt_Type_Type_MIN = StopInvalidStmt_Type_STOP;

constexpr StopInvalidStmt_Type StopInvalidStmt_Type_Type_MAX = StopInvalidStmt_Type_INVALID;

constexpr int StopInvalidStmt_Type_Type_ARRAYSIZE = StopInvalidStmt_Type_Type_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* StopInvalidStmt_Type_descriptor();

template<typename T>

inline const std::string& StopInvalidStmt_Type_Name(T enum_t_value) {

  static_assert(::std::is_same<T, StopInvalidStmt_Type>::value ||

    ::std::is_integral<T>::value,

    "Incorrect type passed to function StopInvalidStmt_Type_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    StopInvalidStmt_Type_descriptor(), enum_t_value);

}

inline bool StopInvalidStmt_Type_Parse(

    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StopInvalidStmt_Type* value) {

  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<StopInvalidStmt_Type>(

    StopInvalidStmt_Type_descriptor(), name, value);

}

enum RetRevStmt_Type : int {

  RetRevStmt_Type_RETURN = 0,

  RetRevStmt_Type_REVERT = 1

};

bool RetRevStmt_Type_IsValid(int value);

constexpr RetRevStmt_Type RetRevStmt_Type_Type_MIN = RetRevStmt_Type_RETURN;

constexpr RetRevStmt_Type RetRevStmt_Type_Type_MAX = RetRevStmt_Type_REVERT;

constexpr int RetRevStmt_Type_Type_ARRAYSIZE = RetRevStmt_Type_Type_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* RetRevStmt_Type_descriptor();

template<typename T>

inline const std::string& RetRevStmt_Type_Name(T enum_t_value) {

  static_assert(::std::is_same<T, RetRevStmt_Type>::value ||

    ::std::is_integral<T>::value,

    "Incorrect type passed to function RetRevStmt_Type_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    RetRevStmt_Type_descriptor(), enum_t_value);

}

inline bool RetRevStmt_Type_Parse(

    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, RetRevStmt_Type* value) {

  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<RetRevStmt_Type>(

    RetRevStmt_Type_descriptor(), name, value);

}

enum Program_Version : int {

  Program_Version_HOMESTEAD = 0,

  Program_Version_TANGERINE = 1,

  Program_Version_SPURIOUS = 2,

  Program_Version_BYZANTIUM = 3,

  Program_Version_CONSTANTINOPLE = 4,

  Program_Version_PETERSBURG = 5,

  Program_Version_ISTANBUL = 6,

  Program_Version_BERLIN = 7,

  Program_Version_LONDON = 8,

  Program_Version_PARIS = 9,

  Program_Version_SHANGHAI = 10,

  Program_Version_CANCUN = 11,

  Program_Version_PRAGUE = 12,

  Program_Version_OSAKA = 13,

  Program_Version_AMSTERDAM = 14

};

bool Program_Version_IsValid(int value);

constexpr Program_Version Program_Version_Version_MIN = Program_Version_HOMESTEAD;

constexpr Program_Version Program_Version_Version_MAX = Program_Version_AMSTERDAM;

constexpr int Program_Version_Version_ARRAYSIZE = Program_Version_Version_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Program_Version_descriptor();

template<typename T>

inline const std::string& Program_Version_Name(T enum_t_value) {

  static_assert(::std::is_same<T, Program_Version>::value ||

    ::std::is_integral<T>::value,

    "Incorrect type passed to function Program_Version_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    Program_Version_descriptor(), enum_t_value);

}

inline bool Program_Version_Parse(

    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Program_Version* value) {

  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Program_Version>(

    Program_Version_descriptor(), name, value);

}

// ===================================================================

class VarDecl final :

    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:solidity.yul.test.yul_fuzzer.VarDecl) */ {

 public:

  inline VarDecl() : VarDecl(nullptr) {}

  ~VarDecl() override;

  explicit PROTOBUF_CONSTEXPR VarDecl(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  VarDecl(const VarDecl& from);

  VarDecl(VarDecl&& from) noexcept

    : VarDecl() {

    *this = ::std::move(from);

  }

  inline VarDecl& operator=(const VarDecl& from) {

    CopyFrom(from);

    return *this;

  }

  inline VarDecl& operator=(VarDecl&& from) noexcept {

    if (this == &from) return *this;

    if (GetOwningArena() == from.GetOwningArena()

  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE

        && GetOwningArena() != nullptr

  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE

    ) {

      InternalSwap(&from);

    } else {

      CopyFrom(from);

    }

    return *this;

  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {

    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);

  }

  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {

    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();

  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {

    return GetDescriptor();

  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {

    return default_instance().GetMetadata().descriptor;

  }

  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {

    return default_instance().GetMetadata().reflection;

  }

  static const VarDecl& default_instance() {

    return *internal_default_instance();

  }

  static inline const VarDecl* internal_default_instance() {

    return reinterpret_cast<const VarDecl*>(

               &_VarDecl_default_instance_);

  }

  static constexpr int kIndexInFileMessages =

    0;

  friend void swap(VarDecl& a, VarDecl& b) {

    a.Swap(&b);

  }

  inline void Swap(VarDecl* other) {

    if (other == this) return;

  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP

    if (GetOwningArena() != nullptr &&

        GetOwningArena() == other->GetOwningArena()) {

   #else  // PROTOBUF_FORCE_COPY_IN_SWAP

    if (GetOwningArena() == other->GetOwningArena()) {

  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP

      InternalSwap(other);

    } else {

      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);

    }

  }

  void UnsafeArenaSwap(VarDecl* other) {

    if (other == this) return;

    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());

    InternalSwap(other);

  }

  // implements Message ----------------------------------------------

  VarDecl* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {

    return CreateMaybeMessage<VarDecl>(arena);

  }

  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;

  void CopyFrom(const VarDecl& from);

  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;

  void MergeFrom( const VarDecl& from) {

    VarDecl::MergeImpl(*this, from);

  }

  private:

  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);

  public:

  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;

  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;

  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;

  uint8_t* _InternalSerialize(

      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;

  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:

  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);

  void SharedDtor();

  void SetCachedSize(int size) const final;

  void InternalSwap(VarDecl* other);

  private:

  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;

  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {

    return "solidity.yul.test.yul_fuzzer.VarDecl";

  }

  protected:

  explicit VarDecl(::PROTOBUF_NAMESPACE_ID::Arena* arena,

                       bool is_message_owned = false);

  public:

  static const ClassData _class_data_;

  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {

    kExprFieldNumber = 1,

  };

  // required .solidity.yul.test.yul_fuzzer.Expression expr = 1;

  bool has_expr() const;

  private:

  bool _internal_has_expr() const;

  public:

  void clear_expr();

  const ::solidity::yul::test::yul_fuzzer::Expression& expr() const;

  PROTOBUF_NODISCARD ::solidity::yul::test::yul_fuzzer::Expression* release_expr();

  ::solidity::yul::test::yul_fuzzer::Expression* mutable_expr();

  void set_allocated_expr(::solidity::yul::test::yul_fuzzer::Expression* expr);

  private:

  const ::solidity::yul::test::yul_fuzzer::Expression& _internal_expr() const;

  ::solidity::yul::test::yul_fuzzer::Expression* _internal_mutable_expr();

  public:

  void unsafe_arena_set_allocated_expr(

      ::solidity::yul::test::yul_fuzzer::Expression* expr);

  ::solidity::yul::test::yul_fuzzer::Expression* unsafe_arena_release_expr();

  // @@protoc_insertion_point(class_scope:solidity.yul.test.yul_fuzzer.VarDecl)

 private:

  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;

  typedef void InternalArenaConstructable_;

  typedef void DestructorSkippable_;

  struct Impl_ {

    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;

    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;

    ::solidity::yul::test::yul_fuzzer::Expression* expr_;

  };

  union { Impl_ _impl_; };

  friend struct ::TableStruct_yulProto_2eproto;

};

// -------------------------------------------------------------------

class MultiVarDecl final :

    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:solidity.yul.test.yul_fuzzer.MultiVarDecl) */ {

 public:

  inline MultiVarDecl() : MultiVarDecl(nullptr) {}

  ~MultiVarDecl() override;

  explicit PROTOBUF_CONSTEXPR MultiVarDecl(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  MultiVarDecl(const MultiVarDecl& from);

  MultiVarDecl(MultiVarDecl&& from) noexcept

    : MultiVarDecl() {

    *this = ::std::move(from);

  }

  inline MultiVarDecl& operator=(const MultiVarDecl& from) {

    CopyFrom(from);

    return *this;

  }

  inline MultiVarDecl& operator=(MultiVarDecl&& from) noexcept {

    if (this == &from) return *this;

    if (GetOwningArena() == from.GetOwningArena()

  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE

        && GetOwningArena() != nullptr

  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE

    ) {

      InternalSwap(&from);

    } else {

      CopyFrom(from);

    }

    return *this;

  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {

    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);

  }

  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {

    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();

  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {

    return GetDescriptor();

  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {

    return default_instance().GetMetadata().descriptor;

  }

  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {

    return default_instance().GetMetadata().reflection;

  }

  static const MultiVarDecl& default_instance() {

    return *internal_default_instance();

  }

  static inline const MultiVarDecl* internal_default_instance() {

    return reinterpret_cast<const MultiVarDecl*>(

               &_MultiVarDecl_default_instance_);

  }

  static constexpr int kIndexInFileMessages =

    1;

  friend void swap(MultiVarDecl& a, MultiVarDecl& b) {

    a.Swap(&b);

  }

  inline void Swap(MultiVarDecl* other) {

    if (other == this) return;

  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP

    if (GetOwningArena() != nullptr &&

        GetOwningArena() == other->GetOwningArena()) {

   #else  // PROTOBUF_FORCE_COPY_IN_SWAP

    if (GetOwningArena() == other->GetOwningArena()) {

  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP

      InternalSwap(other);

    } else {

      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);

    }

  }

  void UnsafeArenaSwap(MultiVarDecl* other) {

    if (other == this) return;

    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());

    InternalSwap(other);

  }

  // implements Message ----------------------------------------------

  MultiVarDecl* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {

    return CreateMaybeMessage<MultiVarDecl>(arena);

  }

  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;

  void CopyFrom(const MultiVarDecl& from);

  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;

  void MergeFrom( const MultiVarDecl& from) {

    MultiVarDecl::MergeImpl(*this, from);

  }

  private:

  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);

  public:

  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;

  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;

  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;

  uint8_t* _InternalSerialize(

      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;

  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:

  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);

  void SharedDtor();

  void SetCachedSize(int size) const final;

  void InternalSwap(MultiVarDecl* other);

  private:

  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;

  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {

    return "solidity.yul.test.yul_fuzzer.MultiVarDecl";

  }

  protected:

  explicit MultiVarDecl(::PROTOBUF_NAMESPACE_ID::Arena* arena,

                       bool is_message_owned = false);

  public:

  static const ClassData _class_data_;

  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {

    kNumVarsFieldNumber = 1,

  };

  // required uint32 num_vars = 1;

  bool has_num_vars() const;

  private:

  bool _internal_has_num_vars() const;

  public:

  void clear_num_vars();

  uint32_t num_vars() const;

  void set_num_vars(uint32_t value);

  private:

  uint32_t _internal_num_vars() const;

  void _internal_set_num_vars(uint32_t value);

  public:

  // @@protoc_insertion_point(class_scope:solidity.yul.test.yul_fuzzer.MultiVarDecl)

 private:

  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;

  typedef void InternalArenaConstructable_;

  typedef void DestructorSkippable_;

  struct Impl_ {

    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;

    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;

    uint32_t num_vars_;

  };

  union { Impl_ _impl_; };

  friend struct ::TableStruct_yulProto_2eproto;

};

// -------------------------------------------------------------------

class LowLevelCall final :

    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:solidity.yul.test.yul_fuzzer.LowLevelCall) */ {

 public:

  inline LowLevelCall() : LowLevelCall(nullptr) {}

  ~LowLevelCall() override;

  explicit PROTOBUF_CONSTEXPR LowLevelCall(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  LowLevelCall(const LowLevelCall& from);

  LowLevelCall(LowLevelCall&& from) noexcept

    : LowLevelCall() {

    *this = ::std::move(from);

  }

  inline LowLevelCall& operator=(const LowLevelCall& from) {

    CopyFrom(from);

    return *this;

  }

  inline LowLevelCall& operator=(LowLevelCall&& from) noexcept {

    if (this == &from) return *this;

    if (GetOwningArena() == from.GetOwningArena()

  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE

        && GetOwningArena() != nullptr

  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE

    ) {

      InternalSwap(&from);

    } else {

      CopyFrom(from);

    }

    return *this;

  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {

    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);

  }

  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {

    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();

  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {

    return GetDescriptor();

  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {

    return default_instance().GetMetadata().descriptor;

  }

  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {

    return default_instance().GetMetadata().reflection;

  }

  static const LowLevelCall& default_instance() {

    return *internal_default_instance();

  }

  static inline const LowLevelCall* internal_default_instance() {

    return reinterpret_cast<const LowLevelCall*>(

               &_LowLevelCall_default_instance_);

  }

  static constexpr int kIndexInFileMessages =

    2;

  friend void swap(LowLevelCall& a, LowLevelCall& b) {

    a.Swap(&b);

  }

  inline void Swap(LowLevelCall* other) {

    if (other == this) return;

  #ifdef PROTOBUF_FORCE_COPY_IN_SWAP

    if (GetOwningArena() != nullptr &&

        GetOwningArena() == other->GetOwningArena()) {

   #else  // PROTOBUF_FORCE_COPY_IN_SWAP

    if (GetOwningArena() == other->GetOwningArena()) {

  #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP

      InternalSwap(other);

    } else {

      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);

    }

  }

  void UnsafeArenaSwap(LowLevelCall* other) {

    if (other == this) return;

    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());

    InternalSwap(other);

  }

  // implements Message ----------------------------------------------