// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: Execution.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_Execution_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_Execution_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3012000
#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 3012004 < 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_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/inlined_string_field.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/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_Execution_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_Execution_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[1]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_Execution_2eproto;
namespace protobuf {
class Execution;
class ExecutionDefaultTypeInternal;
extern ExecutionDefaultTypeInternal _Execution_default_instance_;
}  // namespace protobuf
PROTOBUF_NAMESPACE_OPEN
template<> ::protobuf::Execution* Arena::CreateMaybeMessage<::protobuf::Execution>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace protobuf {

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

class Execution PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:protobuf.Execution) */ {
 public:
  inline Execution() : Execution(nullptr) {};
  virtual ~Execution();

  Execution(const Execution& from);
  Execution(Execution&& from) noexcept
    : Execution() {
    *this = ::std::move(from);
  }

  inline Execution& operator=(const Execution& from) {
    CopyFrom(from);
    return *this;
  }
  inline Execution& operator=(Execution&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const Execution& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const Execution* internal_default_instance() {
    return reinterpret_cast<const Execution*>(
               &_Execution_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(Execution& a, Execution& b) {
    a.Swap(&b);
  }
  inline void Swap(Execution* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Execution* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline Execution* New() const final {
    return CreateMaybeMessage<Execution>(nullptr);
  }

  Execution* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Execution>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Execution& from);
  void MergeFrom(const Execution& from);
  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;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Execution* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "protobuf.Execution";
  }
  protected:
  explicit Execution(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_Execution_2eproto);
    return ::descriptor_table_Execution_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kExecIdFieldNumber = 2,
    kTimeFieldNumber = 3,
    kAcctNumberFieldNumber = 4,
    kExchangeFieldNumber = 5,
    kSideFieldNumber = 6,
    kSharesFieldNumber = 7,
    kCumQtyFieldNumber = 12,
    kOrderRefFieldNumber = 14,
    kEvRuleFieldNumber = 15,
    kModelCodeFieldNumber = 17,
    kSubmitterFieldNumber = 20,
    kOrderIdFieldNumber = 1,
    kClientIdFieldNumber = 10,
    kPriceFieldNumber = 8,
    kPermIdFieldNumber = 9,
    kAvgPriceFieldNumber = 13,
    kEvMultiplierFieldNumber = 16,
    kIsLiquidationFieldNumber = 11,
    kIsPriceRevisionPendingFieldNumber = 19,
    kLastLiquidityFieldNumber = 18,
    kOptExerciseOrLapseTypeFieldNumber = 21,
  };
  // string execId = 2;
  bool has_execid() const;
  private:
  bool _internal_has_execid() const;
  public:
  void clear_execid();
  const std::string& execid() const;
  void set_execid(const std::string& value);
  void set_execid(std::string&& value);
  void set_execid(const char* value);
  void set_execid(const char* value, size_t size);
  std::string* mutable_execid();
  std::string* release_execid();
  void set_allocated_execid(std::string* execid);
  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  std::string* unsafe_arena_release_execid();
  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_execid(
      std::string* execid);
  private:
  const std::string& _internal_execid() const;
  void _internal_set_execid(const std::string& value);
  std::string* _internal_mutable_execid();
  public:

  // string time = 3;
  bool has_time() const;
  private:
  bool _internal_has_time() const;
  public:
  void clear_time();
  const std::string& time() const;
  void set_time(const std::string& value);
  void set_time(std::string&& value);
  void set_time(const char* value);
  void set_time(const char* value, size_t size);
  std::string* mutable_time();
  std::string* release_time();
  void set_allocated_time(std::string* time);
  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  std::string* unsafe_arena_release_time();
  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_time(
      std::string* time);
  private:
  const std::string& _internal_time() const;
  void _internal_set_time(const std::string& value);
  std::string* _internal_mutable_time();
  public:

  // string acctNumber = 4;
  bool has_acctnumber() const;
  private:
  bool _internal_has_acctnumber() const;
  public:
  void clear_acctnumber();
  const std::string& acctnumber() const;
  void set_acctnumber(const std::string& value);
  void set_acctnumber(std::string&& value);
  void set_acctnumber(const char* value);
  void set_acctnumber(const char* value, size_t size);
  std::string* mutable_acctnumber();
  std::string* release_acctnumber();
  void set_allocated_acctnumber(std::string* acctnumber);
  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  std::string* unsafe_arena_release_acctnumber();
  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_acctnumber(
      std::string* acctnumber);
  private:
  const std::string& _internal_acctnumber() const;
  void _internal_set_acctnumber(const std::string& value);
  std::string* _internal_mutable_acctnumber();
  public:

  // string exchange = 5;
  bool has_exchange() const;
  private:
  bool _internal_has_exchange() const;
  public:
  void clear_exchange();
  const std::string& exchange() const;
  void set_exchange(const std::string& value);
  void set_exchange(std::string&& value);
  void set_exchange(const char* value);
  void set_exchange(const char* value, size_t size);
  std::string* mutable_exchange();
  std::string* release_exchange();
  void set_allocated_exchange(std::string* exchange);
  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  std::string* unsafe_arena_release_exchange();
  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_exchange(
      std::string* exchange);
  private:
  const std::string& _internal_exchange() const;
  void _internal_set_exchange(const std::string& value);
  std::string* _internal_mutable_exchange();
  public:

  // string side = 6;
  bool has_side() const;
  private:
  bool _internal_has_side() const;
  public:
  void clear_side();
  const std::string& side() const;
  void set_side(const std::string& value);
  void set_side(std::string&& value);
  void set_side(const char* value);
  void set_side(const char* value, size_t size);
  std::string* mutable_side();
  std::string* release_side();
  void set_allocated_side(std::string* side);
  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  std::string* unsafe_arena_release_side();
  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_side(
      std::string* side);
  private:
  const std::string& _internal_side() const;
  void _internal_set_side(const std::string& value);
  std::string* _internal_mutable_side();
  public:

  // string shares = 7;
  bool has_shares() const;
  private:
  bool _internal_has_shares() const;
  public:
  void clear_shares();
  const std::string& shares() const;
  void set_shares(const std::string& value);
  void set_shares(std::string&& value);
  void set_shares(const char* value);
  void set_shares(const char* value, size_t size);
  std::string* mutable_shares();
  std::string* release_shares();
  void set_allocated_shares(std::string* shares);
  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  std::string* unsafe_arena_release_shares();
  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_shares(
      std::string* shares);
  private:
  const std::string& _internal_shares() const;
  void _internal_set_shares(const std::string& value);
  std::string* _internal_mutable_shares();
  public:

  // string cumQty = 12;
  bool has_cumqty() const;
  private:
  bool _internal_has_cumqty() const;
  public:
  void clear_cumqty();
  const std::string& cumqty() const;
  void set_cumqty(const std::string& value);
  void set_cumqty(std::string&& value);
  void set_cumqty(const char* value);
  void set_cumqty(const char* value, size_t size);
  std::string* mutable_cumqty();
  std::string* release_cumqty();
  void set_allocated_cumqty(std::string* cumqty);
  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  std::string* unsafe_arena_release_cumqty();
  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_cumqty(
      std::string* cumqty);
  private:
  const std::string& _internal_cumqty() const;
  void _internal_set_cumqty(const std::string& value);
  std::string* _internal_mutable_cumqty();
  public:

  // string orderRef = 14;
  bool has_orderref() const;
  private:
  bool _internal_has_orderref() const;
  public:
  void clear_orderref();
  const std::string& orderref() const;
  void set_orderref(const std::string& value);
  void set_orderref(std::string&& value);
  void set_orderref(const char* value);
  void set_orderref(const char* value, size_t size);
  std::string* mutable_orderref();
  std::string* release_orderref();
  void set_allocated_orderref(std::string* orderref);
  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  std::string* unsafe_arena_release_orderref();
  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_orderref(
      std::string* orderref);
  private:
  const std::string& _internal_orderref() const;
  void _internal_set_orderref(const std::string& value);
  std::string* _internal_mutable_orderref();
  public:

  // string evRule = 15;
  bool has_evrule() const;
  private:
  bool _internal_has_evrule() const;
  public:
  void clear_evrule();
  const std::string& evrule() const;
  void set_evrule(const std::string& value);
  void set_evrule(std::string&& value);
  void set_evrule(const char* value);
  void set_evrule(const char* value, size_t size);
  std::string* mutable_evrule();
  std::string* release_evrule();
  void set_allocated_evrule(std::string* evrule);
  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  std::string* unsafe_arena_release_evrule();
  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_evrule(
      std::string* evrule);
  private:
  const std::string& _internal_evrule() const;
  void _internal_set_evrule(const std::string& value);
  std::string* _internal_mutable_evrule();
  public:

  // string modelCode = 17;
  bool has_modelcode() const;
  private:
  bool _internal_has_modelcode() const;
  public:
  void clear_modelcode();
  const std::string& modelcode() const;
  void set_modelcode(const std::string& value);
  void set_modelcode(std::string&& value);
  void set_modelcode(const char* value);
  void set_modelcode(const char* value, size_t size);
  std::string* mutable_modelcode();
  std::string* release_modelcode();
  void set_allocated_modelcode(std::string* modelcode);
  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  std::string* unsafe_arena_release_modelcode();
  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_modelcode(
      std::string* modelcode);
  private:
  const std::string& _internal_modelcode() const;
  void _internal_set_modelcode(const std::string& value);
  std::string* _internal_mutable_modelcode();
  public:

  // string submitter = 20;
  bool has_submitter() const;
  private:
  bool _internal_has_submitter() const;
  public:
  void clear_submitter();
  const std::string& submitter() const;
  void set_submitter(const std::string& value);
  void set_submitter(std::string&& value);
  void set_submitter(const char* value);
  void set_submitter(const char* value, size_t size);
  std::string* mutable_submitter();
  std::string* release_submitter();
  void set_allocated_submitter(std::string* submitter);
  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  std::string* unsafe_arena_release_submitter();
  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_submitter(
      std::string* submitter);
  private:
  const std::string& _internal_submitter() const;
  void _internal_set_submitter(const std::string& value);
  std::string* _internal_mutable_submitter();
  public:

  // int32 orderId = 1;
  bool has_orderid() const;
  private:
  bool _internal_has_orderid() const;
  public:
  void clear_orderid();
  ::PROTOBUF_NAMESPACE_ID::int32 orderid() const;
  void set_orderid(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_orderid() const;
  void _internal_set_orderid(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 clientId = 10;
  bool has_clientid() const;
  private:
  bool _internal_has_clientid() const;
  public:
  void clear_clientid();
  ::PROTOBUF_NAMESPACE_ID::int32 clientid() const;
  void set_clientid(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_clientid() const;
  void _internal_set_clientid(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // double price = 8;
  bool has_price() const;
  private:
  bool _internal_has_price() const;
  public:
  void clear_price();
  double price() const;
  void set_price(double value);
  private:
  double _internal_price() const;
  void _internal_set_price(double value);
  public:

  // int64 permId = 9;
  bool has_permid() const;
  private:
  bool _internal_has_permid() const;
  public:
  void clear_permid();
  ::PROTOBUF_NAMESPACE_ID::int64 permid() const;
  void set_permid(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_permid() const;
  void _internal_set_permid(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // double avgPrice = 13;
  bool has_avgprice() const;
  private:
  bool _internal_has_avgprice() const;
  public:
  void clear_avgprice();
  double avgprice() const;
  void set_avgprice(double value);
  private:
  double _internal_avgprice() const;
  void _internal_set_avgprice(double value);
  public:

  // double evMultiplier = 16;
  bool has_evmultiplier() const;
  private:
  bool _internal_has_evmultiplier() const;
  public:
  void clear_evmultiplier();
  double evmultiplier() const;
  void set_evmultiplier(double value);
  private:
  double _internal_evmultiplier() const;
  void _internal_set_evmultiplier(double value);
  public:

  // bool isLiquidation = 11;
  bool has_isliquidation() const;
  private:
  bool _internal_has_isliquidation() const;
  public:
  void clear_isliquidation();
  bool isliquidation() const;
  void set_isliquidation(bool value);
  private:
  bool _internal_isliquidation() const;
  void _internal_set_isliquidation(bool value);
  public:

  // bool isPriceRevisionPending = 19;
  bool has_ispricerevisionpending() const;
  private:
  bool _internal_has_ispricerevisionpending() const;
  public:
  void clear_ispricerevisionpending();
  bool ispricerevisionpending() const;
  void set_ispricerevisionpending(bool value);
  private:
  bool _internal_ispricerevisionpending() const;
  void _internal_set_ispricerevisionpending(bool value);
  public:

  // int32 lastLiquidity = 18;
  bool has_lastliquidity() const;
  private:
  bool _internal_has_lastliquidity() const;
  public:
  void clear_lastliquidity();
  ::PROTOBUF_NAMESPACE_ID::int32 lastliquidity() const;
  void set_lastliquidity(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_lastliquidity() const;
  void _internal_set_lastliquidity(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 optExerciseOrLapseType = 21;
  bool has_optexerciseorlapsetype() const;
  private:
  bool _internal_has_optexerciseorlapsetype() const;
  public:
  void clear_optexerciseorlapsetype();
  ::PROTOBUF_NAMESPACE_ID::int32 optexerciseorlapsetype() const;
  void set_optexerciseorlapsetype(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_optexerciseorlapsetype() const;
  void _internal_set_optexerciseorlapsetype(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // @@protoc_insertion_point(class_scope:protobuf.Execution)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr execid_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr time_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr acctnumber_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr exchange_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr side_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr shares_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr cumqty_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr orderref_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr evrule_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr modelcode_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr submitter_;
  ::PROTOBUF_NAMESPACE_ID::int32 orderid_;
  ::PROTOBUF_NAMESPACE_ID::int32 clientid_;
  double price_;
  ::PROTOBUF_NAMESPACE_ID::int64 permid_;
  double avgprice_;
  double evmultiplier_;
  bool isliquidation_;
  bool ispricerevisionpending_;
  ::PROTOBUF_NAMESPACE_ID::int32 lastliquidity_;
  ::PROTOBUF_NAMESPACE_ID::int32 optexerciseorlapsetype_;
  friend struct ::TableStruct_Execution_2eproto;
};
// ===================================================================


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

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// Execution

// int32 orderId = 1;
inline bool Execution::_internal_has_orderid() const {
  bool value = (_has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool Execution::has_orderid() const {
  return _internal_has_orderid();
}
inline void Execution::clear_orderid() {
  orderid_ = 0;
  _has_bits_[0] &= ~0x00000800u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Execution::_internal_orderid() const {
  return orderid_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Execution::orderid() const {
  // @@protoc_insertion_point(field_get:protobuf.Execution.orderId)
  return _internal_orderid();
}
inline void Execution::_internal_set_orderid(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00000800u;
  orderid_ = value;
}
inline void Execution::set_orderid(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_orderid(value);
  // @@protoc_insertion_point(field_set:protobuf.Execution.orderId)
}

// string execId = 2;
inline bool Execution::_internal_has_execid() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Execution::has_execid() const {
  return _internal_has_execid();
}
inline void Execution::clear_execid() {
  execid_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Execution::execid() const {
  // @@protoc_insertion_point(field_get:protobuf.Execution.execId)
  return _internal_execid();
}
inline void Execution::set_execid(const std::string& value) {
  _internal_set_execid(value);
  // @@protoc_insertion_point(field_set:protobuf.Execution.execId)
}
inline std::string* Execution::mutable_execid() {
  // @@protoc_insertion_point(field_mutable:protobuf.Execution.execId)
  return _internal_mutable_execid();
}
inline const std::string& Execution::_internal_execid() const {
  return execid_.Get();
}
inline void Execution::_internal_set_execid(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  execid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Execution::set_execid(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  execid_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Execution.execId)
}
inline void Execution::set_execid(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  execid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Execution.execId)
}
inline void Execution::set_execid(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  execid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Execution.execId)
}
inline std::string* Execution::_internal_mutable_execid() {
  _has_bits_[0] |= 0x00000001u;
  return execid_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Execution::release_execid() {
  // @@protoc_insertion_point(field_release:protobuf.Execution.execId)
  if (!_internal_has_execid()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return execid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Execution::set_allocated_execid(std::string* execid) {
  if (execid != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  execid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), execid,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Execution.execId)
}
inline std::string* Execution::unsafe_arena_release_execid() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Execution.execId)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00000001u;
  return execid_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Execution::unsafe_arena_set_allocated_execid(
    std::string* execid) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (execid != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  execid_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      execid, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Execution.execId)
}

// string time = 3;
inline bool Execution::_internal_has_time() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Execution::has_time() const {
  return _internal_has_time();
}
inline void Execution::clear_time() {
  time_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Execution::time() const {
  // @@protoc_insertion_point(field_get:protobuf.Execution.time)
  return _internal_time();
}
inline void Execution::set_time(const std::string& value) {
  _internal_set_time(value);
  // @@protoc_insertion_point(field_set:protobuf.Execution.time)
}
inline std::string* Execution::mutable_time() {
  // @@protoc_insertion_point(field_mutable:protobuf.Execution.time)
  return _internal_mutable_time();
}
inline const std::string& Execution::_internal_time() const {
  return time_.Get();
}
inline void Execution::_internal_set_time(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  time_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Execution::set_time(std::string&& value) {
  _has_bits_[0] |= 0x00000002u;
  time_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Execution.time)
}
inline void Execution::set_time(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000002u;
  time_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Execution.time)
}
inline void Execution::set_time(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000002u;
  time_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Execution.time)
}
inline std::string* Execution::_internal_mutable_time() {
  _has_bits_[0] |= 0x00000002u;
  return time_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Execution::release_time() {
  // @@protoc_insertion_point(field_release:protobuf.Execution.time)
  if (!_internal_has_time()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return time_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Execution::set_allocated_time(std::string* time) {
  if (time != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  time_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), time,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Execution.time)
}
inline std::string* Execution::unsafe_arena_release_time() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Execution.time)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00000002u;
  return time_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Execution::unsafe_arena_set_allocated_time(
    std::string* time) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (time != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  time_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      time, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Execution.time)
}

// string acctNumber = 4;
inline bool Execution::_internal_has_acctnumber() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Execution::has_acctnumber() const {
  return _internal_has_acctnumber();
}
inline void Execution::clear_acctnumber() {
  acctnumber_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000004u;
}
inline const std::string& Execution::acctnumber() const {
  // @@protoc_insertion_point(field_get:protobuf.Execution.acctNumber)
  return _internal_acctnumber();
}
inline void Execution::set_acctnumber(const std::string& value) {
  _internal_set_acctnumber(value);
  // @@protoc_insertion_point(field_set:protobuf.Execution.acctNumber)
}
inline std::string* Execution::mutable_acctnumber() {
  // @@protoc_insertion_point(field_mutable:protobuf.Execution.acctNumber)
  return _internal_mutable_acctnumber();
}
inline const std::string& Execution::_internal_acctnumber() const {
  return acctnumber_.Get();
}
inline void Execution::_internal_set_acctnumber(const std::string& value) {
  _has_bits_[0] |= 0x00000004u;
  acctnumber_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Execution::set_acctnumber(std::string&& value) {
  _has_bits_[0] |= 0x00000004u;
  acctnumber_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Execution.acctNumber)
}
inline void Execution::set_acctnumber(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000004u;
  acctnumber_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Execution.acctNumber)
}
inline void Execution::set_acctnumber(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000004u;
  acctnumber_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Execution.acctNumber)
}
inline std::string* Execution::_internal_mutable_acctnumber() {
  _has_bits_[0] |= 0x00000004u;
  return acctnumber_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Execution::release_acctnumber() {
  // @@protoc_insertion_point(field_release:protobuf.Execution.acctNumber)
  if (!_internal_has_acctnumber()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000004u;
  return acctnumber_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Execution::set_allocated_acctnumber(std::string* acctnumber) {
  if (acctnumber != nullptr) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  acctnumber_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), acctnumber,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Execution.acctNumber)
}
inline std::string* Execution::unsafe_arena_release_acctnumber() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Execution.acctNumber)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00000004u;
  return acctnumber_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Execution::unsafe_arena_set_allocated_acctnumber(
    std::string* acctnumber) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (acctnumber != nullptr) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  acctnumber_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      acctnumber, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Execution.acctNumber)
}

// string exchange = 5;
inline bool Execution::_internal_has_exchange() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Execution::has_exchange() const {
  return _internal_has_exchange();
}
inline void Execution::clear_exchange() {
  exchange_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000008u;
}
inline const std::string& Execution::exchange() const {
  // @@protoc_insertion_point(field_get:protobuf.Execution.exchange)
  return _internal_exchange();
}
inline void Execution::set_exchange(const std::string& value) {
  _internal_set_exchange(value);
  // @@protoc_insertion_point(field_set:protobuf.Execution.exchange)
}
inline std::string* Execution::mutable_exchange() {
  // @@protoc_insertion_point(field_mutable:protobuf.Execution.exchange)
  return _internal_mutable_exchange();
}
inline const std::string& Execution::_internal_exchange() const {
  return exchange_.Get();
}
inline void Execution::_internal_set_exchange(const std::string& value) {
  _has_bits_[0] |= 0x00000008u;
  exchange_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Execution::set_exchange(std::string&& value) {
  _has_bits_[0] |= 0x00000008u;
  exchange_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Execution.exchange)
}
inline void Execution::set_exchange(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000008u;
  exchange_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Execution.exchange)
}
inline void Execution::set_exchange(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000008u;
  exchange_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Execution.exchange)
}
inline std::string* Execution::_internal_mutable_exchange() {
  _has_bits_[0] |= 0x00000008u;
  return exchange_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Execution::release_exchange() {
  // @@protoc_insertion_point(field_release:protobuf.Execution.exchange)
  if (!_internal_has_exchange()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000008u;
  return exchange_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Execution::set_allocated_exchange(std::string* exchange) {
  if (exchange != nullptr) {
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  exchange_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), exchange,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Execution.exchange)
}
inline std::string* Execution::unsafe_arena_release_exchange() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Execution.exchange)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00000008u;
  return exchange_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Execution::unsafe_arena_set_allocated_exchange(
    std::string* exchange) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (exchange != nullptr) {
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  exchange_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      exchange, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Execution.exchange)
}

// string side = 6;
inline bool Execution::_internal_has_side() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool Execution::has_side() const {
  return _internal_has_side();
}
inline void Execution::clear_side() {
  side_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000010u;
}
inline const std::string& Execution::side() const {
  // @@protoc_insertion_point(field_get:protobuf.Execution.side)
  return _internal_side();
}
inline void Execution::set_side(const std::string& value) {
  _internal_set_side(value);
  // @@protoc_insertion_point(field_set:protobuf.Execution.side)
}
inline std::string* Execution::mutable_side() {
  // @@protoc_insertion_point(field_mutable:protobuf.Execution.side)
  return _internal_mutable_side();
}
inline const std::string& Execution::_internal_side() const {
  return side_.Get();
}
inline void Execution::_internal_set_side(const std::string& value) {
  _has_bits_[0] |= 0x00000010u;
  side_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Execution::set_side(std::string&& value) {
  _has_bits_[0] |= 0x00000010u;
  side_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Execution.side)
}
inline void Execution::set_side(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000010u;
  side_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Execution.side)
}
inline void Execution::set_side(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000010u;
  side_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Execution.side)
}
inline std::string* Execution::_internal_mutable_side() {
  _has_bits_[0] |= 0x00000010u;
  return side_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Execution::release_side() {
  // @@protoc_insertion_point(field_release:protobuf.Execution.side)
  if (!_internal_has_side()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000010u;
  return side_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Execution::set_allocated_side(std::string* side) {
  if (side != nullptr) {
    _has_bits_[0] |= 0x00000010u;
  } else {
    _has_bits_[0] &= ~0x00000010u;
  }
  side_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), side,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Execution.side)
}
inline std::string* Execution::unsafe_arena_release_side() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Execution.side)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00000010u;
  return side_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Execution::unsafe_arena_set_allocated_side(
    std::string* side) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (side != nullptr) {
    _has_bits_[0] |= 0x00000010u;
  } else {
    _has_bits_[0] &= ~0x00000010u;
  }
  side_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      side, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Execution.side)
}

// string shares = 7;
inline bool Execution::_internal_has_shares() const {
  bool value = (_has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool Execution::has_shares() const {
  return _internal_has_shares();
}
inline void Execution::clear_shares() {
  shares_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000020u;
}
inline const std::string& Execution::shares() const {
  // @@protoc_insertion_point(field_get:protobuf.Execution.shares)
  return _internal_shares();
}
inline void Execution::set_shares(const std::string& value) {
  _internal_set_shares(value);
  // @@protoc_insertion_point(field_set:protobuf.Execution.shares)
}
inline std::string* Execution::mutable_shares() {
  // @@protoc_insertion_point(field_mutable:protobuf.Execution.shares)
  return _internal_mutable_shares();
}
inline const std::string& Execution::_internal_shares() const {
  return shares_.Get();
}
inline void Execution::_internal_set_shares(const std::string& value) {
  _has_bits_[0] |= 0x00000020u;
  shares_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Execution::set_shares(std::string&& value) {
  _has_bits_[0] |= 0x00000020u;
  shares_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Execution.shares)
}
inline void Execution::set_shares(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000020u;
  shares_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Execution.shares)
}
inline void Execution::set_shares(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000020u;
  shares_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Execution.shares)
}
inline std::string* Execution::_internal_mutable_shares() {
  _has_bits_[0] |= 0x00000020u;
  return shares_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Execution::release_shares() {
  // @@protoc_insertion_point(field_release:protobuf.Execution.shares)
  if (!_internal_has_shares()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000020u;
  return shares_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Execution::set_allocated_shares(std::string* shares) {
  if (shares != nullptr) {
    _has_bits_[0] |= 0x00000020u;
  } else {
    _has_bits_[0] &= ~0x00000020u;
  }
  shares_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), shares,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Execution.shares)
}
inline std::string* Execution::unsafe_arena_release_shares() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Execution.shares)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00000020u;
  return shares_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Execution::unsafe_arena_set_allocated_shares(
    std::string* shares) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (shares != nullptr) {
    _has_bits_[0] |= 0x00000020u;
  } else {
    _has_bits_[0] &= ~0x00000020u;
  }
  shares_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      shares, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Execution.shares)
}

// double price = 8;
inline bool Execution::_internal_has_price() const {
  bool value = (_has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool Execution::has_price() const {
  return _internal_has_price();
}
inline void Execution::clear_price() {
  price_ = 0;
  _has_bits_[0] &= ~0x00002000u;
}
inline double Execution::_internal_price() const {
  return price_;
}
inline double Execution::price() const {
  // @@protoc_insertion_point(field_get:protobuf.Execution.price)
  return _internal_price();
}
inline void Execution::_internal_set_price(double value) {
  _has_bits_[0] |= 0x00002000u;
  price_ = value;
}
inline void Execution::set_price(double value) {
  _internal_set_price(value);
  // @@protoc_insertion_point(field_set:protobuf.Execution.price)
}

// int64 permId = 9;
inline bool Execution::_internal_has_permid() const {
  bool value = (_has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool Execution::has_permid() const {
  return _internal_has_permid();
}
inline void Execution::clear_permid() {
  permid_ = PROTOBUF_LONGLONG(0);
  _has_bits_[0] &= ~0x00004000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 Execution::_internal_permid() const {
  return permid_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 Execution::permid() const {
  // @@protoc_insertion_point(field_get:protobuf.Execution.permId)
  return _internal_permid();
}
inline void Execution::_internal_set_permid(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[0] |= 0x00004000u;
  permid_ = value;
}
inline void Execution::set_permid(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_permid(value);
  // @@protoc_insertion_point(field_set:protobuf.Execution.permId)
}

// int32 clientId = 10;
inline bool Execution::_internal_has_clientid() const {
  bool value = (_has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool Execution::has_clientid() const {
  return _internal_has_clientid();
}
inline void Execution::clear_clientid() {
  clientid_ = 0;
  _has_bits_[0] &= ~0x00001000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Execution::_internal_clientid() const {
  return clientid_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Execution::clientid() const {
  // @@protoc_insertion_point(field_get:protobuf.Execution.clientId)
  return _internal_clientid();
}
inline void Execution::_internal_set_clientid(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00001000u;
  clientid_ = value;
}
inline void Execution::set_clientid(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_clientid(value);
  // @@protoc_insertion_point(field_set:protobuf.Execution.clientId)
}

// bool isLiquidation = 11;
inline bool Execution::_internal_has_isliquidation() const {
  bool value = (_has_bits_[0] & 0x00020000u) != 0;
  return value;
}
inline bool Execution::has_isliquidation() const {
  return _internal_has_isliquidation();
}
inline void Execution::clear_isliquidation() {
  isliquidation_ = false;
  _has_bits_[0] &= ~0x00020000u;
}
inline bool Execution::_internal_isliquidation() const {
  return isliquidation_;
}
inline bool Execution::isliquidation() const {
  // @@protoc_insertion_point(field_get:protobuf.Execution.isLiquidation)
  return _internal_isliquidation();
}
inline void Execution::_internal_set_isliquidation(bool value) {
  _has_bits_[0] |= 0x00020000u;
  isliquidation_ = value;
}
inline void Execution::set_isliquidation(bool value) {
  _internal_set_isliquidation(value);
  // @@protoc_insertion_point(field_set:protobuf.Execution.isLiquidation)
}

// string cumQty = 12;
inline bool Execution::_internal_has_cumqty() const {
  bool value = (_has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool Execution::has_cumqty() const {
  return _internal_has_cumqty();
}
inline void Execution::clear_cumqty() {
  cumqty_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000040u;
}
inline const std::string& Execution::cumqty() const {
  // @@protoc_insertion_point(field_get:protobuf.Execution.cumQty)
  return _internal_cumqty();
}
inline void Execution::set_cumqty(const std::string& value) {
  _internal_set_cumqty(value);
  // @@protoc_insertion_point(field_set:protobuf.Execution.cumQty)
}
inline std::string* Execution::mutable_cumqty() {
  // @@protoc_insertion_point(field_mutable:protobuf.Execution.cumQty)
  return _internal_mutable_cumqty();
}
inline const std::string& Execution::_internal_cumqty() const {
  return cumqty_.Get();
}
inline void Execution::_internal_set_cumqty(const std::string& value) {
  _has_bits_[0] |= 0x00000040u;
  cumqty_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Execution::set_cumqty(std::string&& value) {
  _has_bits_[0] |= 0x00000040u;
  cumqty_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Execution.cumQty)
}
inline void Execution::set_cumqty(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000040u;
  cumqty_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Execution.cumQty)
}
inline void Execution::set_cumqty(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000040u;
  cumqty_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Execution.cumQty)
}
inline std::string* Execution::_internal_mutable_cumqty() {
  _has_bits_[0] |= 0x00000040u;
  return cumqty_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Execution::release_cumqty() {
  // @@protoc_insertion_point(field_release:protobuf.Execution.cumQty)
  if (!_internal_has_cumqty()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000040u;
  return cumqty_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Execution::set_allocated_cumqty(std::string* cumqty) {
  if (cumqty != nullptr) {
    _has_bits_[0] |= 0x00000040u;
  } else {
    _has_bits_[0] &= ~0x00000040u;
  }
  cumqty_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), cumqty,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Execution.cumQty)
}
inline std::string* Execution::unsafe_arena_release_cumqty() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Execution.cumQty)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00000040u;
  return cumqty_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Execution::unsafe_arena_set_allocated_cumqty(
    std::string* cumqty) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (cumqty != nullptr) {
    _has_bits_[0] |= 0x00000040u;
  } else {
    _has_bits_[0] &= ~0x00000040u;
  }
  cumqty_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      cumqty, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Execution.cumQty)
}

// double avgPrice = 13;
inline bool Execution::_internal_has_avgprice() const {
  bool value = (_has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline bool Execution::has_avgprice() const {
  return _internal_has_avgprice();
}
inline void Execution::clear_avgprice() {
  avgprice_ = 0;
  _has_bits_[0] &= ~0x00008000u;
}
inline double Execution::_internal_avgprice() const {
  return avgprice_;
}
inline double Execution::avgprice() const {
  // @@protoc_insertion_point(field_get:protobuf.Execution.avgPrice)
  return _internal_avgprice();
}
inline void Execution::_internal_set_avgprice(double value) {
  _has_bits_[0] |= 0x00008000u;
  avgprice_ = value;
}
inline void Execution::set_avgprice(double value) {
  _internal_set_avgprice(value);
  // @@protoc_insertion_point(field_set:protobuf.Execution.avgPrice)
}

// string orderRef = 14;
inline bool Execution::_internal_has_orderref() const {
  bool value = (_has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool Execution::has_orderref() const {
  return _internal_has_orderref();
}
inline void Execution::clear_orderref() {
  orderref_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000080u;
}
inline const std::string& Execution::orderref() const {
  // @@protoc_insertion_point(field_get:protobuf.Execution.orderRef)
  return _internal_orderref();
}
inline void Execution::set_orderref(const std::string& value) {
  _internal_set_orderref(value);
  // @@protoc_insertion_point(field_set:protobuf.Execution.orderRef)
}
inline std::string* Execution::mutable_orderref() {
  // @@protoc_insertion_point(field_mutable:protobuf.Execution.orderRef)
  return _internal_mutable_orderref();
}
inline const std::string& Execution::_internal_orderref() const {
  return orderref_.Get();
}
inline void Execution::_internal_set_orderref(const std::string& value) {
  _has_bits_[0] |= 0x00000080u;
  orderref_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Execution::set_orderref(std::string&& value) {
  _has_bits_[0] |= 0x00000080u;
  orderref_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Execution.orderRef)
}
inline void Execution::set_orderref(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000080u;
  orderref_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Execution.orderRef)
}
inline void Execution::set_orderref(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000080u;
  orderref_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Execution.orderRef)
}
inline std::string* Execution::_internal_mutable_orderref() {
  _has_bits_[0] |= 0x00000080u;
  return orderref_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Execution::release_orderref() {
  // @@protoc_insertion_point(field_release:protobuf.Execution.orderRef)
  if (!_internal_has_orderref()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000080u;
  return orderref_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Execution::set_allocated_orderref(std::string* orderref) {
  if (orderref != nullptr) {
    _has_bits_[0] |= 0x00000080u;
  } else {
    _has_bits_[0] &= ~0x00000080u;
  }
  orderref_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), orderref,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Execution.orderRef)
}
inline std::string* Execution::unsafe_arena_release_orderref() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Execution.orderRef)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00000080u;
  return orderref_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Execution::unsafe_arena_set_allocated_orderref(
    std::string* orderref) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (orderref != nullptr) {
    _has_bits_[0] |= 0x00000080u;
  } else {
    _has_bits_[0] &= ~0x00000080u;
  }
  orderref_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      orderref, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Execution.orderRef)
}

// string evRule = 15;
inline bool Execution::_internal_has_evrule() const {
  bool value = (_has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool Execution::has_evrule() const {
  return _internal_has_evrule();
}
inline void Execution::clear_evrule() {
  evrule_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000100u;
}
inline const std::string& Execution::evrule() const {
  // @@protoc_insertion_point(field_get:protobuf.Execution.evRule)
  return _internal_evrule();
}
inline void Execution::set_evrule(const std::string& value) {
  _internal_set_evrule(value);
  // @@protoc_insertion_point(field_set:protobuf.Execution.evRule)
}
inline std::string* Execution::mutable_evrule() {
  // @@protoc_insertion_point(field_mutable:protobuf.Execution.evRule)
  return _internal_mutable_evrule();
}
inline const std::string& Execution::_internal_evrule() const {
  return evrule_.Get();
}
inline void Execution::_internal_set_evrule(const std::string& value) {
  _has_bits_[0] |= 0x00000100u;
  evrule_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Execution::set_evrule(std::string&& value) {
  _has_bits_[0] |= 0x00000100u;
  evrule_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Execution.evRule)
}
inline void Execution::set_evrule(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000100u;
  evrule_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Execution.evRule)
}
inline void Execution::set_evrule(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000100u;
  evrule_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Execution.evRule)
}
inline std::string* Execution::_internal_mutable_evrule() {
  _has_bits_[0] |= 0x00000100u;
  return evrule_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Execution::release_evrule() {
  // @@protoc_insertion_point(field_release:protobuf.Execution.evRule)
  if (!_internal_has_evrule()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000100u;
  return evrule_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Execution::set_allocated_evrule(std::string* evrule) {
  if (evrule != nullptr) {
    _has_bits_[0] |= 0x00000100u;
  } else {
    _has_bits_[0] &= ~0x00000100u;
  }
  evrule_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), evrule,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Execution.evRule)
}
inline std::string* Execution::unsafe_arena_release_evrule() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Execution.evRule)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00000100u;
  return evrule_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Execution::unsafe_arena_set_allocated_evrule(
    std::string* evrule) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (evrule != nullptr) {
    _has_bits_[0] |= 0x00000100u;
  } else {
    _has_bits_[0] &= ~0x00000100u;
  }
  evrule_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      evrule, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Execution.evRule)
}

// double evMultiplier = 16;
inline bool Execution::_internal_has_evmultiplier() const {
  bool value = (_has_bits_[0] & 0x00010000u) != 0;
  return value;
}
inline bool Execution::has_evmultiplier() const {
  return _internal_has_evmultiplier();
}
inline void Execution::clear_evmultiplier() {
  evmultiplier_ = 0;
  _has_bits_[0] &= ~0x00010000u;
}
inline double Execution::_internal_evmultiplier() const {
  return evmultiplier_;
}
inline double Execution::evmultiplier() const {
  // @@protoc_insertion_point(field_get:protobuf.Execution.evMultiplier)
  return _internal_evmultiplier();
}
inline void Execution::_internal_set_evmultiplier(double value) {
  _has_bits_[0] |= 0x00010000u;
  evmultiplier_ = value;
}
inline void Execution::set_evmultiplier(double value) {
  _internal_set_evmultiplier(value);
  // @@protoc_insertion_point(field_set:protobuf.Execution.evMultiplier)
}

// string modelCode = 17;
inline bool Execution::_internal_has_modelcode() const {
  bool value = (_has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool Execution::has_modelcode() const {
  return _internal_has_modelcode();
}
inline void Execution::clear_modelcode() {
  modelcode_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000200u;
}
inline const std::string& Execution::modelcode() const {
  // @@protoc_insertion_point(field_get:protobuf.Execution.modelCode)
  return _internal_modelcode();
}
inline void Execution::set_modelcode(const std::string& value) {
  _internal_set_modelcode(value);
  // @@protoc_insertion_point(field_set:protobuf.Execution.modelCode)
}
inline std::string* Execution::mutable_modelcode() {
  // @@protoc_insertion_point(field_mutable:protobuf.Execution.modelCode)
  return _internal_mutable_modelcode();
}
inline const std::string& Execution::_internal_modelcode() const {
  return modelcode_.Get();
}
inline void Execution::_internal_set_modelcode(const std::string& value) {
  _has_bits_[0] |= 0x00000200u;
  modelcode_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Execution::set_modelcode(std::string&& value) {
  _has_bits_[0] |= 0x00000200u;
  modelcode_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Execution.modelCode)
}
inline void Execution::set_modelcode(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000200u;
  modelcode_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Execution.modelCode)
}
inline void Execution::set_modelcode(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000200u;
  modelcode_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Execution.modelCode)
}
inline std::string* Execution::_internal_mutable_modelcode() {
  _has_bits_[0] |= 0x00000200u;
  return modelcode_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Execution::release_modelcode() {
  // @@protoc_insertion_point(field_release:protobuf.Execution.modelCode)
  if (!_internal_has_modelcode()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000200u;
  return modelcode_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Execution::set_allocated_modelcode(std::string* modelcode) {
  if (modelcode != nullptr) {
    _has_bits_[0] |= 0x00000200u;
  } else {
    _has_bits_[0] &= ~0x00000200u;
  }
  modelcode_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), modelcode,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Execution.modelCode)
}
inline std::string* Execution::unsafe_arena_release_modelcode() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Execution.modelCode)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00000200u;
  return modelcode_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Execution::unsafe_arena_set_allocated_modelcode(
    std::string* modelcode) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (modelcode != nullptr) {
    _has_bits_[0] |= 0x00000200u;
  } else {
    _has_bits_[0] &= ~0x00000200u;
  }
  modelcode_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      modelcode, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Execution.modelCode)
}

// int32 lastLiquidity = 18;
inline bool Execution::_internal_has_lastliquidity() const {
  bool value = (_has_bits_[0] & 0x00080000u) != 0;
  return value;
}
inline bool Execution::has_lastliquidity() const {
  return _internal_has_lastliquidity();
}
inline void Execution::clear_lastliquidity() {
  lastliquidity_ = 0;
  _has_bits_[0] &= ~0x00080000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Execution::_internal_lastliquidity() const {
  return lastliquidity_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Execution::lastliquidity() const {
  // @@protoc_insertion_point(field_get:protobuf.Execution.lastLiquidity)
  return _internal_lastliquidity();
}
inline void Execution::_internal_set_lastliquidity(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00080000u;
  lastliquidity_ = value;
}
inline void Execution::set_lastliquidity(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_lastliquidity(value);
  // @@protoc_insertion_point(field_set:protobuf.Execution.lastLiquidity)
}

// bool isPriceRevisionPending = 19;
inline bool Execution::_internal_has_ispricerevisionpending() const {
  bool value = (_has_bits_[0] & 0x00040000u) != 0;
  return value;
}
inline bool Execution::has_ispricerevisionpending() const {
  return _internal_has_ispricerevisionpending();
}
inline void Execution::clear_ispricerevisionpending() {
  ispricerevisionpending_ = false;
  _has_bits_[0] &= ~0x00040000u;
}
inline bool Execution::_internal_ispricerevisionpending() const {
  return ispricerevisionpending_;
}
inline bool Execution::ispricerevisionpending() const {
  // @@protoc_insertion_point(field_get:protobuf.Execution.isPriceRevisionPending)
  return _internal_ispricerevisionpending();
}
inline void Execution::_internal_set_ispricerevisionpending(bool value) {
  _has_bits_[0] |= 0x00040000u;
  ispricerevisionpending_ = value;
}
inline void Execution::set_ispricerevisionpending(bool value) {
  _internal_set_ispricerevisionpending(value);
  // @@protoc_insertion_point(field_set:protobuf.Execution.isPriceRevisionPending)
}

// string submitter = 20;
inline bool Execution::_internal_has_submitter() const {
  bool value = (_has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool Execution::has_submitter() const {
  return _internal_has_submitter();
}
inline void Execution::clear_submitter() {
  submitter_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000400u;
}
inline const std::string& Execution::submitter() const {
  // @@protoc_insertion_point(field_get:protobuf.Execution.submitter)
  return _internal_submitter();
}
inline void Execution::set_submitter(const std::string& value) {
  _internal_set_submitter(value);
  // @@protoc_insertion_point(field_set:protobuf.Execution.submitter)
}
inline std::string* Execution::mutable_submitter() {
  // @@protoc_insertion_point(field_mutable:protobuf.Execution.submitter)
  return _internal_mutable_submitter();
}
inline const std::string& Execution::_internal_submitter() const {
  return submitter_.Get();
}
inline void Execution::_internal_set_submitter(const std::string& value) {
  _has_bits_[0] |= 0x00000400u;
  submitter_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Execution::set_submitter(std::string&& value) {
  _has_bits_[0] |= 0x00000400u;
  submitter_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Execution.submitter)
}
inline void Execution::set_submitter(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000400u;
  submitter_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Execution.submitter)
}
inline void Execution::set_submitter(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000400u;
  submitter_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Execution.submitter)
}
inline std::string* Execution::_internal_mutable_submitter() {
  _has_bits_[0] |= 0x00000400u;
  return submitter_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Execution::release_submitter() {
  // @@protoc_insertion_point(field_release:protobuf.Execution.submitter)
  if (!_internal_has_submitter()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000400u;
  return submitter_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Execution::set_allocated_submitter(std::string* submitter) {
  if (submitter != nullptr) {
    _has_bits_[0] |= 0x00000400u;
  } else {
    _has_bits_[0] &= ~0x00000400u;
  }
  submitter_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), submitter,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Execution.submitter)
}
inline std::string* Execution::unsafe_arena_release_submitter() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Execution.submitter)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00000400u;
  return submitter_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Execution::unsafe_arena_set_allocated_submitter(
    std::string* submitter) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (submitter != nullptr) {
    _has_bits_[0] |= 0x00000400u;
  } else {
    _has_bits_[0] &= ~0x00000400u;
  }
  submitter_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      submitter, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Execution.submitter)
}

// int32 optExerciseOrLapseType = 21;
inline bool Execution::_internal_has_optexerciseorlapsetype() const {
  bool value = (_has_bits_[0] & 0x00100000u) != 0;
  return value;
}
inline bool Execution::has_optexerciseorlapsetype() const {
  return _internal_has_optexerciseorlapsetype();
}
inline void Execution::clear_optexerciseorlapsetype() {
  optexerciseorlapsetype_ = 0;
  _has_bits_[0] &= ~0x00100000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Execution::_internal_optexerciseorlapsetype() const {
  return optexerciseorlapsetype_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Execution::optexerciseorlapsetype() const {
  // @@protoc_insertion_point(field_get:protobuf.Execution.optExerciseOrLapseType)
  return _internal_optexerciseorlapsetype();
}
inline void Execution::_internal_set_optexerciseorlapsetype(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00100000u;
  optexerciseorlapsetype_ = value;
}
inline void Execution::set_optexerciseorlapsetype(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_optexerciseorlapsetype(value);
  // @@protoc_insertion_point(field_set:protobuf.Execution.optExerciseOrLapseType)
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__

// @@protoc_insertion_point(namespace_scope)

}  // namespace protobuf

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_Execution_2eproto
