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

#ifndef GOOGLE_PROTOBUF_INCLUDED_Order_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_Order_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/map.h>  // IWYU pragma: export
#include <google/protobuf/map_entry.h>
#include <google/protobuf/map_field_inl.h>
#include <google/protobuf/unknown_field_set.h>
#include "OrderCondition.pb.h"
#include "SoftDollarTier.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_Order_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_Order_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[4]
    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_Order_2eproto;
namespace protobuf {
class Order;
class OrderDefaultTypeInternal;
extern OrderDefaultTypeInternal _Order_default_instance_;
class Order_AlgoParamsEntry_DoNotUse;
class Order_AlgoParamsEntry_DoNotUseDefaultTypeInternal;
extern Order_AlgoParamsEntry_DoNotUseDefaultTypeInternal _Order_AlgoParamsEntry_DoNotUse_default_instance_;
class Order_OrderMiscOptionsEntry_DoNotUse;
class Order_OrderMiscOptionsEntry_DoNotUseDefaultTypeInternal;
extern Order_OrderMiscOptionsEntry_DoNotUseDefaultTypeInternal _Order_OrderMiscOptionsEntry_DoNotUse_default_instance_;
class Order_SmartComboRoutingParamsEntry_DoNotUse;
class Order_SmartComboRoutingParamsEntry_DoNotUseDefaultTypeInternal;
extern Order_SmartComboRoutingParamsEntry_DoNotUseDefaultTypeInternal _Order_SmartComboRoutingParamsEntry_DoNotUse_default_instance_;
}  // namespace protobuf
PROTOBUF_NAMESPACE_OPEN
template<> ::protobuf::Order* Arena::CreateMaybeMessage<::protobuf::Order>(Arena*);
template<> ::protobuf::Order_AlgoParamsEntry_DoNotUse* Arena::CreateMaybeMessage<::protobuf::Order_AlgoParamsEntry_DoNotUse>(Arena*);
template<> ::protobuf::Order_OrderMiscOptionsEntry_DoNotUse* Arena::CreateMaybeMessage<::protobuf::Order_OrderMiscOptionsEntry_DoNotUse>(Arena*);
template<> ::protobuf::Order_SmartComboRoutingParamsEntry_DoNotUse* Arena::CreateMaybeMessage<::protobuf::Order_SmartComboRoutingParamsEntry_DoNotUse>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace protobuf {

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

class Order_AlgoParamsEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<Order_AlgoParamsEntry_DoNotUse, 
    std::string, std::string,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    0 > {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<Order_AlgoParamsEntry_DoNotUse, 
    std::string, std::string,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    0 > SuperType;
  Order_AlgoParamsEntry_DoNotUse();
  Order_AlgoParamsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const Order_AlgoParamsEntry_DoNotUse& other);
  static const Order_AlgoParamsEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const Order_AlgoParamsEntry_DoNotUse*>(&_Order_AlgoParamsEntry_DoNotUse_default_instance_); }
  static bool ValidateKey(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "protobuf.Order.AlgoParamsEntry.key");
 }
  static bool ValidateValue(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "protobuf.Order.AlgoParamsEntry.value");
 }
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& other) final;
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_Order_2eproto);
    return ::descriptor_table_Order_2eproto.file_level_metadata[0];
  }

  public:
};

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

class Order_SmartComboRoutingParamsEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<Order_SmartComboRoutingParamsEntry_DoNotUse, 
    std::string, std::string,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    0 > {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<Order_SmartComboRoutingParamsEntry_DoNotUse, 
    std::string, std::string,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    0 > SuperType;
  Order_SmartComboRoutingParamsEntry_DoNotUse();
  Order_SmartComboRoutingParamsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const Order_SmartComboRoutingParamsEntry_DoNotUse& other);
  static const Order_SmartComboRoutingParamsEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const Order_SmartComboRoutingParamsEntry_DoNotUse*>(&_Order_SmartComboRoutingParamsEntry_DoNotUse_default_instance_); }
  static bool ValidateKey(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "protobuf.Order.SmartComboRoutingParamsEntry.key");
 }
  static bool ValidateValue(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "protobuf.Order.SmartComboRoutingParamsEntry.value");
 }
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& other) final;
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_Order_2eproto);
    return ::descriptor_table_Order_2eproto.file_level_metadata[1];
  }

  public:
};

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

class Order_OrderMiscOptionsEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<Order_OrderMiscOptionsEntry_DoNotUse, 
    std::string, std::string,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    0 > {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry<Order_OrderMiscOptionsEntry_DoNotUse, 
    std::string, std::string,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    0 > SuperType;
  Order_OrderMiscOptionsEntry_DoNotUse();
  Order_OrderMiscOptionsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const Order_OrderMiscOptionsEntry_DoNotUse& other);
  static const Order_OrderMiscOptionsEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const Order_OrderMiscOptionsEntry_DoNotUse*>(&_Order_OrderMiscOptionsEntry_DoNotUse_default_instance_); }
  static bool ValidateKey(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "protobuf.Order.OrderMiscOptionsEntry.key");
 }
  static bool ValidateValue(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "protobuf.Order.OrderMiscOptionsEntry.value");
 }
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& other) final;
  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_Order_2eproto);
    return ::descriptor_table_Order_2eproto.file_level_metadata[2];
  }

  public:
};

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

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

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

  inline Order& operator=(const Order& from) {
    CopyFrom(from);
    return *this;
  }
  inline Order& operator=(Order&& 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 Order& default_instance();

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

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

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

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

  Order* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Order>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Order& from);
  void MergeFrom(const Order& 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(Order* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "protobuf.Order";
  }
  protected:
  explicit Order(::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_Order_2eproto);
    return ::descriptor_table_Order_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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


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

  enum : int {
    kAlgoParamsFieldNumber = 62,
    kSmartComboRoutingParamsFieldNumber = 64,
    kOrderMiscOptionsFieldNumber = 84,
    kConditionsFieldNumber = 100,
    kActionFieldNumber = 5,
    kTotalQuantityFieldNumber = 6,
    kOrderTypeFieldNumber = 8,
    kTifFieldNumber = 11,
    kAccountFieldNumber = 12,
    kSettlingFirmFieldNumber = 13,
    kClearingAccountFieldNumber = 14,
    kClearingIntentFieldNumber = 15,
    kGoodAfterTimeFieldNumber = 25,
    kGoodTillDateFieldNumber = 26,
    kOcaGroupFieldNumber = 27,
    kOrderRefFieldNumber = 28,
    kRule80AFieldNumber = 29,
    kActiveStartTimeFieldNumber = 32,
    kActiveStopTimeFieldNumber = 33,
    kFaGroupFieldNumber = 34,
    kFaMethodFieldNumber = 35,
    kFaPercentageFieldNumber = 36,
    kDeltaNeutralOrderTypeFieldNumber = 41,
    kDeltaNeutralOpenCloseFieldNumber = 44,
    kDeltaNeutralDesignatedLocationFieldNumber = 47,
    kScaleTableFieldNumber = 58,
    kHedgeTypeFieldNumber = 59,
    kHedgeParamFieldNumber = 60,
    kAlgoStrategyFieldNumber = 61,
    kAlgoIdFieldNumber = 63,
    kOpenCloseFieldNumber = 68,
    kDesignatedLocationFieldNumber = 71,
    kDeltaNeutralSettlingFirmFieldNumber = 73,
    kDeltaNeutralClearingAccountFieldNumber = 74,
    kDeltaNeutralClearingIntentFieldNumber = 75,
    kReferenceExchangeIdFieldNumber = 92,
    kAdjustedOrderTypeFieldNumber = 93,
    kModelCodeFieldNumber = 103,
    kExtOperatorFieldNumber = 104,
    kMifid2DecisionMakerFieldNumber = 107,
    kMifid2DecisionAlgoFieldNumber = 108,
    kMifid2ExecutionTraderFieldNumber = 109,
    kMifid2ExecutionAlgoFieldNumber = 110,
    kAutoCancelDateFieldNumber = 114,
    kFilledQuantityFieldNumber = 115,
    kShareholderFieldNumber = 118,
    kAdvancedErrorOverrideFieldNumber = 125,
    kManualOrderTimeFieldNumber = 126,
    kCustomerAccountFieldNumber = 132,
    kBondAccruedInterestFieldNumber = 134,
    kSubmitterFieldNumber = 137,
    kSoftDollarTierFieldNumber = 105,
    kClientIdFieldNumber = 1,
    kOrderIdFieldNumber = 2,
    kPermIdFieldNumber = 3,
    kParentIdFieldNumber = 4,
    kDisplaySizeFieldNumber = 7,
    kLmtPriceFieldNumber = 9,
    kAuxPriceFieldNumber = 10,
    kAllOrNoneFieldNumber = 16,
    kBlockOrderFieldNumber = 17,
    kHiddenFieldNumber = 18,
    kOutsideRthFieldNumber = 19,
    kMinQtyFieldNumber = 24,
    kPercentOffsetFieldNumber = 21,
    kTrailingPercentFieldNumber = 22,
    kTrailStopPriceFieldNumber = 23,
    kOcaTypeFieldNumber = 30,
    kTriggerMethodFieldNumber = 31,
    kVolatilityFieldNumber = 37,
    kVolatilityTypeFieldNumber = 38,
    kSweepToFillFieldNumber = 20,
    kContinuousUpdateFieldNumber = 39,
    kDeltaNeutralShortSaleFieldNumber = 45,
    kScaleAutoResetFieldNumber = 54,
    kReferencePriceTypeFieldNumber = 40,
    kDeltaNeutralConIdFieldNumber = 43,
    kDeltaNeutralAuxPriceFieldNumber = 42,
    kDeltaNeutralShortSaleSlotFieldNumber = 46,
    kScaleInitLevelSizeFieldNumber = 48,
    kScalePriceIncrementFieldNumber = 50,
    kScaleSubsLevelSizeFieldNumber = 49,
    kScalePriceAdjustIntervalFieldNumber = 52,
    kScalePriceAdjustValueFieldNumber = 51,
    kScaleProfitOffsetFieldNumber = 53,
    kScaleInitPositionFieldNumber = 55,
    kScaleInitFillQtyFieldNumber = 56,
    kScaleRandomPercentFieldNumber = 57,
    kWhatIfFieldNumber = 65,
    kTransmitFieldNumber = 66,
    kOverridePercentageConstraintsFieldNumber = 67,
    kOriginFieldNumber = 69,
    kShortSaleSlotFieldNumber = 70,
    kExemptCodeFieldNumber = 72,
    kDiscretionaryAmtFieldNumber = 76,
    kStartingPriceFieldNumber = 78,
    kStockRefPriceFieldNumber = 79,
    kDeltaFieldNumber = 80,
    kStockRangeLowerFieldNumber = 81,
    kStockRangeUpperFieldNumber = 82,
    kOptOutSmartRoutingFieldNumber = 77,
    kNotHeldFieldNumber = 83,
    kSolicitedFieldNumber = 85,
    kRandomizeSizeFieldNumber = 86,
    kReferenceContractIdFieldNumber = 88,
    kPeggedChangeAmountFieldNumber = 89,
    kReferenceChangeAmountFieldNumber = 91,
    kTriggerPriceFieldNumber = 94,
    kAdjustedStopPriceFieldNumber = 95,
    kRandomizePriceFieldNumber = 87,
    kIsPeggedChangeAmountDecreaseFieldNumber = 90,
    kConditionsCancelOrderFieldNumber = 101,
    kConditionsIgnoreRthFieldNumber = 102,
    kAdjustableTrailingUnitFieldNumber = 98,
    kAdjustedStopLimitPriceFieldNumber = 96,
    kAdjustedTrailingAmountFieldNumber = 97,
    kLmtPriceOffsetFieldNumber = 99,
    kCashQtyFieldNumber = 106,
    kDontUseAutoPriceForHedgeFieldNumber = 111,
    kIsOmsContainerFieldNumber = 112,
    kDiscretionaryUpToLimitPriceFieldNumber = 113,
    kAutoCancelParentFieldNumber = 117,
    kRefFuturesConIdFieldNumber = 116,
    kParentPermIdFieldNumber = 121,
    kUsePriceMgmtAlgoFieldNumber = 122,
    kDurationFieldNumber = 123,
    kPostToAtsFieldNumber = 124,
    kImbalanceOnlyFieldNumber = 119,
    kRouteMarketableToBboFieldNumber = 120,
    kProfessionalCustomerFieldNumber = 133,
    kIncludeOvernightFieldNumber = 135,
    kMinTradeQtyFieldNumber = 127,
    kMinCompeteSizeFieldNumber = 128,
    kCompeteAgainstBestOffsetFieldNumber = 129,
    kMidOffsetAtWholeFieldNumber = 130,
    kMidOffsetAtHalfFieldNumber = 131,
    kManualOrderIndicatorFieldNumber = 136,
  };
  // map<string, string> algoParams = 62;
  int algoparams_size() const;
  private:
  int _internal_algoparams_size() const;
  public:
  void clear_algoparams();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
      _internal_algoparams() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
      _internal_mutable_algoparams();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
      algoparams() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
      mutable_algoparams();

  // map<string, string> smartComboRoutingParams = 64;
  int smartcomboroutingparams_size() const;
  private:
  int _internal_smartcomboroutingparams_size() const;
  public:
  void clear_smartcomboroutingparams();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
      _internal_smartcomboroutingparams() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
      _internal_mutable_smartcomboroutingparams();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
      smartcomboroutingparams() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
      mutable_smartcomboroutingparams();

  // map<string, string> orderMiscOptions = 84;
  int ordermiscoptions_size() const;
  private:
  int _internal_ordermiscoptions_size() const;
  public:
  void clear_ordermiscoptions();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
      _internal_ordermiscoptions() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
      _internal_mutable_ordermiscoptions();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
      ordermiscoptions() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
      mutable_ordermiscoptions();

  // repeated .protobuf.OrderCondition conditions = 100;
  int conditions_size() const;
  private:
  int _internal_conditions_size() const;
  public:
  void clear_conditions();
  ::protobuf::OrderCondition* mutable_conditions(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::protobuf::OrderCondition >*
      mutable_conditions();
  private:
  const ::protobuf::OrderCondition& _internal_conditions(int index) const;
  ::protobuf::OrderCondition* _internal_add_conditions();
  public:
  const ::protobuf::OrderCondition& conditions(int index) const;
  ::protobuf::OrderCondition* add_conditions();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::protobuf::OrderCondition >&
      conditions() const;

  // string action = 5;
  bool has_action() const;
  private:
  bool _internal_has_action() const;
  public:
  void clear_action();
  const std::string& action() const;
  void set_action(const std::string& value);
  void set_action(std::string&& value);
  void set_action(const char* value);
  void set_action(const char* value, size_t size);
  std::string* mutable_action();
  std::string* release_action();
  void set_allocated_action(std::string* action);
  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_action();
  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_action(
      std::string* action);
  private:
  const std::string& _internal_action() const;
  void _internal_set_action(const std::string& value);
  std::string* _internal_mutable_action();
  public:

  // string totalQuantity = 6;
  bool has_totalquantity() const;
  private:
  bool _internal_has_totalquantity() const;
  public:
  void clear_totalquantity();
  const std::string& totalquantity() const;
  void set_totalquantity(const std::string& value);
  void set_totalquantity(std::string&& value);
  void set_totalquantity(const char* value);
  void set_totalquantity(const char* value, size_t size);
  std::string* mutable_totalquantity();
  std::string* release_totalquantity();
  void set_allocated_totalquantity(std::string* totalquantity);
  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_totalquantity();
  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_totalquantity(
      std::string* totalquantity);
  private:
  const std::string& _internal_totalquantity() const;
  void _internal_set_totalquantity(const std::string& value);
  std::string* _internal_mutable_totalquantity();
  public:

  // string orderType = 8;
  bool has_ordertype() const;
  private:
  bool _internal_has_ordertype() const;
  public:
  void clear_ordertype();
  const std::string& ordertype() const;
  void set_ordertype(const std::string& value);
  void set_ordertype(std::string&& value);
  void set_ordertype(const char* value);
  void set_ordertype(const char* value, size_t size);
  std::string* mutable_ordertype();
  std::string* release_ordertype();
  void set_allocated_ordertype(std::string* ordertype);
  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_ordertype();
  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_ordertype(
      std::string* ordertype);
  private:
  const std::string& _internal_ordertype() const;
  void _internal_set_ordertype(const std::string& value);
  std::string* _internal_mutable_ordertype();
  public:

  // string tif = 11;
  bool has_tif() const;
  private:
  bool _internal_has_tif() const;
  public:
  void clear_tif();
  const std::string& tif() const;
  void set_tif(const std::string& value);
  void set_tif(std::string&& value);
  void set_tif(const char* value);
  void set_tif(const char* value, size_t size);
  std::string* mutable_tif();
  std::string* release_tif();
  void set_allocated_tif(std::string* tif);
  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_tif();
  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_tif(
      std::string* tif);
  private:
  const std::string& _internal_tif() const;
  void _internal_set_tif(const std::string& value);
  std::string* _internal_mutable_tif();
  public:

  // string account = 12;
  bool has_account() const;
  private:
  bool _internal_has_account() const;
  public:
  void clear_account();
  const std::string& account() const;
  void set_account(const std::string& value);
  void set_account(std::string&& value);
  void set_account(const char* value);
  void set_account(const char* value, size_t size);
  std::string* mutable_account();
  std::string* release_account();
  void set_allocated_account(std::string* account);
  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_account();
  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_account(
      std::string* account);
  private:
  const std::string& _internal_account() const;
  void _internal_set_account(const std::string& value);
  std::string* _internal_mutable_account();
  public:

  // string settlingFirm = 13;
  bool has_settlingfirm() const;
  private:
  bool _internal_has_settlingfirm() const;
  public:
  void clear_settlingfirm();
  const std::string& settlingfirm() const;
  void set_settlingfirm(const std::string& value);
  void set_settlingfirm(std::string&& value);
  void set_settlingfirm(const char* value);
  void set_settlingfirm(const char* value, size_t size);
  std::string* mutable_settlingfirm();
  std::string* release_settlingfirm();
  void set_allocated_settlingfirm(std::string* settlingfirm);
  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_settlingfirm();
  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_settlingfirm(
      std::string* settlingfirm);
  private:
  const std::string& _internal_settlingfirm() const;
  void _internal_set_settlingfirm(const std::string& value);
  std::string* _internal_mutable_settlingfirm();
  public:

  // string clearingAccount = 14;
  bool has_clearingaccount() const;
  private:
  bool _internal_has_clearingaccount() const;
  public:
  void clear_clearingaccount();
  const std::string& clearingaccount() const;
  void set_clearingaccount(const std::string& value);
  void set_clearingaccount(std::string&& value);
  void set_clearingaccount(const char* value);
  void set_clearingaccount(const char* value, size_t size);
  std::string* mutable_clearingaccount();
  std::string* release_clearingaccount();
  void set_allocated_clearingaccount(std::string* clearingaccount);
  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_clearingaccount();
  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_clearingaccount(
      std::string* clearingaccount);
  private:
  const std::string& _internal_clearingaccount() const;
  void _internal_set_clearingaccount(const std::string& value);
  std::string* _internal_mutable_clearingaccount();
  public:

  // string clearingIntent = 15;
  bool has_clearingintent() const;
  private:
  bool _internal_has_clearingintent() const;
  public:
  void clear_clearingintent();
  const std::string& clearingintent() const;
  void set_clearingintent(const std::string& value);
  void set_clearingintent(std::string&& value);
  void set_clearingintent(const char* value);
  void set_clearingintent(const char* value, size_t size);
  std::string* mutable_clearingintent();
  std::string* release_clearingintent();
  void set_allocated_clearingintent(std::string* clearingintent);
  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_clearingintent();
  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_clearingintent(
      std::string* clearingintent);
  private:
  const std::string& _internal_clearingintent() const;
  void _internal_set_clearingintent(const std::string& value);
  std::string* _internal_mutable_clearingintent();
  public:

  // string goodAfterTime = 25;
  bool has_goodaftertime() const;
  private:
  bool _internal_has_goodaftertime() const;
  public:
  void clear_goodaftertime();
  const std::string& goodaftertime() const;
  void set_goodaftertime(const std::string& value);
  void set_goodaftertime(std::string&& value);
  void set_goodaftertime(const char* value);
  void set_goodaftertime(const char* value, size_t size);
  std::string* mutable_goodaftertime();
  std::string* release_goodaftertime();
  void set_allocated_goodaftertime(std::string* goodaftertime);
  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_goodaftertime();
  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_goodaftertime(
      std::string* goodaftertime);
  private:
  const std::string& _internal_goodaftertime() const;
  void _internal_set_goodaftertime(const std::string& value);
  std::string* _internal_mutable_goodaftertime();
  public:

  // string goodTillDate = 26;
  bool has_goodtilldate() const;
  private:
  bool _internal_has_goodtilldate() const;
  public:
  void clear_goodtilldate();
  const std::string& goodtilldate() const;
  void set_goodtilldate(const std::string& value);
  void set_goodtilldate(std::string&& value);
  void set_goodtilldate(const char* value);
  void set_goodtilldate(const char* value, size_t size);
  std::string* mutable_goodtilldate();
  std::string* release_goodtilldate();
  void set_allocated_goodtilldate(std::string* goodtilldate);
  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_goodtilldate();
  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_goodtilldate(
      std::string* goodtilldate);
  private:
  const std::string& _internal_goodtilldate() const;
  void _internal_set_goodtilldate(const std::string& value);
  std::string* _internal_mutable_goodtilldate();
  public:

  // string ocaGroup = 27;
  bool has_ocagroup() const;
  private:
  bool _internal_has_ocagroup() const;
  public:
  void clear_ocagroup();
  const std::string& ocagroup() const;
  void set_ocagroup(const std::string& value);
  void set_ocagroup(std::string&& value);
  void set_ocagroup(const char* value);
  void set_ocagroup(const char* value, size_t size);
  std::string* mutable_ocagroup();
  std::string* release_ocagroup();
  void set_allocated_ocagroup(std::string* ocagroup);
  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_ocagroup();
  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_ocagroup(
      std::string* ocagroup);
  private:
  const std::string& _internal_ocagroup() const;
  void _internal_set_ocagroup(const std::string& value);
  std::string* _internal_mutable_ocagroup();
  public:

  // string orderRef = 28;
  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 rule80A = 29;
  bool has_rule80a() const;
  private:
  bool _internal_has_rule80a() const;
  public:
  void clear_rule80a();
  const std::string& rule80a() const;
  void set_rule80a(const std::string& value);
  void set_rule80a(std::string&& value);
  void set_rule80a(const char* value);
  void set_rule80a(const char* value, size_t size);
  std::string* mutable_rule80a();
  std::string* release_rule80a();
  void set_allocated_rule80a(std::string* rule80a);
  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_rule80a();
  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_rule80a(
      std::string* rule80a);
  private:
  const std::string& _internal_rule80a() const;
  void _internal_set_rule80a(const std::string& value);
  std::string* _internal_mutable_rule80a();
  public:

  // string activeStartTime = 32;
  bool has_activestarttime() const;
  private:
  bool _internal_has_activestarttime() const;
  public:
  void clear_activestarttime();
  const std::string& activestarttime() const;
  void set_activestarttime(const std::string& value);
  void set_activestarttime(std::string&& value);
  void set_activestarttime(const char* value);
  void set_activestarttime(const char* value, size_t size);
  std::string* mutable_activestarttime();
  std::string* release_activestarttime();
  void set_allocated_activestarttime(std::string* activestarttime);
  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_activestarttime();
  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_activestarttime(
      std::string* activestarttime);
  private:
  const std::string& _internal_activestarttime() const;
  void _internal_set_activestarttime(const std::string& value);
  std::string* _internal_mutable_activestarttime();
  public:

  // string activeStopTime = 33;
  bool has_activestoptime() const;
  private:
  bool _internal_has_activestoptime() const;
  public:
  void clear_activestoptime();
  const std::string& activestoptime() const;
  void set_activestoptime(const std::string& value);
  void set_activestoptime(std::string&& value);
  void set_activestoptime(const char* value);
  void set_activestoptime(const char* value, size_t size);
  std::string* mutable_activestoptime();
  std::string* release_activestoptime();
  void set_allocated_activestoptime(std::string* activestoptime);
  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_activestoptime();
  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_activestoptime(
      std::string* activestoptime);
  private:
  const std::string& _internal_activestoptime() const;
  void _internal_set_activestoptime(const std::string& value);
  std::string* _internal_mutable_activestoptime();
  public:

  // string faGroup = 34;
  bool has_fagroup() const;
  private:
  bool _internal_has_fagroup() const;
  public:
  void clear_fagroup();
  const std::string& fagroup() const;
  void set_fagroup(const std::string& value);
  void set_fagroup(std::string&& value);
  void set_fagroup(const char* value);
  void set_fagroup(const char* value, size_t size);
  std::string* mutable_fagroup();
  std::string* release_fagroup();
  void set_allocated_fagroup(std::string* fagroup);
  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_fagroup();
  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_fagroup(
      std::string* fagroup);
  private:
  const std::string& _internal_fagroup() const;
  void _internal_set_fagroup(const std::string& value);
  std::string* _internal_mutable_fagroup();
  public:

  // string faMethod = 35;
  bool has_famethod() const;
  private:
  bool _internal_has_famethod() const;
  public:
  void clear_famethod();
  const std::string& famethod() const;
  void set_famethod(const std::string& value);
  void set_famethod(std::string&& value);
  void set_famethod(const char* value);
  void set_famethod(const char* value, size_t size);
  std::string* mutable_famethod();
  std::string* release_famethod();
  void set_allocated_famethod(std::string* famethod);
  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_famethod();
  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_famethod(
      std::string* famethod);
  private:
  const std::string& _internal_famethod() const;
  void _internal_set_famethod(const std::string& value);
  std::string* _internal_mutable_famethod();
  public:

  // string faPercentage = 36;
  bool has_fapercentage() const;
  private:
  bool _internal_has_fapercentage() const;
  public:
  void clear_fapercentage();
  const std::string& fapercentage() const;
  void set_fapercentage(const std::string& value);
  void set_fapercentage(std::string&& value);
  void set_fapercentage(const char* value);
  void set_fapercentage(const char* value, size_t size);
  std::string* mutable_fapercentage();
  std::string* release_fapercentage();
  void set_allocated_fapercentage(std::string* fapercentage);
  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_fapercentage();
  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_fapercentage(
      std::string* fapercentage);
  private:
  const std::string& _internal_fapercentage() const;
  void _internal_set_fapercentage(const std::string& value);
  std::string* _internal_mutable_fapercentage();
  public:

  // string deltaNeutralOrderType = 41;
  bool has_deltaneutralordertype() const;
  private:
  bool _internal_has_deltaneutralordertype() const;
  public:
  void clear_deltaneutralordertype();
  const std::string& deltaneutralordertype() const;
  void set_deltaneutralordertype(const std::string& value);
  void set_deltaneutralordertype(std::string&& value);
  void set_deltaneutralordertype(const char* value);
  void set_deltaneutralordertype(const char* value, size_t size);
  std::string* mutable_deltaneutralordertype();
  std::string* release_deltaneutralordertype();
  void set_allocated_deltaneutralordertype(std::string* deltaneutralordertype);
  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_deltaneutralordertype();
  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_deltaneutralordertype(
      std::string* deltaneutralordertype);
  private:
  const std::string& _internal_deltaneutralordertype() const;
  void _internal_set_deltaneutralordertype(const std::string& value);
  std::string* _internal_mutable_deltaneutralordertype();
  public:

  // string deltaNeutralOpenClose = 44;
  bool has_deltaneutralopenclose() const;
  private:
  bool _internal_has_deltaneutralopenclose() const;
  public:
  void clear_deltaneutralopenclose();
  const std::string& deltaneutralopenclose() const;
  void set_deltaneutralopenclose(const std::string& value);
  void set_deltaneutralopenclose(std::string&& value);
  void set_deltaneutralopenclose(const char* value);
  void set_deltaneutralopenclose(const char* value, size_t size);
  std::string* mutable_deltaneutralopenclose();
  std::string* release_deltaneutralopenclose();
  void set_allocated_deltaneutralopenclose(std::string* deltaneutralopenclose);
  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_deltaneutralopenclose();
  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_deltaneutralopenclose(
      std::string* deltaneutralopenclose);
  private:
  const std::string& _internal_deltaneutralopenclose() const;
  void _internal_set_deltaneutralopenclose(const std::string& value);
  std::string* _internal_mutable_deltaneutralopenclose();
  public:

  // string deltaNeutralDesignatedLocation = 47;
  bool has_deltaneutraldesignatedlocation() const;
  private:
  bool _internal_has_deltaneutraldesignatedlocation() const;
  public:
  void clear_deltaneutraldesignatedlocation();
  const std::string& deltaneutraldesignatedlocation() const;
  void set_deltaneutraldesignatedlocation(const std::string& value);
  void set_deltaneutraldesignatedlocation(std::string&& value);
  void set_deltaneutraldesignatedlocation(const char* value);
  void set_deltaneutraldesignatedlocation(const char* value, size_t size);
  std::string* mutable_deltaneutraldesignatedlocation();
  std::string* release_deltaneutraldesignatedlocation();
  void set_allocated_deltaneutraldesignatedlocation(std::string* deltaneutraldesignatedlocation);
  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_deltaneutraldesignatedlocation();
  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_deltaneutraldesignatedlocation(
      std::string* deltaneutraldesignatedlocation);
  private:
  const std::string& _internal_deltaneutraldesignatedlocation() const;
  void _internal_set_deltaneutraldesignatedlocation(const std::string& value);
  std::string* _internal_mutable_deltaneutraldesignatedlocation();
  public:

  // string scaleTable = 58;
  bool has_scaletable() const;
  private:
  bool _internal_has_scaletable() const;
  public:
  void clear_scaletable();
  const std::string& scaletable() const;
  void set_scaletable(const std::string& value);
  void set_scaletable(std::string&& value);
  void set_scaletable(const char* value);
  void set_scaletable(const char* value, size_t size);
  std::string* mutable_scaletable();
  std::string* release_scaletable();
  void set_allocated_scaletable(std::string* scaletable);
  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_scaletable();
  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_scaletable(
      std::string* scaletable);
  private:
  const std::string& _internal_scaletable() const;
  void _internal_set_scaletable(const std::string& value);
  std::string* _internal_mutable_scaletable();
  public:

  // string hedgeType = 59;
  bool has_hedgetype() const;
  private:
  bool _internal_has_hedgetype() const;
  public:
  void clear_hedgetype();
  const std::string& hedgetype() const;
  void set_hedgetype(const std::string& value);
  void set_hedgetype(std::string&& value);
  void set_hedgetype(const char* value);
  void set_hedgetype(const char* value, size_t size);
  std::string* mutable_hedgetype();
  std::string* release_hedgetype();
  void set_allocated_hedgetype(std::string* hedgetype);
  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_hedgetype();
  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_hedgetype(
      std::string* hedgetype);
  private:
  const std::string& _internal_hedgetype() const;
  void _internal_set_hedgetype(const std::string& value);
  std::string* _internal_mutable_hedgetype();
  public:

  // string hedgeParam = 60;
  bool has_hedgeparam() const;
  private:
  bool _internal_has_hedgeparam() const;
  public:
  void clear_hedgeparam();
  const std::string& hedgeparam() const;
  void set_hedgeparam(const std::string& value);
  void set_hedgeparam(std::string&& value);
  void set_hedgeparam(const char* value);
  void set_hedgeparam(const char* value, size_t size);
  std::string* mutable_hedgeparam();
  std::string* release_hedgeparam();
  void set_allocated_hedgeparam(std::string* hedgeparam);
  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_hedgeparam();
  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_hedgeparam(
      std::string* hedgeparam);
  private:
  const std::string& _internal_hedgeparam() const;
  void _internal_set_hedgeparam(const std::string& value);
  std::string* _internal_mutable_hedgeparam();
  public:

  // string algoStrategy = 61;
  bool has_algostrategy() const;
  private:
  bool _internal_has_algostrategy() const;
  public:
  void clear_algostrategy();
  const std::string& algostrategy() const;
  void set_algostrategy(const std::string& value);
  void set_algostrategy(std::string&& value);
  void set_algostrategy(const char* value);
  void set_algostrategy(const char* value, size_t size);
  std::string* mutable_algostrategy();
  std::string* release_algostrategy();
  void set_allocated_algostrategy(std::string* algostrategy);
  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_algostrategy();
  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_algostrategy(
      std::string* algostrategy);
  private:
  const std::string& _internal_algostrategy() const;
  void _internal_set_algostrategy(const std::string& value);
  std::string* _internal_mutable_algostrategy();
  public:

  // string algoId = 63;
  bool has_algoid() const;
  private:
  bool _internal_has_algoid() const;
  public:
  void clear_algoid();
  const std::string& algoid() const;
  void set_algoid(const std::string& value);
  void set_algoid(std::string&& value);
  void set_algoid(const char* value);
  void set_algoid(const char* value, size_t size);
  std::string* mutable_algoid();
  std::string* release_algoid();
  void set_allocated_algoid(std::string* algoid);
  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_algoid();
  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_algoid(
      std::string* algoid);
  private:
  const std::string& _internal_algoid() const;
  void _internal_set_algoid(const std::string& value);
  std::string* _internal_mutable_algoid();
  public:

  // string openClose = 68;
  bool has_openclose() const;
  private:
  bool _internal_has_openclose() const;
  public:
  void clear_openclose();
  const std::string& openclose() const;
  void set_openclose(const std::string& value);
  void set_openclose(std::string&& value);
  void set_openclose(const char* value);
  void set_openclose(const char* value, size_t size);
  std::string* mutable_openclose();
  std::string* release_openclose();
  void set_allocated_openclose(std::string* openclose);
  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_openclose();
  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_openclose(
      std::string* openclose);
  private:
  const std::string& _internal_openclose() const;
  void _internal_set_openclose(const std::string& value);
  std::string* _internal_mutable_openclose();
  public:

  // string designatedLocation = 71;
  bool has_designatedlocation() const;
  private:
  bool _internal_has_designatedlocation() const;
  public:
  void clear_designatedlocation();
  const std::string& designatedlocation() const;
  void set_designatedlocation(const std::string& value);
  void set_designatedlocation(std::string&& value);
  void set_designatedlocation(const char* value);
  void set_designatedlocation(const char* value, size_t size);
  std::string* mutable_designatedlocation();
  std::string* release_designatedlocation();
  void set_allocated_designatedlocation(std::string* designatedlocation);
  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_designatedlocation();
  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_designatedlocation(
      std::string* designatedlocation);
  private:
  const std::string& _internal_designatedlocation() const;
  void _internal_set_designatedlocation(const std::string& value);
  std::string* _internal_mutable_designatedlocation();
  public:

  // string deltaNeutralSettlingFirm = 73;
  bool has_deltaneutralsettlingfirm() const;
  private:
  bool _internal_has_deltaneutralsettlingfirm() const;
  public:
  void clear_deltaneutralsettlingfirm();
  const std::string& deltaneutralsettlingfirm() const;
  void set_deltaneutralsettlingfirm(const std::string& value);
  void set_deltaneutralsettlingfirm(std::string&& value);
  void set_deltaneutralsettlingfirm(const char* value);
  void set_deltaneutralsettlingfirm(const char* value, size_t size);
  std::string* mutable_deltaneutralsettlingfirm();
  std::string* release_deltaneutralsettlingfirm();
  void set_allocated_deltaneutralsettlingfirm(std::string* deltaneutralsettlingfirm);
  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_deltaneutralsettlingfirm();
  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_deltaneutralsettlingfirm(
      std::string* deltaneutralsettlingfirm);
  private:
  const std::string& _internal_deltaneutralsettlingfirm() const;
  void _internal_set_deltaneutralsettlingfirm(const std::string& value);
  std::string* _internal_mutable_deltaneutralsettlingfirm();
  public:

  // string deltaNeutralClearingAccount = 74;
  bool has_deltaneutralclearingaccount() const;
  private:
  bool _internal_has_deltaneutralclearingaccount() const;
  public:
  void clear_deltaneutralclearingaccount();
  const std::string& deltaneutralclearingaccount() const;
  void set_deltaneutralclearingaccount(const std::string& value);
  void set_deltaneutralclearingaccount(std::string&& value);
  void set_deltaneutralclearingaccount(const char* value);
  void set_deltaneutralclearingaccount(const char* value, size_t size);
  std::string* mutable_deltaneutralclearingaccount();
  std::string* release_deltaneutralclearingaccount();
  void set_allocated_deltaneutralclearingaccount(std::string* deltaneutralclearingaccount);
  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_deltaneutralclearingaccount();
  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_deltaneutralclearingaccount(
      std::string* deltaneutralclearingaccount);
  private:
  const std::string& _internal_deltaneutralclearingaccount() const;
  void _internal_set_deltaneutralclearingaccount(const std::string& value);
  std::string* _internal_mutable_deltaneutralclearingaccount();
  public:

  // string deltaNeutralClearingIntent = 75;
  bool has_deltaneutralclearingintent() const;
  private:
  bool _internal_has_deltaneutralclearingintent() const;
  public:
  void clear_deltaneutralclearingintent();
  const std::string& deltaneutralclearingintent() const;
  void set_deltaneutralclearingintent(const std::string& value);
  void set_deltaneutralclearingintent(std::string&& value);
  void set_deltaneutralclearingintent(const char* value);
  void set_deltaneutralclearingintent(const char* value, size_t size);
  std::string* mutable_deltaneutralclearingintent();
  std::string* release_deltaneutralclearingintent();
  void set_allocated_deltaneutralclearingintent(std::string* deltaneutralclearingintent);
  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_deltaneutralclearingintent();
  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_deltaneutralclearingintent(
      std::string* deltaneutralclearingintent);
  private:
  const std::string& _internal_deltaneutralclearingintent() const;
  void _internal_set_deltaneutralclearingintent(const std::string& value);
  std::string* _internal_mutable_deltaneutralclearingintent();
  public:

  // string referenceExchangeId = 92;
  bool has_referenceexchangeid() const;
  private:
  bool _internal_has_referenceexchangeid() const;
  public:
  void clear_referenceexchangeid();
  const std::string& referenceexchangeid() const;
  void set_referenceexchangeid(const std::string& value);
  void set_referenceexchangeid(std::string&& value);
  void set_referenceexchangeid(const char* value);
  void set_referenceexchangeid(const char* value, size_t size);
  std::string* mutable_referenceexchangeid();
  std::string* release_referenceexchangeid();
  void set_allocated_referenceexchangeid(std::string* referenceexchangeid);
  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_referenceexchangeid();
  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_referenceexchangeid(
      std::string* referenceexchangeid);
  private:
  const std::string& _internal_referenceexchangeid() const;
  void _internal_set_referenceexchangeid(const std::string& value);
  std::string* _internal_mutable_referenceexchangeid();
  public:

  // string adjustedOrderType = 93;
  bool has_adjustedordertype() const;
  private:
  bool _internal_has_adjustedordertype() const;
  public:
  void clear_adjustedordertype();
  const std::string& adjustedordertype() const;
  void set_adjustedordertype(const std::string& value);
  void set_adjustedordertype(std::string&& value);
  void set_adjustedordertype(const char* value);
  void set_adjustedordertype(const char* value, size_t size);
  std::string* mutable_adjustedordertype();
  std::string* release_adjustedordertype();
  void set_allocated_adjustedordertype(std::string* adjustedordertype);
  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_adjustedordertype();
  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_adjustedordertype(
      std::string* adjustedordertype);
  private:
  const std::string& _internal_adjustedordertype() const;
  void _internal_set_adjustedordertype(const std::string& value);
  std::string* _internal_mutable_adjustedordertype();
  public:

  // string modelCode = 103;
  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 extOperator = 104;
  bool has_extoperator() const;
  private:
  bool _internal_has_extoperator() const;
  public:
  void clear_extoperator();
  const std::string& extoperator() const;
  void set_extoperator(const std::string& value);
  void set_extoperator(std::string&& value);
  void set_extoperator(const char* value);
  void set_extoperator(const char* value, size_t size);
  std::string* mutable_extoperator();
  std::string* release_extoperator();
  void set_allocated_extoperator(std::string* extoperator);
  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_extoperator();
  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_extoperator(
      std::string* extoperator);
  private:
  const std::string& _internal_extoperator() const;
  void _internal_set_extoperator(const std::string& value);
  std::string* _internal_mutable_extoperator();
  public:

  // string mifid2DecisionMaker = 107;
  bool has_mifid2decisionmaker() const;
  private:
  bool _internal_has_mifid2decisionmaker() const;
  public:
  void clear_mifid2decisionmaker();
  const std::string& mifid2decisionmaker() const;
  void set_mifid2decisionmaker(const std::string& value);
  void set_mifid2decisionmaker(std::string&& value);
  void set_mifid2decisionmaker(const char* value);
  void set_mifid2decisionmaker(const char* value, size_t size);
  std::string* mutable_mifid2decisionmaker();
  std::string* release_mifid2decisionmaker();
  void set_allocated_mifid2decisionmaker(std::string* mifid2decisionmaker);
  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_mifid2decisionmaker();
  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_mifid2decisionmaker(
      std::string* mifid2decisionmaker);
  private:
  const std::string& _internal_mifid2decisionmaker() const;
  void _internal_set_mifid2decisionmaker(const std::string& value);
  std::string* _internal_mutable_mifid2decisionmaker();
  public:

  // string mifid2DecisionAlgo = 108;
  bool has_mifid2decisionalgo() const;
  private:
  bool _internal_has_mifid2decisionalgo() const;
  public:
  void clear_mifid2decisionalgo();
  const std::string& mifid2decisionalgo() const;
  void set_mifid2decisionalgo(const std::string& value);
  void set_mifid2decisionalgo(std::string&& value);
  void set_mifid2decisionalgo(const char* value);
  void set_mifid2decisionalgo(const char* value, size_t size);
  std::string* mutable_mifid2decisionalgo();
  std::string* release_mifid2decisionalgo();
  void set_allocated_mifid2decisionalgo(std::string* mifid2decisionalgo);
  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_mifid2decisionalgo();
  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_mifid2decisionalgo(
      std::string* mifid2decisionalgo);
  private:
  const std::string& _internal_mifid2decisionalgo() const;
  void _internal_set_mifid2decisionalgo(const std::string& value);
  std::string* _internal_mutable_mifid2decisionalgo();
  public:

  // string mifid2ExecutionTrader = 109;
  bool has_mifid2executiontrader() const;
  private:
  bool _internal_has_mifid2executiontrader() const;
  public:
  void clear_mifid2executiontrader();
  const std::string& mifid2executiontrader() const;
  void set_mifid2executiontrader(const std::string& value);
  void set_mifid2executiontrader(std::string&& value);
  void set_mifid2executiontrader(const char* value);
  void set_mifid2executiontrader(const char* value, size_t size);
  std::string* mutable_mifid2executiontrader();
  std::string* release_mifid2executiontrader();
  void set_allocated_mifid2executiontrader(std::string* mifid2executiontrader);
  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_mifid2executiontrader();
  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_mifid2executiontrader(
      std::string* mifid2executiontrader);
  private:
  const std::string& _internal_mifid2executiontrader() const;
  void _internal_set_mifid2executiontrader(const std::string& value);
  std::string* _internal_mutable_mifid2executiontrader();
  public:

  // string mifid2ExecutionAlgo = 110;
  bool has_mifid2executionalgo() const;
  private:
  bool _internal_has_mifid2executionalgo() const;
  public:
  void clear_mifid2executionalgo();
  const std::string& mifid2executionalgo() const;
  void set_mifid2executionalgo(const std::string& value);
  void set_mifid2executionalgo(std::string&& value);
  void set_mifid2executionalgo(const char* value);
  void set_mifid2executionalgo(const char* value, size_t size);
  std::string* mutable_mifid2executionalgo();
  std::string* release_mifid2executionalgo();
  void set_allocated_mifid2executionalgo(std::string* mifid2executionalgo);
  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_mifid2executionalgo();
  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_mifid2executionalgo(
      std::string* mifid2executionalgo);
  private:
  const std::string& _internal_mifid2executionalgo() const;
  void _internal_set_mifid2executionalgo(const std::string& value);
  std::string* _internal_mutable_mifid2executionalgo();
  public:

  // string autoCancelDate = 114;
  bool has_autocanceldate() const;
  private:
  bool _internal_has_autocanceldate() const;
  public:
  void clear_autocanceldate();
  const std::string& autocanceldate() const;
  void set_autocanceldate(const std::string& value);
  void set_autocanceldate(std::string&& value);
  void set_autocanceldate(const char* value);
  void set_autocanceldate(const char* value, size_t size);
  std::string* mutable_autocanceldate();
  std::string* release_autocanceldate();
  void set_allocated_autocanceldate(std::string* autocanceldate);
  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_autocanceldate();
  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_autocanceldate(
      std::string* autocanceldate);
  private:
  const std::string& _internal_autocanceldate() const;
  void _internal_set_autocanceldate(const std::string& value);
  std::string* _internal_mutable_autocanceldate();
  public:

  // string filledQuantity = 115;
  bool has_filledquantity() const;
  private:
  bool _internal_has_filledquantity() const;
  public:
  void clear_filledquantity();
  const std::string& filledquantity() const;
  void set_filledquantity(const std::string& value);
  void set_filledquantity(std::string&& value);
  void set_filledquantity(const char* value);
  void set_filledquantity(const char* value, size_t size);
  std::string* mutable_filledquantity();
  std::string* release_filledquantity();
  void set_allocated_filledquantity(std::string* filledquantity);
  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_filledquantity();
  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_filledquantity(
      std::string* filledquantity);
  private:
  const std::string& _internal_filledquantity() const;
  void _internal_set_filledquantity(const std::string& value);
  std::string* _internal_mutable_filledquantity();
  public:

  // string shareholder = 118;
  bool has_shareholder() const;
  private:
  bool _internal_has_shareholder() const;
  public:
  void clear_shareholder();
  const std::string& shareholder() const;
  void set_shareholder(const std::string& value);
  void set_shareholder(std::string&& value);
  void set_shareholder(const char* value);
  void set_shareholder(const char* value, size_t size);
  std::string* mutable_shareholder();
  std::string* release_shareholder();
  void set_allocated_shareholder(std::string* shareholder);
  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_shareholder();
  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_shareholder(
      std::string* shareholder);
  private:
  const std::string& _internal_shareholder() const;
  void _internal_set_shareholder(const std::string& value);
  std::string* _internal_mutable_shareholder();
  public:

  // string advancedErrorOverride = 125;
  bool has_advancederroroverride() const;
  private:
  bool _internal_has_advancederroroverride() const;
  public:
  void clear_advancederroroverride();
  const std::string& advancederroroverride() const;
  void set_advancederroroverride(const std::string& value);
  void set_advancederroroverride(std::string&& value);
  void set_advancederroroverride(const char* value);
  void set_advancederroroverride(const char* value, size_t size);
  std::string* mutable_advancederroroverride();
  std::string* release_advancederroroverride();
  void set_allocated_advancederroroverride(std::string* advancederroroverride);
  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_advancederroroverride();
  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_advancederroroverride(
      std::string* advancederroroverride);
  private:
  const std::string& _internal_advancederroroverride() const;
  void _internal_set_advancederroroverride(const std::string& value);
  std::string* _internal_mutable_advancederroroverride();
  public:

  // string manualOrderTime = 126;
  bool has_manualordertime() const;
  private:
  bool _internal_has_manualordertime() const;
  public:
  void clear_manualordertime();
  const std::string& manualordertime() const;
  void set_manualordertime(const std::string& value);
  void set_manualordertime(std::string&& value);
  void set_manualordertime(const char* value);
  void set_manualordertime(const char* value, size_t size);
  std::string* mutable_manualordertime();
  std::string* release_manualordertime();
  void set_allocated_manualordertime(std::string* manualordertime);
  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_manualordertime();
  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_manualordertime(
      std::string* manualordertime);
  private:
  const std::string& _internal_manualordertime() const;
  void _internal_set_manualordertime(const std::string& value);
  std::string* _internal_mutable_manualordertime();
  public:

  // string customerAccount = 132;
  bool has_customeraccount() const;
  private:
  bool _internal_has_customeraccount() const;
  public:
  void clear_customeraccount();
  const std::string& customeraccount() const;
  void set_customeraccount(const std::string& value);
  void set_customeraccount(std::string&& value);
  void set_customeraccount(const char* value);
  void set_customeraccount(const char* value, size_t size);
  std::string* mutable_customeraccount();
  std::string* release_customeraccount();
  void set_allocated_customeraccount(std::string* customeraccount);
  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_customeraccount();
  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_customeraccount(
      std::string* customeraccount);
  private:
  const std::string& _internal_customeraccount() const;
  void _internal_set_customeraccount(const std::string& value);
  std::string* _internal_mutable_customeraccount();
  public:

  // string bondAccruedInterest = 134;
  bool has_bondaccruedinterest() const;
  private:
  bool _internal_has_bondaccruedinterest() const;
  public:
  void clear_bondaccruedinterest();
  const std::string& bondaccruedinterest() const;
  void set_bondaccruedinterest(const std::string& value);
  void set_bondaccruedinterest(std::string&& value);
  void set_bondaccruedinterest(const char* value);
  void set_bondaccruedinterest(const char* value, size_t size);
  std::string* mutable_bondaccruedinterest();
  std::string* release_bondaccruedinterest();
  void set_allocated_bondaccruedinterest(std::string* bondaccruedinterest);
  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_bondaccruedinterest();
  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_bondaccruedinterest(
      std::string* bondaccruedinterest);
  private:
  const std::string& _internal_bondaccruedinterest() const;
  void _internal_set_bondaccruedinterest(const std::string& value);
  std::string* _internal_mutable_bondaccruedinterest();
  public:

  // string submitter = 137;
  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:

  // .protobuf.SoftDollarTier softDollarTier = 105;
  bool has_softdollartier() const;
  private:
  bool _internal_has_softdollartier() const;
  public:
  void clear_softdollartier();
  const ::protobuf::SoftDollarTier& softdollartier() const;
  ::protobuf::SoftDollarTier* release_softdollartier();
  ::protobuf::SoftDollarTier* mutable_softdollartier();
  void set_allocated_softdollartier(::protobuf::SoftDollarTier* softdollartier);
  private:
  const ::protobuf::SoftDollarTier& _internal_softdollartier() const;
  ::protobuf::SoftDollarTier* _internal_mutable_softdollartier();
  public:
  void unsafe_arena_set_allocated_softdollartier(
      ::protobuf::SoftDollarTier* softdollartier);
  ::protobuf::SoftDollarTier* unsafe_arena_release_softdollartier();

  // int32 clientId = 1;
  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:

  // int32 orderId = 2;
  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:

  // int64 permId = 3;
  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:

  // int32 parentId = 4;
  bool has_parentid() const;
  private:
  bool _internal_has_parentid() const;
  public:
  void clear_parentid();
  ::PROTOBUF_NAMESPACE_ID::int32 parentid() const;
  void set_parentid(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_parentid() const;
  void _internal_set_parentid(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 displaySize = 7;
  bool has_displaysize() const;
  private:
  bool _internal_has_displaysize() const;
  public:
  void clear_displaysize();
  ::PROTOBUF_NAMESPACE_ID::int32 displaysize() const;
  void set_displaysize(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_displaysize() const;
  void _internal_set_displaysize(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // double lmtPrice = 9;
  bool has_lmtprice() const;
  private:
  bool _internal_has_lmtprice() const;
  public:
  void clear_lmtprice();
  double lmtprice() const;
  void set_lmtprice(double value);
  private:
  double _internal_lmtprice() const;
  void _internal_set_lmtprice(double value);
  public:

  // double auxPrice = 10;
  bool has_auxprice() const;
  private:
  bool _internal_has_auxprice() const;
  public:
  void clear_auxprice();
  double auxprice() const;
  void set_auxprice(double value);
  private:
  double _internal_auxprice() const;
  void _internal_set_auxprice(double value);
  public:

  // bool allOrNone = 16;
  bool has_allornone() const;
  private:
  bool _internal_has_allornone() const;
  public:
  void clear_allornone();
  bool allornone() const;
  void set_allornone(bool value);
  private:
  bool _internal_allornone() const;
  void _internal_set_allornone(bool value);
  public:

  // bool blockOrder = 17;
  bool has_blockorder() const;
  private:
  bool _internal_has_blockorder() const;
  public:
  void clear_blockorder();
  bool blockorder() const;
  void set_blockorder(bool value);
  private:
  bool _internal_blockorder() const;
  void _internal_set_blockorder(bool value);
  public:

  // bool hidden = 18;
  bool has_hidden() const;
  private:
  bool _internal_has_hidden() const;
  public:
  void clear_hidden();
  bool hidden() const;
  void set_hidden(bool value);
  private:
  bool _internal_hidden() const;
  void _internal_set_hidden(bool value);
  public:

  // bool outsideRth = 19;
  bool has_outsiderth() const;
  private:
  bool _internal_has_outsiderth() const;
  public:
  void clear_outsiderth();
  bool outsiderth() const;
  void set_outsiderth(bool value);
  private:
  bool _internal_outsiderth() const;
  void _internal_set_outsiderth(bool value);
  public:

  // int32 minQty = 24;
  bool has_minqty() const;
  private:
  bool _internal_has_minqty() const;
  public:
  void clear_minqty();
  ::PROTOBUF_NAMESPACE_ID::int32 minqty() const;
  void set_minqty(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_minqty() const;
  void _internal_set_minqty(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // double percentOffset = 21;
  bool has_percentoffset() const;
  private:
  bool _internal_has_percentoffset() const;
  public:
  void clear_percentoffset();
  double percentoffset() const;
  void set_percentoffset(double value);
  private:
  double _internal_percentoffset() const;
  void _internal_set_percentoffset(double value);
  public:

  // double trailingPercent = 22;
  bool has_trailingpercent() const;
  private:
  bool _internal_has_trailingpercent() const;
  public:
  void clear_trailingpercent();
  double trailingpercent() const;
  void set_trailingpercent(double value);
  private:
  double _internal_trailingpercent() const;
  void _internal_set_trailingpercent(double value);
  public:

  // double trailStopPrice = 23;
  bool has_trailstopprice() const;
  private:
  bool _internal_has_trailstopprice() const;
  public:
  void clear_trailstopprice();
  double trailstopprice() const;
  void set_trailstopprice(double value);
  private:
  double _internal_trailstopprice() const;
  void _internal_set_trailstopprice(double value);
  public:

  // int32 ocaType = 30;
  bool has_ocatype() const;
  private:
  bool _internal_has_ocatype() const;
  public:
  void clear_ocatype();
  ::PROTOBUF_NAMESPACE_ID::int32 ocatype() const;
  void set_ocatype(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_ocatype() const;
  void _internal_set_ocatype(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 triggerMethod = 31;
  bool has_triggermethod() const;
  private:
  bool _internal_has_triggermethod() const;
  public:
  void clear_triggermethod();
  ::PROTOBUF_NAMESPACE_ID::int32 triggermethod() const;
  void set_triggermethod(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_triggermethod() const;
  void _internal_set_triggermethod(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // double volatility = 37;
  bool has_volatility() const;
  private:
  bool _internal_has_volatility() const;
  public:
  void clear_volatility();
  double volatility() const;
  void set_volatility(double value);
  private:
  double _internal_volatility() const;
  void _internal_set_volatility(double value);
  public:

  // int32 volatilityType = 38;
  bool has_volatilitytype() const;
  private:
  bool _internal_has_volatilitytype() const;
  public:
  void clear_volatilitytype();
  ::PROTOBUF_NAMESPACE_ID::int32 volatilitytype() const;
  void set_volatilitytype(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_volatilitytype() const;
  void _internal_set_volatilitytype(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // bool sweepToFill = 20;
  bool has_sweeptofill() const;
  private:
  bool _internal_has_sweeptofill() const;
  public:
  void clear_sweeptofill();
  bool sweeptofill() const;
  void set_sweeptofill(bool value);
  private:
  bool _internal_sweeptofill() const;
  void _internal_set_sweeptofill(bool value);
  public:

  // bool continuousUpdate = 39;
  bool has_continuousupdate() const;
  private:
  bool _internal_has_continuousupdate() const;
  public:
  void clear_continuousupdate();
  bool continuousupdate() const;
  void set_continuousupdate(bool value);
  private:
  bool _internal_continuousupdate() const;
  void _internal_set_continuousupdate(bool value);
  public:

  // bool deltaNeutralShortSale = 45;
  bool has_deltaneutralshortsale() const;
  private:
  bool _internal_has_deltaneutralshortsale() const;
  public:
  void clear_deltaneutralshortsale();
  bool deltaneutralshortsale() const;
  void set_deltaneutralshortsale(bool value);
  private:
  bool _internal_deltaneutralshortsale() const;
  void _internal_set_deltaneutralshortsale(bool value);
  public:

  // bool scaleAutoReset = 54;
  bool has_scaleautoreset() const;
  private:
  bool _internal_has_scaleautoreset() const;
  public:
  void clear_scaleautoreset();
  bool scaleautoreset() const;
  void set_scaleautoreset(bool value);
  private:
  bool _internal_scaleautoreset() const;
  void _internal_set_scaleautoreset(bool value);
  public:

  // int32 referencePriceType = 40;
  bool has_referencepricetype() const;
  private:
  bool _internal_has_referencepricetype() const;
  public:
  void clear_referencepricetype();
  ::PROTOBUF_NAMESPACE_ID::int32 referencepricetype() const;
  void set_referencepricetype(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_referencepricetype() const;
  void _internal_set_referencepricetype(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 deltaNeutralConId = 43;
  bool has_deltaneutralconid() const;
  private:
  bool _internal_has_deltaneutralconid() const;
  public:
  void clear_deltaneutralconid();
  ::PROTOBUF_NAMESPACE_ID::int32 deltaneutralconid() const;
  void set_deltaneutralconid(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_deltaneutralconid() const;
  void _internal_set_deltaneutralconid(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // double deltaNeutralAuxPrice = 42;
  bool has_deltaneutralauxprice() const;
  private:
  bool _internal_has_deltaneutralauxprice() const;
  public:
  void clear_deltaneutralauxprice();
  double deltaneutralauxprice() const;
  void set_deltaneutralauxprice(double value);
  private:
  double _internal_deltaneutralauxprice() const;
  void _internal_set_deltaneutralauxprice(double value);
  public:

  // int32 deltaNeutralShortSaleSlot = 46;
  bool has_deltaneutralshortsaleslot() const;
  private:
  bool _internal_has_deltaneutralshortsaleslot() const;
  public:
  void clear_deltaneutralshortsaleslot();
  ::PROTOBUF_NAMESPACE_ID::int32 deltaneutralshortsaleslot() const;
  void set_deltaneutralshortsaleslot(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_deltaneutralshortsaleslot() const;
  void _internal_set_deltaneutralshortsaleslot(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 scaleInitLevelSize = 48;
  bool has_scaleinitlevelsize() const;
  private:
  bool _internal_has_scaleinitlevelsize() const;
  public:
  void clear_scaleinitlevelsize();
  ::PROTOBUF_NAMESPACE_ID::int32 scaleinitlevelsize() const;
  void set_scaleinitlevelsize(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_scaleinitlevelsize() const;
  void _internal_set_scaleinitlevelsize(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // double scalePriceIncrement = 50;
  bool has_scalepriceincrement() const;
  private:
  bool _internal_has_scalepriceincrement() const;
  public:
  void clear_scalepriceincrement();
  double scalepriceincrement() const;
  void set_scalepriceincrement(double value);
  private:
  double _internal_scalepriceincrement() const;
  void _internal_set_scalepriceincrement(double value);
  public:

  // int32 scaleSubsLevelSize = 49;
  bool has_scalesubslevelsize() const;
  private:
  bool _internal_has_scalesubslevelsize() const;
  public:
  void clear_scalesubslevelsize();
  ::PROTOBUF_NAMESPACE_ID::int32 scalesubslevelsize() const;
  void set_scalesubslevelsize(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_scalesubslevelsize() const;
  void _internal_set_scalesubslevelsize(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 scalePriceAdjustInterval = 52;
  bool has_scalepriceadjustinterval() const;
  private:
  bool _internal_has_scalepriceadjustinterval() const;
  public:
  void clear_scalepriceadjustinterval();
  ::PROTOBUF_NAMESPACE_ID::int32 scalepriceadjustinterval() const;
  void set_scalepriceadjustinterval(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_scalepriceadjustinterval() const;
  void _internal_set_scalepriceadjustinterval(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // double scalePriceAdjustValue = 51;
  bool has_scalepriceadjustvalue() const;
  private:
  bool _internal_has_scalepriceadjustvalue() const;
  public:
  void clear_scalepriceadjustvalue();
  double scalepriceadjustvalue() const;
  void set_scalepriceadjustvalue(double value);
  private:
  double _internal_scalepriceadjustvalue() const;
  void _internal_set_scalepriceadjustvalue(double value);
  public:

  // double scaleProfitOffset = 53;
  bool has_scaleprofitoffset() const;
  private:
  bool _internal_has_scaleprofitoffset() const;
  public:
  void clear_scaleprofitoffset();
  double scaleprofitoffset() const;
  void set_scaleprofitoffset(double value);
  private:
  double _internal_scaleprofitoffset() const;
  void _internal_set_scaleprofitoffset(double value);
  public:

  // int32 scaleInitPosition = 55;
  bool has_scaleinitposition() const;
  private:
  bool _internal_has_scaleinitposition() const;
  public:
  void clear_scaleinitposition();
  ::PROTOBUF_NAMESPACE_ID::int32 scaleinitposition() const;
  void set_scaleinitposition(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_scaleinitposition() const;
  void _internal_set_scaleinitposition(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 scaleInitFillQty = 56;
  bool has_scaleinitfillqty() const;
  private:
  bool _internal_has_scaleinitfillqty() const;
  public:
  void clear_scaleinitfillqty();
  ::PROTOBUF_NAMESPACE_ID::int32 scaleinitfillqty() const;
  void set_scaleinitfillqty(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_scaleinitfillqty() const;
  void _internal_set_scaleinitfillqty(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // bool scaleRandomPercent = 57;
  bool has_scalerandompercent() const;
  private:
  bool _internal_has_scalerandompercent() const;
  public:
  void clear_scalerandompercent();
  bool scalerandompercent() const;
  void set_scalerandompercent(bool value);
  private:
  bool _internal_scalerandompercent() const;
  void _internal_set_scalerandompercent(bool value);
  public:

  // bool whatIf = 65;
  bool has_whatif() const;
  private:
  bool _internal_has_whatif() const;
  public:
  void clear_whatif();
  bool whatif() const;
  void set_whatif(bool value);
  private:
  bool _internal_whatif() const;
  void _internal_set_whatif(bool value);
  public:

  // bool transmit = 66;
  bool has_transmit() const;
  private:
  bool _internal_has_transmit() const;
  public:
  void clear_transmit();
  bool transmit() const;
  void set_transmit(bool value);
  private:
  bool _internal_transmit() const;
  void _internal_set_transmit(bool value);
  public:

  // bool overridePercentageConstraints = 67;
  bool has_overridepercentageconstraints() const;
  private:
  bool _internal_has_overridepercentageconstraints() const;
  public:
  void clear_overridepercentageconstraints();
  bool overridepercentageconstraints() const;
  void set_overridepercentageconstraints(bool value);
  private:
  bool _internal_overridepercentageconstraints() const;
  void _internal_set_overridepercentageconstraints(bool value);
  public:

  // int32 origin = 69;
  bool has_origin() const;
  private:
  bool _internal_has_origin() const;
  public:
  void clear_origin();
  ::PROTOBUF_NAMESPACE_ID::int32 origin() const;
  void set_origin(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_origin() const;
  void _internal_set_origin(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 shortSaleSlot = 70;
  bool has_shortsaleslot() const;
  private:
  bool _internal_has_shortsaleslot() const;
  public:
  void clear_shortsaleslot();
  ::PROTOBUF_NAMESPACE_ID::int32 shortsaleslot() const;
  void set_shortsaleslot(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_shortsaleslot() const;
  void _internal_set_shortsaleslot(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 exemptCode = 72;
  bool has_exemptcode() const;
  private:
  bool _internal_has_exemptcode() const;
  public:
  void clear_exemptcode();
  ::PROTOBUF_NAMESPACE_ID::int32 exemptcode() const;
  void set_exemptcode(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_exemptcode() const;
  void _internal_set_exemptcode(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // double discretionaryAmt = 76;
  bool has_discretionaryamt() const;
  private:
  bool _internal_has_discretionaryamt() const;
  public:
  void clear_discretionaryamt();
  double discretionaryamt() const;
  void set_discretionaryamt(double value);
  private:
  double _internal_discretionaryamt() const;
  void _internal_set_discretionaryamt(double value);
  public:

  // double startingPrice = 78;
  bool has_startingprice() const;
  private:
  bool _internal_has_startingprice() const;
  public:
  void clear_startingprice();
  double startingprice() const;
  void set_startingprice(double value);
  private:
  double _internal_startingprice() const;
  void _internal_set_startingprice(double value);
  public:

  // double stockRefPrice = 79;
  bool has_stockrefprice() const;
  private:
  bool _internal_has_stockrefprice() const;
  public:
  void clear_stockrefprice();
  double stockrefprice() const;
  void set_stockrefprice(double value);
  private:
  double _internal_stockrefprice() const;
  void _internal_set_stockrefprice(double value);
  public:

  // double delta = 80;
  bool has_delta() const;
  private:
  bool _internal_has_delta() const;
  public:
  void clear_delta();
  double delta() const;
  void set_delta(double value);
  private:
  double _internal_delta() const;
  void _internal_set_delta(double value);
  public:

  // double stockRangeLower = 81;
  bool has_stockrangelower() const;
  private:
  bool _internal_has_stockrangelower() const;
  public:
  void clear_stockrangelower();
  double stockrangelower() const;
  void set_stockrangelower(double value);
  private:
  double _internal_stockrangelower() const;
  void _internal_set_stockrangelower(double value);
  public:

  // double stockRangeUpper = 82;
  bool has_stockrangeupper() const;
  private:
  bool _internal_has_stockrangeupper() const;
  public:
  void clear_stockrangeupper();
  double stockrangeupper() const;
  void set_stockrangeupper(double value);
  private:
  double _internal_stockrangeupper() const;
  void _internal_set_stockrangeupper(double value);
  public:

  // bool optOutSmartRouting = 77;
  bool has_optoutsmartrouting() const;
  private:
  bool _internal_has_optoutsmartrouting() const;
  public:
  void clear_optoutsmartrouting();
  bool optoutsmartrouting() const;
  void set_optoutsmartrouting(bool value);
  private:
  bool _internal_optoutsmartrouting() const;
  void _internal_set_optoutsmartrouting(bool value);
  public:

  // bool notHeld = 83;
  bool has_notheld() const;
  private:
  bool _internal_has_notheld() const;
  public:
  void clear_notheld();
  bool notheld() const;
  void set_notheld(bool value);
  private:
  bool _internal_notheld() const;
  void _internal_set_notheld(bool value);
  public:

  // bool solicited = 85;
  bool has_solicited() const;
  private:
  bool _internal_has_solicited() const;
  public:
  void clear_solicited();
  bool solicited() const;
  void set_solicited(bool value);
  private:
  bool _internal_solicited() const;
  void _internal_set_solicited(bool value);
  public:

  // bool randomizeSize = 86;
  bool has_randomizesize() const;
  private:
  bool _internal_has_randomizesize() const;
  public:
  void clear_randomizesize();
  bool randomizesize() const;
  void set_randomizesize(bool value);
  private:
  bool _internal_randomizesize() const;
  void _internal_set_randomizesize(bool value);
  public:

  // int32 referenceContractId = 88;
  bool has_referencecontractid() const;
  private:
  bool _internal_has_referencecontractid() const;
  public:
  void clear_referencecontractid();
  ::PROTOBUF_NAMESPACE_ID::int32 referencecontractid() const;
  void set_referencecontractid(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_referencecontractid() const;
  void _internal_set_referencecontractid(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // double peggedChangeAmount = 89;
  bool has_peggedchangeamount() const;
  private:
  bool _internal_has_peggedchangeamount() const;
  public:
  void clear_peggedchangeamount();
  double peggedchangeamount() const;
  void set_peggedchangeamount(double value);
  private:
  double _internal_peggedchangeamount() const;
  void _internal_set_peggedchangeamount(double value);
  public:

  // double referenceChangeAmount = 91;
  bool has_referencechangeamount() const;
  private:
  bool _internal_has_referencechangeamount() const;
  public:
  void clear_referencechangeamount();
  double referencechangeamount() const;
  void set_referencechangeamount(double value);
  private:
  double _internal_referencechangeamount() const;
  void _internal_set_referencechangeamount(double value);
  public:

  // double triggerPrice = 94;
  bool has_triggerprice() const;
  private:
  bool _internal_has_triggerprice() const;
  public:
  void clear_triggerprice();
  double triggerprice() const;
  void set_triggerprice(double value);
  private:
  double _internal_triggerprice() const;
  void _internal_set_triggerprice(double value);
  public:

  // double adjustedStopPrice = 95;
  bool has_adjustedstopprice() const;
  private:
  bool _internal_has_adjustedstopprice() const;
  public:
  void clear_adjustedstopprice();
  double adjustedstopprice() const;
  void set_adjustedstopprice(double value);
  private:
  double _internal_adjustedstopprice() const;
  void _internal_set_adjustedstopprice(double value);
  public:

  // bool randomizePrice = 87;
  bool has_randomizeprice() const;
  private:
  bool _internal_has_randomizeprice() const;
  public:
  void clear_randomizeprice();
  bool randomizeprice() const;
  void set_randomizeprice(bool value);
  private:
  bool _internal_randomizeprice() const;
  void _internal_set_randomizeprice(bool value);
  public:

  // bool isPeggedChangeAmountDecrease = 90;
  bool has_ispeggedchangeamountdecrease() const;
  private:
  bool _internal_has_ispeggedchangeamountdecrease() const;
  public:
  void clear_ispeggedchangeamountdecrease();
  bool ispeggedchangeamountdecrease() const;
  void set_ispeggedchangeamountdecrease(bool value);
  private:
  bool _internal_ispeggedchangeamountdecrease() const;
  void _internal_set_ispeggedchangeamountdecrease(bool value);
  public:

  // bool conditionsCancelOrder = 101;
  bool has_conditionscancelorder() const;
  private:
  bool _internal_has_conditionscancelorder() const;
  public:
  void clear_conditionscancelorder();
  bool conditionscancelorder() const;
  void set_conditionscancelorder(bool value);
  private:
  bool _internal_conditionscancelorder() const;
  void _internal_set_conditionscancelorder(bool value);
  public:

  // bool conditionsIgnoreRth = 102;
  bool has_conditionsignorerth() const;
  private:
  bool _internal_has_conditionsignorerth() const;
  public:
  void clear_conditionsignorerth();
  bool conditionsignorerth() const;
  void set_conditionsignorerth(bool value);
  private:
  bool _internal_conditionsignorerth() const;
  void _internal_set_conditionsignorerth(bool value);
  public:

  // int32 adjustableTrailingUnit = 98;
  bool has_adjustabletrailingunit() const;
  private:
  bool _internal_has_adjustabletrailingunit() const;
  public:
  void clear_adjustabletrailingunit();
  ::PROTOBUF_NAMESPACE_ID::int32 adjustabletrailingunit() const;
  void set_adjustabletrailingunit(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_adjustabletrailingunit() const;
  void _internal_set_adjustabletrailingunit(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // double adjustedStopLimitPrice = 96;
  bool has_adjustedstoplimitprice() const;
  private:
  bool _internal_has_adjustedstoplimitprice() const;
  public:
  void clear_adjustedstoplimitprice();
  double adjustedstoplimitprice() const;
  void set_adjustedstoplimitprice(double value);
  private:
  double _internal_adjustedstoplimitprice() const;
  void _internal_set_adjustedstoplimitprice(double value);
  public:

  // double adjustedTrailingAmount = 97;
  bool has_adjustedtrailingamount() const;
  private:
  bool _internal_has_adjustedtrailingamount() const;
  public:
  void clear_adjustedtrailingamount();
  double adjustedtrailingamount() const;
  void set_adjustedtrailingamount(double value);
  private:
  double _internal_adjustedtrailingamount() const;
  void _internal_set_adjustedtrailingamount(double value);
  public:

  // double lmtPriceOffset = 99;
  bool has_lmtpriceoffset() const;
  private:
  bool _internal_has_lmtpriceoffset() const;
  public:
  void clear_lmtpriceoffset();
  double lmtpriceoffset() const;
  void set_lmtpriceoffset(double value);
  private:
  double _internal_lmtpriceoffset() const;
  void _internal_set_lmtpriceoffset(double value);
  public:

  // double cashQty = 106;
  bool has_cashqty() const;
  private:
  bool _internal_has_cashqty() const;
  public:
  void clear_cashqty();
  double cashqty() const;
  void set_cashqty(double value);
  private:
  double _internal_cashqty() const;
  void _internal_set_cashqty(double value);
  public:

  // bool dontUseAutoPriceForHedge = 111;
  bool has_dontuseautopriceforhedge() const;
  private:
  bool _internal_has_dontuseautopriceforhedge() const;
  public:
  void clear_dontuseautopriceforhedge();
  bool dontuseautopriceforhedge() const;
  void set_dontuseautopriceforhedge(bool value);
  private:
  bool _internal_dontuseautopriceforhedge() const;
  void _internal_set_dontuseautopriceforhedge(bool value);
  public:

  // bool isOmsContainer = 112;
  bool has_isomscontainer() const;
  private:
  bool _internal_has_isomscontainer() const;
  public:
  void clear_isomscontainer();
  bool isomscontainer() const;
  void set_isomscontainer(bool value);
  private:
  bool _internal_isomscontainer() const;
  void _internal_set_isomscontainer(bool value);
  public:

  // bool discretionaryUpToLimitPrice = 113;
  bool has_discretionaryuptolimitprice() const;
  private:
  bool _internal_has_discretionaryuptolimitprice() const;
  public:
  void clear_discretionaryuptolimitprice();
  bool discretionaryuptolimitprice() const;
  void set_discretionaryuptolimitprice(bool value);
  private:
  bool _internal_discretionaryuptolimitprice() const;
  void _internal_set_discretionaryuptolimitprice(bool value);
  public:

  // bool autoCancelParent = 117;
  bool has_autocancelparent() const;
  private:
  bool _internal_has_autocancelparent() const;
  public:
  void clear_autocancelparent();
  bool autocancelparent() const;
  void set_autocancelparent(bool value);
  private:
  bool _internal_autocancelparent() const;
  void _internal_set_autocancelparent(bool value);
  public:

  // int32 refFuturesConId = 116;
  bool has_reffuturesconid() const;
  private:
  bool _internal_has_reffuturesconid() const;
  public:
  void clear_reffuturesconid();
  ::PROTOBUF_NAMESPACE_ID::int32 reffuturesconid() const;
  void set_reffuturesconid(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_reffuturesconid() const;
  void _internal_set_reffuturesconid(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int64 parentPermId = 121;
  bool has_parentpermid() const;
  private:
  bool _internal_has_parentpermid() const;
  public:
  void clear_parentpermid();
  ::PROTOBUF_NAMESPACE_ID::int64 parentpermid() const;
  void set_parentpermid(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_parentpermid() const;
  void _internal_set_parentpermid(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // int32 usePriceMgmtAlgo = 122;
  bool has_usepricemgmtalgo() const;
  private:
  bool _internal_has_usepricemgmtalgo() const;
  public:
  void clear_usepricemgmtalgo();
  ::PROTOBUF_NAMESPACE_ID::int32 usepricemgmtalgo() const;
  void set_usepricemgmtalgo(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_usepricemgmtalgo() const;
  void _internal_set_usepricemgmtalgo(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 duration = 123;
  bool has_duration() const;
  private:
  bool _internal_has_duration() const;
  public:
  void clear_duration();
  ::PROTOBUF_NAMESPACE_ID::int32 duration() const;
  void set_duration(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_duration() const;
  void _internal_set_duration(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 postToAts = 124;
  bool has_posttoats() const;
  private:
  bool _internal_has_posttoats() const;
  public:
  void clear_posttoats();
  ::PROTOBUF_NAMESPACE_ID::int32 posttoats() const;
  void set_posttoats(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_posttoats() const;
  void _internal_set_posttoats(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // bool imbalanceOnly = 119;
  bool has_imbalanceonly() const;
  private:
  bool _internal_has_imbalanceonly() const;
  public:
  void clear_imbalanceonly();
  bool imbalanceonly() const;
  void set_imbalanceonly(bool value);
  private:
  bool _internal_imbalanceonly() const;
  void _internal_set_imbalanceonly(bool value);
  public:

  // bool routeMarketableToBbo = 120;
  bool has_routemarketabletobbo() const;
  private:
  bool _internal_has_routemarketabletobbo() const;
  public:
  void clear_routemarketabletobbo();
  bool routemarketabletobbo() const;
  void set_routemarketabletobbo(bool value);
  private:
  bool _internal_routemarketabletobbo() const;
  void _internal_set_routemarketabletobbo(bool value);
  public:

  // bool professionalCustomer = 133;
  bool has_professionalcustomer() const;
  private:
  bool _internal_has_professionalcustomer() const;
  public:
  void clear_professionalcustomer();
  bool professionalcustomer() const;
  void set_professionalcustomer(bool value);
  private:
  bool _internal_professionalcustomer() const;
  void _internal_set_professionalcustomer(bool value);
  public:

  // bool includeOvernight = 135;
  bool has_includeovernight() const;
  private:
  bool _internal_has_includeovernight() const;
  public:
  void clear_includeovernight();
  bool includeovernight() const;
  void set_includeovernight(bool value);
  private:
  bool _internal_includeovernight() const;
  void _internal_set_includeovernight(bool value);
  public:

  // int32 minTradeQty = 127;
  bool has_mintradeqty() const;
  private:
  bool _internal_has_mintradeqty() const;
  public:
  void clear_mintradeqty();
  ::PROTOBUF_NAMESPACE_ID::int32 mintradeqty() const;
  void set_mintradeqty(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_mintradeqty() const;
  void _internal_set_mintradeqty(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 minCompeteSize = 128;
  bool has_mincompetesize() const;
  private:
  bool _internal_has_mincompetesize() const;
  public:
  void clear_mincompetesize();
  ::PROTOBUF_NAMESPACE_ID::int32 mincompetesize() const;
  void set_mincompetesize(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_mincompetesize() const;
  void _internal_set_mincompetesize(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // double competeAgainstBestOffset = 129;
  bool has_competeagainstbestoffset() const;
  private:
  bool _internal_has_competeagainstbestoffset() const;
  public:
  void clear_competeagainstbestoffset();
  double competeagainstbestoffset() const;
  void set_competeagainstbestoffset(double value);
  private:
  double _internal_competeagainstbestoffset() const;
  void _internal_set_competeagainstbestoffset(double value);
  public:

  // double midOffsetAtWhole = 130;
  bool has_midoffsetatwhole() const;
  private:
  bool _internal_has_midoffsetatwhole() const;
  public:
  void clear_midoffsetatwhole();
  double midoffsetatwhole() const;
  void set_midoffsetatwhole(double value);
  private:
  double _internal_midoffsetatwhole() const;
  void _internal_set_midoffsetatwhole(double value);
  public:

  // double midOffsetAtHalf = 131;
  bool has_midoffsetathalf() const;
  private:
  bool _internal_has_midoffsetathalf() const;
  public:
  void clear_midoffsetathalf();
  double midoffsetathalf() const;
  void set_midoffsetathalf(double value);
  private:
  double _internal_midoffsetathalf() const;
  void _internal_set_midoffsetathalf(double value);
  public:

  // int32 manualOrderIndicator = 136;
  bool has_manualorderindicator() const;
  private:
  bool _internal_has_manualorderindicator() const;
  public:
  void clear_manualorderindicator();
  ::PROTOBUF_NAMESPACE_ID::int32 manualorderindicator() const;
  void set_manualorderindicator(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_manualorderindicator() const;
  void _internal_set_manualorderindicator(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<5> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::internal::MapField<
      Order_AlgoParamsEntry_DoNotUse,
      std::string, std::string,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
      0 > algoparams_;
  ::PROTOBUF_NAMESPACE_ID::internal::MapField<
      Order_SmartComboRoutingParamsEntry_DoNotUse,
      std::string, std::string,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
      0 > smartcomboroutingparams_;
  ::PROTOBUF_NAMESPACE_ID::internal::MapField<
      Order_OrderMiscOptionsEntry_DoNotUse,
      std::string, std::string,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
      0 > ordermiscoptions_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::protobuf::OrderCondition > conditions_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr action_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr totalquantity_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ordertype_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tif_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr account_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr settlingfirm_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr clearingaccount_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr clearingintent_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr goodaftertime_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr goodtilldate_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ocagroup_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr orderref_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr rule80a_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr activestarttime_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr activestoptime_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fagroup_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr famethod_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fapercentage_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr deltaneutralordertype_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr deltaneutralopenclose_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr deltaneutraldesignatedlocation_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr scaletable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hedgetype_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hedgeparam_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr algostrategy_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr algoid_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr openclose_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr designatedlocation_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr deltaneutralsettlingfirm_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr deltaneutralclearingaccount_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr deltaneutralclearingintent_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr referenceexchangeid_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr adjustedordertype_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr modelcode_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr extoperator_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mifid2decisionmaker_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mifid2decisionalgo_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mifid2executiontrader_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mifid2executionalgo_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr autocanceldate_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr filledquantity_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr shareholder_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr advancederroroverride_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr manualordertime_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr customeraccount_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr bondaccruedinterest_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr submitter_;
  ::protobuf::SoftDollarTier* softdollartier_;
  ::PROTOBUF_NAMESPACE_ID::int32 clientid_;
  ::PROTOBUF_NAMESPACE_ID::int32 orderid_;
  ::PROTOBUF_NAMESPACE_ID::int64 permid_;
  ::PROTOBUF_NAMESPACE_ID::int32 parentid_;
  ::PROTOBUF_NAMESPACE_ID::int32 displaysize_;
  double lmtprice_;
  double auxprice_;
  bool allornone_;
  bool blockorder_;
  bool hidden_;
  bool outsiderth_;
  ::PROTOBUF_NAMESPACE_ID::int32 minqty_;
  double percentoffset_;
  double trailingpercent_;
  double trailstopprice_;
  ::PROTOBUF_NAMESPACE_ID::int32 ocatype_;
  ::PROTOBUF_NAMESPACE_ID::int32 triggermethod_;
  double volatility_;
  ::PROTOBUF_NAMESPACE_ID::int32 volatilitytype_;
  bool sweeptofill_;
  bool continuousupdate_;
  bool deltaneutralshortsale_;
  bool scaleautoreset_;
  ::PROTOBUF_NAMESPACE_ID::int32 referencepricetype_;
  ::PROTOBUF_NAMESPACE_ID::int32 deltaneutralconid_;
  double deltaneutralauxprice_;
  ::PROTOBUF_NAMESPACE_ID::int32 deltaneutralshortsaleslot_;
  ::PROTOBUF_NAMESPACE_ID::int32 scaleinitlevelsize_;
  double scalepriceincrement_;
  ::PROTOBUF_NAMESPACE_ID::int32 scalesubslevelsize_;
  ::PROTOBUF_NAMESPACE_ID::int32 scalepriceadjustinterval_;
  double scalepriceadjustvalue_;
  double scaleprofitoffset_;
  ::PROTOBUF_NAMESPACE_ID::int32 scaleinitposition_;
  ::PROTOBUF_NAMESPACE_ID::int32 scaleinitfillqty_;
  bool scalerandompercent_;
  bool whatif_;
  bool transmit_;
  bool overridepercentageconstraints_;
  ::PROTOBUF_NAMESPACE_ID::int32 origin_;
  ::PROTOBUF_NAMESPACE_ID::int32 shortsaleslot_;
  ::PROTOBUF_NAMESPACE_ID::int32 exemptcode_;
  double discretionaryamt_;
  double startingprice_;
  double stockrefprice_;
  double delta_;
  double stockrangelower_;
  double stockrangeupper_;
  bool optoutsmartrouting_;
  bool notheld_;
  bool solicited_;
  bool randomizesize_;
  ::PROTOBUF_NAMESPACE_ID::int32 referencecontractid_;
  double peggedchangeamount_;
  double referencechangeamount_;
  double triggerprice_;
  double adjustedstopprice_;
  bool randomizeprice_;
  bool ispeggedchangeamountdecrease_;
  bool conditionscancelorder_;
  bool conditionsignorerth_;
  ::PROTOBUF_NAMESPACE_ID::int32 adjustabletrailingunit_;
  double adjustedstoplimitprice_;
  double adjustedtrailingamount_;
  double lmtpriceoffset_;
  double cashqty_;
  bool dontuseautopriceforhedge_;
  bool isomscontainer_;
  bool discretionaryuptolimitprice_;
  bool autocancelparent_;
  ::PROTOBUF_NAMESPACE_ID::int32 reffuturesconid_;
  ::PROTOBUF_NAMESPACE_ID::int64 parentpermid_;
  ::PROTOBUF_NAMESPACE_ID::int32 usepricemgmtalgo_;
  ::PROTOBUF_NAMESPACE_ID::int32 duration_;
  ::PROTOBUF_NAMESPACE_ID::int32 posttoats_;
  bool imbalanceonly_;
  bool routemarketabletobbo_;
  bool professionalcustomer_;
  bool includeovernight_;
  ::PROTOBUF_NAMESPACE_ID::int32 mintradeqty_;
  ::PROTOBUF_NAMESPACE_ID::int32 mincompetesize_;
  double competeagainstbestoffset_;
  double midoffsetatwhole_;
  double midoffsetathalf_;
  ::PROTOBUF_NAMESPACE_ID::int32 manualorderindicator_;
  friend struct ::TableStruct_Order_2eproto;
};
// ===================================================================


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

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

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

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

// Order

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

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

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

// int32 parentId = 4;
inline bool Order::_internal_has_parentid() const {
  bool value = (_has_bits_[1] & 0x00080000u) != 0;
  return value;
}
inline bool Order::has_parentid() const {
  return _internal_has_parentid();
}
inline void Order::clear_parentid() {
  parentid_ = 0;
  _has_bits_[1] &= ~0x00080000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::_internal_parentid() const {
  return parentid_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::parentid() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.parentId)
  return _internal_parentid();
}
inline void Order::_internal_set_parentid(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[1] |= 0x00080000u;
  parentid_ = value;
}
inline void Order::set_parentid(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_parentid(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.parentId)
}

// string action = 5;
inline bool Order::_internal_has_action() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Order::has_action() const {
  return _internal_has_action();
}
inline void Order::clear_action() {
  action_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Order::action() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.action)
  return _internal_action();
}
inline void Order::set_action(const std::string& value) {
  _internal_set_action(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.action)
}
inline std::string* Order::mutable_action() {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.action)
  return _internal_mutable_action();
}
inline const std::string& Order::_internal_action() const {
  return action_.Get();
}
inline void Order::_internal_set_action(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  action_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Order::set_action(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  action_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Order.action)
}
inline void Order::set_action(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  action_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Order.action)
}
inline void Order::set_action(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  action_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Order.action)
}
inline std::string* Order::_internal_mutable_action() {
  _has_bits_[0] |= 0x00000001u;
  return action_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Order::release_action() {
  // @@protoc_insertion_point(field_release:protobuf.Order.action)
  if (!_internal_has_action()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return action_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Order::set_allocated_action(std::string* action) {
  if (action != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  action_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), action,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Order.action)
}
inline std::string* Order::unsafe_arena_release_action() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Order.action)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00000001u;
  return action_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Order::unsafe_arena_set_allocated_action(
    std::string* action) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (action != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  action_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      action, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Order.action)
}

// string totalQuantity = 6;
inline bool Order::_internal_has_totalquantity() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Order::has_totalquantity() const {
  return _internal_has_totalquantity();
}
inline void Order::clear_totalquantity() {
  totalquantity_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Order::totalquantity() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.totalQuantity)
  return _internal_totalquantity();
}
inline void Order::set_totalquantity(const std::string& value) {
  _internal_set_totalquantity(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.totalQuantity)
}
inline std::string* Order::mutable_totalquantity() {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.totalQuantity)
  return _internal_mutable_totalquantity();
}
inline const std::string& Order::_internal_totalquantity() const {
  return totalquantity_.Get();
}
inline void Order::_internal_set_totalquantity(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  totalquantity_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Order::set_totalquantity(std::string&& value) {
  _has_bits_[0] |= 0x00000002u;
  totalquantity_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Order.totalQuantity)
}
inline void Order::set_totalquantity(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000002u;
  totalquantity_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Order.totalQuantity)
}
inline void Order::set_totalquantity(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000002u;
  totalquantity_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Order.totalQuantity)
}
inline std::string* Order::_internal_mutable_totalquantity() {
  _has_bits_[0] |= 0x00000002u;
  return totalquantity_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Order::release_totalquantity() {
  // @@protoc_insertion_point(field_release:protobuf.Order.totalQuantity)
  if (!_internal_has_totalquantity()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return totalquantity_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Order::set_allocated_totalquantity(std::string* totalquantity) {
  if (totalquantity != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  totalquantity_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), totalquantity,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Order.totalQuantity)
}
inline std::string* Order::unsafe_arena_release_totalquantity() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Order.totalQuantity)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00000002u;
  return totalquantity_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Order::unsafe_arena_set_allocated_totalquantity(
    std::string* totalquantity) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (totalquantity != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  totalquantity_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      totalquantity, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Order.totalQuantity)
}

// int32 displaySize = 7;
inline bool Order::_internal_has_displaysize() const {
  bool value = (_has_bits_[1] & 0x00100000u) != 0;
  return value;
}
inline bool Order::has_displaysize() const {
  return _internal_has_displaysize();
}
inline void Order::clear_displaysize() {
  displaysize_ = 0;
  _has_bits_[1] &= ~0x00100000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::_internal_displaysize() const {
  return displaysize_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::displaysize() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.displaySize)
  return _internal_displaysize();
}
inline void Order::_internal_set_displaysize(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[1] |= 0x00100000u;
  displaysize_ = value;
}
inline void Order::set_displaysize(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_displaysize(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.displaySize)
}

// string orderType = 8;
inline bool Order::_internal_has_ordertype() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Order::has_ordertype() const {
  return _internal_has_ordertype();
}
inline void Order::clear_ordertype() {
  ordertype_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000004u;
}
inline const std::string& Order::ordertype() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.orderType)
  return _internal_ordertype();
}
inline void Order::set_ordertype(const std::string& value) {
  _internal_set_ordertype(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.orderType)
}
inline std::string* Order::mutable_ordertype() {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.orderType)
  return _internal_mutable_ordertype();
}
inline const std::string& Order::_internal_ordertype() const {
  return ordertype_.Get();
}
inline void Order::_internal_set_ordertype(const std::string& value) {
  _has_bits_[0] |= 0x00000004u;
  ordertype_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Order::set_ordertype(std::string&& value) {
  _has_bits_[0] |= 0x00000004u;
  ordertype_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Order.orderType)
}
inline void Order::set_ordertype(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000004u;
  ordertype_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Order.orderType)
}
inline void Order::set_ordertype(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000004u;
  ordertype_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Order.orderType)
}
inline std::string* Order::_internal_mutable_ordertype() {
  _has_bits_[0] |= 0x00000004u;
  return ordertype_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Order::release_ordertype() {
  // @@protoc_insertion_point(field_release:protobuf.Order.orderType)
  if (!_internal_has_ordertype()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000004u;
  return ordertype_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Order::set_allocated_ordertype(std::string* ordertype) {
  if (ordertype != nullptr) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  ordertype_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ordertype,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Order.orderType)
}
inline std::string* Order::unsafe_arena_release_ordertype() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Order.orderType)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00000004u;
  return ordertype_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Order::unsafe_arena_set_allocated_ordertype(
    std::string* ordertype) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (ordertype != nullptr) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  ordertype_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ordertype, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Order.orderType)
}

// double lmtPrice = 9;
inline bool Order::_internal_has_lmtprice() const {
  bool value = (_has_bits_[1] & 0x00200000u) != 0;
  return value;
}
inline bool Order::has_lmtprice() const {
  return _internal_has_lmtprice();
}
inline void Order::clear_lmtprice() {
  lmtprice_ = 0;
  _has_bits_[1] &= ~0x00200000u;
}
inline double Order::_internal_lmtprice() const {
  return lmtprice_;
}
inline double Order::lmtprice() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.lmtPrice)
  return _internal_lmtprice();
}
inline void Order::_internal_set_lmtprice(double value) {
  _has_bits_[1] |= 0x00200000u;
  lmtprice_ = value;
}
inline void Order::set_lmtprice(double value) {
  _internal_set_lmtprice(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.lmtPrice)
}

// double auxPrice = 10;
inline bool Order::_internal_has_auxprice() const {
  bool value = (_has_bits_[1] & 0x00400000u) != 0;
  return value;
}
inline bool Order::has_auxprice() const {
  return _internal_has_auxprice();
}
inline void Order::clear_auxprice() {
  auxprice_ = 0;
  _has_bits_[1] &= ~0x00400000u;
}
inline double Order::_internal_auxprice() const {
  return auxprice_;
}
inline double Order::auxprice() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.auxPrice)
  return _internal_auxprice();
}
inline void Order::_internal_set_auxprice(double value) {
  _has_bits_[1] |= 0x00400000u;
  auxprice_ = value;
}
inline void Order::set_auxprice(double value) {
  _internal_set_auxprice(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.auxPrice)
}

// string tif = 11;
inline bool Order::_internal_has_tif() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Order::has_tif() const {
  return _internal_has_tif();
}
inline void Order::clear_tif() {
  tif_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000008u;
}
inline const std::string& Order::tif() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.tif)
  return _internal_tif();
}
inline void Order::set_tif(const std::string& value) {
  _internal_set_tif(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.tif)
}
inline std::string* Order::mutable_tif() {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.tif)
  return _internal_mutable_tif();
}
inline const std::string& Order::_internal_tif() const {
  return tif_.Get();
}
inline void Order::_internal_set_tif(const std::string& value) {
  _has_bits_[0] |= 0x00000008u;
  tif_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Order::set_tif(std::string&& value) {
  _has_bits_[0] |= 0x00000008u;
  tif_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Order.tif)
}
inline void Order::set_tif(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000008u;
  tif_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Order.tif)
}
inline void Order::set_tif(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000008u;
  tif_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Order.tif)
}
inline std::string* Order::_internal_mutable_tif() {
  _has_bits_[0] |= 0x00000008u;
  return tif_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Order::release_tif() {
  // @@protoc_insertion_point(field_release:protobuf.Order.tif)
  if (!_internal_has_tif()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000008u;
  return tif_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Order::set_allocated_tif(std::string* tif) {
  if (tif != nullptr) {
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  tif_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), tif,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Order.tif)
}
inline std::string* Order::unsafe_arena_release_tif() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Order.tif)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00000008u;
  return tif_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Order::unsafe_arena_set_allocated_tif(
    std::string* tif) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (tif != nullptr) {
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  tif_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      tif, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Order.tif)
}

// string account = 12;
inline bool Order::_internal_has_account() const {
  bool value = (_has_bits_[0] & 0x00000010u) != 0;
  return value;
}
inline bool Order::has_account() const {
  return _internal_has_account();
}
inline void Order::clear_account() {
  account_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000010u;
}
inline const std::string& Order::account() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.account)
  return _internal_account();
}
inline void Order::set_account(const std::string& value) {
  _internal_set_account(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.account)
}
inline std::string* Order::mutable_account() {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.account)
  return _internal_mutable_account();
}
inline const std::string& Order::_internal_account() const {
  return account_.Get();
}
inline void Order::_internal_set_account(const std::string& value) {
  _has_bits_[0] |= 0x00000010u;
  account_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Order::set_account(std::string&& value) {
  _has_bits_[0] |= 0x00000010u;
  account_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Order.account)
}
inline void Order::set_account(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000010u;
  account_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Order.account)
}
inline void Order::set_account(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000010u;
  account_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Order.account)
}
inline std::string* Order::_internal_mutable_account() {
  _has_bits_[0] |= 0x00000010u;
  return account_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Order::release_account() {
  // @@protoc_insertion_point(field_release:protobuf.Order.account)
  if (!_internal_has_account()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000010u;
  return account_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Order::set_allocated_account(std::string* account) {
  if (account != nullptr) {
    _has_bits_[0] |= 0x00000010u;
  } else {
    _has_bits_[0] &= ~0x00000010u;
  }
  account_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), account,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Order.account)
}
inline std::string* Order::unsafe_arena_release_account() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Order.account)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00000010u;
  return account_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Order::unsafe_arena_set_allocated_account(
    std::string* account) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (account != nullptr) {
    _has_bits_[0] |= 0x00000010u;
  } else {
    _has_bits_[0] &= ~0x00000010u;
  }
  account_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      account, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Order.account)
}

// string settlingFirm = 13;
inline bool Order::_internal_has_settlingfirm() const {
  bool value = (_has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool Order::has_settlingfirm() const {
  return _internal_has_settlingfirm();
}
inline void Order::clear_settlingfirm() {
  settlingfirm_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000020u;
}
inline const std::string& Order::settlingfirm() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.settlingFirm)
  return _internal_settlingfirm();
}
inline void Order::set_settlingfirm(const std::string& value) {
  _internal_set_settlingfirm(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.settlingFirm)
}
inline std::string* Order::mutable_settlingfirm() {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.settlingFirm)
  return _internal_mutable_settlingfirm();
}
inline const std::string& Order::_internal_settlingfirm() const {
  return settlingfirm_.Get();
}
inline void Order::_internal_set_settlingfirm(const std::string& value) {
  _has_bits_[0] |= 0x00000020u;
  settlingfirm_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Order::set_settlingfirm(std::string&& value) {
  _has_bits_[0] |= 0x00000020u;
  settlingfirm_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Order.settlingFirm)
}
inline void Order::set_settlingfirm(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000020u;
  settlingfirm_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Order.settlingFirm)
}
inline void Order::set_settlingfirm(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000020u;
  settlingfirm_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Order.settlingFirm)
}
inline std::string* Order::_internal_mutable_settlingfirm() {
  _has_bits_[0] |= 0x00000020u;
  return settlingfirm_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Order::release_settlingfirm() {
  // @@protoc_insertion_point(field_release:protobuf.Order.settlingFirm)
  if (!_internal_has_settlingfirm()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000020u;
  return settlingfirm_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Order::set_allocated_settlingfirm(std::string* settlingfirm) {
  if (settlingfirm != nullptr) {
    _has_bits_[0] |= 0x00000020u;
  } else {
    _has_bits_[0] &= ~0x00000020u;
  }
  settlingfirm_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), settlingfirm,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Order.settlingFirm)
}
inline std::string* Order::unsafe_arena_release_settlingfirm() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Order.settlingFirm)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00000020u;
  return settlingfirm_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Order::unsafe_arena_set_allocated_settlingfirm(
    std::string* settlingfirm) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (settlingfirm != nullptr) {
    _has_bits_[0] |= 0x00000020u;
  } else {
    _has_bits_[0] &= ~0x00000020u;
  }
  settlingfirm_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      settlingfirm, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Order.settlingFirm)
}

// string clearingAccount = 14;
inline bool Order::_internal_has_clearingaccount() const {
  bool value = (_has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool Order::has_clearingaccount() const {
  return _internal_has_clearingaccount();
}
inline void Order::clear_clearingaccount() {
  clearingaccount_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000040u;
}
inline const std::string& Order::clearingaccount() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.clearingAccount)
  return _internal_clearingaccount();
}
inline void Order::set_clearingaccount(const std::string& value) {
  _internal_set_clearingaccount(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.clearingAccount)
}
inline std::string* Order::mutable_clearingaccount() {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.clearingAccount)
  return _internal_mutable_clearingaccount();
}
inline const std::string& Order::_internal_clearingaccount() const {
  return clearingaccount_.Get();
}
inline void Order::_internal_set_clearingaccount(const std::string& value) {
  _has_bits_[0] |= 0x00000040u;
  clearingaccount_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Order::set_clearingaccount(std::string&& value) {
  _has_bits_[0] |= 0x00000040u;
  clearingaccount_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Order.clearingAccount)
}
inline void Order::set_clearingaccount(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000040u;
  clearingaccount_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Order.clearingAccount)
}
inline void Order::set_clearingaccount(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000040u;
  clearingaccount_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Order.clearingAccount)
}
inline std::string* Order::_internal_mutable_clearingaccount() {
  _has_bits_[0] |= 0x00000040u;
  return clearingaccount_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Order::release_clearingaccount() {
  // @@protoc_insertion_point(field_release:protobuf.Order.clearingAccount)
  if (!_internal_has_clearingaccount()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000040u;
  return clearingaccount_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Order::set_allocated_clearingaccount(std::string* clearingaccount) {
  if (clearingaccount != nullptr) {
    _has_bits_[0] |= 0x00000040u;
  } else {
    _has_bits_[0] &= ~0x00000040u;
  }
  clearingaccount_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), clearingaccount,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Order.clearingAccount)
}
inline std::string* Order::unsafe_arena_release_clearingaccount() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Order.clearingAccount)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00000040u;
  return clearingaccount_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Order::unsafe_arena_set_allocated_clearingaccount(
    std::string* clearingaccount) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (clearingaccount != nullptr) {
    _has_bits_[0] |= 0x00000040u;
  } else {
    _has_bits_[0] &= ~0x00000040u;
  }
  clearingaccount_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      clearingaccount, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Order.clearingAccount)
}

// string clearingIntent = 15;
inline bool Order::_internal_has_clearingintent() const {
  bool value = (_has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool Order::has_clearingintent() const {
  return _internal_has_clearingintent();
}
inline void Order::clear_clearingintent() {
  clearingintent_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000080u;
}
inline const std::string& Order::clearingintent() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.clearingIntent)
  return _internal_clearingintent();
}
inline void Order::set_clearingintent(const std::string& value) {
  _internal_set_clearingintent(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.clearingIntent)
}
inline std::string* Order::mutable_clearingintent() {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.clearingIntent)
  return _internal_mutable_clearingintent();
}
inline const std::string& Order::_internal_clearingintent() const {
  return clearingintent_.Get();
}
inline void Order::_internal_set_clearingintent(const std::string& value) {
  _has_bits_[0] |= 0x00000080u;
  clearingintent_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Order::set_clearingintent(std::string&& value) {
  _has_bits_[0] |= 0x00000080u;
  clearingintent_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Order.clearingIntent)
}
inline void Order::set_clearingintent(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000080u;
  clearingintent_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Order.clearingIntent)
}
inline void Order::set_clearingintent(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000080u;
  clearingintent_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Order.clearingIntent)
}
inline std::string* Order::_internal_mutable_clearingintent() {
  _has_bits_[0] |= 0x00000080u;
  return clearingintent_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Order::release_clearingintent() {
  // @@protoc_insertion_point(field_release:protobuf.Order.clearingIntent)
  if (!_internal_has_clearingintent()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000080u;
  return clearingintent_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Order::set_allocated_clearingintent(std::string* clearingintent) {
  if (clearingintent != nullptr) {
    _has_bits_[0] |= 0x00000080u;
  } else {
    _has_bits_[0] &= ~0x00000080u;
  }
  clearingintent_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), clearingintent,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Order.clearingIntent)
}
inline std::string* Order::unsafe_arena_release_clearingintent() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Order.clearingIntent)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00000080u;
  return clearingintent_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Order::unsafe_arena_set_allocated_clearingintent(
    std::string* clearingintent) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (clearingintent != nullptr) {
    _has_bits_[0] |= 0x00000080u;
  } else {
    _has_bits_[0] &= ~0x00000080u;
  }
  clearingintent_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      clearingintent, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Order.clearingIntent)
}

// bool allOrNone = 16;
inline bool Order::_internal_has_allornone() const {
  bool value = (_has_bits_[1] & 0x00800000u) != 0;
  return value;
}
inline bool Order::has_allornone() const {
  return _internal_has_allornone();
}
inline void Order::clear_allornone() {
  allornone_ = false;
  _has_bits_[1] &= ~0x00800000u;
}
inline bool Order::_internal_allornone() const {
  return allornone_;
}
inline bool Order::allornone() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.allOrNone)
  return _internal_allornone();
}
inline void Order::_internal_set_allornone(bool value) {
  _has_bits_[1] |= 0x00800000u;
  allornone_ = value;
}
inline void Order::set_allornone(bool value) {
  _internal_set_allornone(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.allOrNone)
}

// bool blockOrder = 17;
inline bool Order::_internal_has_blockorder() const {
  bool value = (_has_bits_[1] & 0x01000000u) != 0;
  return value;
}
inline bool Order::has_blockorder() const {
  return _internal_has_blockorder();
}
inline void Order::clear_blockorder() {
  blockorder_ = false;
  _has_bits_[1] &= ~0x01000000u;
}
inline bool Order::_internal_blockorder() const {
  return blockorder_;
}
inline bool Order::blockorder() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.blockOrder)
  return _internal_blockorder();
}
inline void Order::_internal_set_blockorder(bool value) {
  _has_bits_[1] |= 0x01000000u;
  blockorder_ = value;
}
inline void Order::set_blockorder(bool value) {
  _internal_set_blockorder(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.blockOrder)
}

// bool hidden = 18;
inline bool Order::_internal_has_hidden() const {
  bool value = (_has_bits_[1] & 0x02000000u) != 0;
  return value;
}
inline bool Order::has_hidden() const {
  return _internal_has_hidden();
}
inline void Order::clear_hidden() {
  hidden_ = false;
  _has_bits_[1] &= ~0x02000000u;
}
inline bool Order::_internal_hidden() const {
  return hidden_;
}
inline bool Order::hidden() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.hidden)
  return _internal_hidden();
}
inline void Order::_internal_set_hidden(bool value) {
  _has_bits_[1] |= 0x02000000u;
  hidden_ = value;
}
inline void Order::set_hidden(bool value) {
  _internal_set_hidden(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.hidden)
}

// bool outsideRth = 19;
inline bool Order::_internal_has_outsiderth() const {
  bool value = (_has_bits_[1] & 0x04000000u) != 0;
  return value;
}
inline bool Order::has_outsiderth() const {
  return _internal_has_outsiderth();
}
inline void Order::clear_outsiderth() {
  outsiderth_ = false;
  _has_bits_[1] &= ~0x04000000u;
}
inline bool Order::_internal_outsiderth() const {
  return outsiderth_;
}
inline bool Order::outsiderth() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.outsideRth)
  return _internal_outsiderth();
}
inline void Order::_internal_set_outsiderth(bool value) {
  _has_bits_[1] |= 0x04000000u;
  outsiderth_ = value;
}
inline void Order::set_outsiderth(bool value) {
  _internal_set_outsiderth(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.outsideRth)
}

// bool sweepToFill = 20;
inline bool Order::_internal_has_sweeptofill() const {
  bool value = (_has_bits_[2] & 0x00000008u) != 0;
  return value;
}
inline bool Order::has_sweeptofill() const {
  return _internal_has_sweeptofill();
}
inline void Order::clear_sweeptofill() {
  sweeptofill_ = false;
  _has_bits_[2] &= ~0x00000008u;
}
inline bool Order::_internal_sweeptofill() const {
  return sweeptofill_;
}
inline bool Order::sweeptofill() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.sweepToFill)
  return _internal_sweeptofill();
}
inline void Order::_internal_set_sweeptofill(bool value) {
  _has_bits_[2] |= 0x00000008u;
  sweeptofill_ = value;
}
inline void Order::set_sweeptofill(bool value) {
  _internal_set_sweeptofill(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.sweepToFill)
}

// double percentOffset = 21;
inline bool Order::_internal_has_percentoffset() const {
  bool value = (_has_bits_[1] & 0x10000000u) != 0;
  return value;
}
inline bool Order::has_percentoffset() const {
  return _internal_has_percentoffset();
}
inline void Order::clear_percentoffset() {
  percentoffset_ = 0;
  _has_bits_[1] &= ~0x10000000u;
}
inline double Order::_internal_percentoffset() const {
  return percentoffset_;
}
inline double Order::percentoffset() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.percentOffset)
  return _internal_percentoffset();
}
inline void Order::_internal_set_percentoffset(double value) {
  _has_bits_[1] |= 0x10000000u;
  percentoffset_ = value;
}
inline void Order::set_percentoffset(double value) {
  _internal_set_percentoffset(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.percentOffset)
}

// double trailingPercent = 22;
inline bool Order::_internal_has_trailingpercent() const {
  bool value = (_has_bits_[1] & 0x20000000u) != 0;
  return value;
}
inline bool Order::has_trailingpercent() const {
  return _internal_has_trailingpercent();
}
inline void Order::clear_trailingpercent() {
  trailingpercent_ = 0;
  _has_bits_[1] &= ~0x20000000u;
}
inline double Order::_internal_trailingpercent() const {
  return trailingpercent_;
}
inline double Order::trailingpercent() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.trailingPercent)
  return _internal_trailingpercent();
}
inline void Order::_internal_set_trailingpercent(double value) {
  _has_bits_[1] |= 0x20000000u;
  trailingpercent_ = value;
}
inline void Order::set_trailingpercent(double value) {
  _internal_set_trailingpercent(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.trailingPercent)
}

// double trailStopPrice = 23;
inline bool Order::_internal_has_trailstopprice() const {
  bool value = (_has_bits_[1] & 0x40000000u) != 0;
  return value;
}
inline bool Order::has_trailstopprice() const {
  return _internal_has_trailstopprice();
}
inline void Order::clear_trailstopprice() {
  trailstopprice_ = 0;
  _has_bits_[1] &= ~0x40000000u;
}
inline double Order::_internal_trailstopprice() const {
  return trailstopprice_;
}
inline double Order::trailstopprice() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.trailStopPrice)
  return _internal_trailstopprice();
}
inline void Order::_internal_set_trailstopprice(double value) {
  _has_bits_[1] |= 0x40000000u;
  trailstopprice_ = value;
}
inline void Order::set_trailstopprice(double value) {
  _internal_set_trailstopprice(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.trailStopPrice)
}

// int32 minQty = 24;
inline bool Order::_internal_has_minqty() const {
  bool value = (_has_bits_[1] & 0x08000000u) != 0;
  return value;
}
inline bool Order::has_minqty() const {
  return _internal_has_minqty();
}
inline void Order::clear_minqty() {
  minqty_ = 0;
  _has_bits_[1] &= ~0x08000000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::_internal_minqty() const {
  return minqty_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::minqty() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.minQty)
  return _internal_minqty();
}
inline void Order::_internal_set_minqty(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[1] |= 0x08000000u;
  minqty_ = value;
}
inline void Order::set_minqty(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_minqty(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.minQty)
}

// string goodAfterTime = 25;
inline bool Order::_internal_has_goodaftertime() const {
  bool value = (_has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool Order::has_goodaftertime() const {
  return _internal_has_goodaftertime();
}
inline void Order::clear_goodaftertime() {
  goodaftertime_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000100u;
}
inline const std::string& Order::goodaftertime() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.goodAfterTime)
  return _internal_goodaftertime();
}
inline void Order::set_goodaftertime(const std::string& value) {
  _internal_set_goodaftertime(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.goodAfterTime)
}
inline std::string* Order::mutable_goodaftertime() {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.goodAfterTime)
  return _internal_mutable_goodaftertime();
}
inline const std::string& Order::_internal_goodaftertime() const {
  return goodaftertime_.Get();
}
inline void Order::_internal_set_goodaftertime(const std::string& value) {
  _has_bits_[0] |= 0x00000100u;
  goodaftertime_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Order::set_goodaftertime(std::string&& value) {
  _has_bits_[0] |= 0x00000100u;
  goodaftertime_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Order.goodAfterTime)
}
inline void Order::set_goodaftertime(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000100u;
  goodaftertime_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Order.goodAfterTime)
}
inline void Order::set_goodaftertime(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000100u;
  goodaftertime_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Order.goodAfterTime)
}
inline std::string* Order::_internal_mutable_goodaftertime() {
  _has_bits_[0] |= 0x00000100u;
  return goodaftertime_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Order::release_goodaftertime() {
  // @@protoc_insertion_point(field_release:protobuf.Order.goodAfterTime)
  if (!_internal_has_goodaftertime()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000100u;
  return goodaftertime_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Order::set_allocated_goodaftertime(std::string* goodaftertime) {
  if (goodaftertime != nullptr) {
    _has_bits_[0] |= 0x00000100u;
  } else {
    _has_bits_[0] &= ~0x00000100u;
  }
  goodaftertime_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), goodaftertime,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Order.goodAfterTime)
}
inline std::string* Order::unsafe_arena_release_goodaftertime() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Order.goodAfterTime)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00000100u;
  return goodaftertime_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Order::unsafe_arena_set_allocated_goodaftertime(
    std::string* goodaftertime) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (goodaftertime != nullptr) {
    _has_bits_[0] |= 0x00000100u;
  } else {
    _has_bits_[0] &= ~0x00000100u;
  }
  goodaftertime_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      goodaftertime, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Order.goodAfterTime)
}

// string goodTillDate = 26;
inline bool Order::_internal_has_goodtilldate() const {
  bool value = (_has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool Order::has_goodtilldate() const {
  return _internal_has_goodtilldate();
}
inline void Order::clear_goodtilldate() {
  goodtilldate_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000200u;
}
inline const std::string& Order::goodtilldate() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.goodTillDate)
  return _internal_goodtilldate();
}
inline void Order::set_goodtilldate(const std::string& value) {
  _internal_set_goodtilldate(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.goodTillDate)
}
inline std::string* Order::mutable_goodtilldate() {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.goodTillDate)
  return _internal_mutable_goodtilldate();
}
inline const std::string& Order::_internal_goodtilldate() const {
  return goodtilldate_.Get();
}
inline void Order::_internal_set_goodtilldate(const std::string& value) {
  _has_bits_[0] |= 0x00000200u;
  goodtilldate_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Order::set_goodtilldate(std::string&& value) {
  _has_bits_[0] |= 0x00000200u;
  goodtilldate_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Order.goodTillDate)
}
inline void Order::set_goodtilldate(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000200u;
  goodtilldate_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Order.goodTillDate)
}
inline void Order::set_goodtilldate(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000200u;
  goodtilldate_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Order.goodTillDate)
}
inline std::string* Order::_internal_mutable_goodtilldate() {
  _has_bits_[0] |= 0x00000200u;
  return goodtilldate_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Order::release_goodtilldate() {
  // @@protoc_insertion_point(field_release:protobuf.Order.goodTillDate)
  if (!_internal_has_goodtilldate()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000200u;
  return goodtilldate_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Order::set_allocated_goodtilldate(std::string* goodtilldate) {
  if (goodtilldate != nullptr) {
    _has_bits_[0] |= 0x00000200u;
  } else {
    _has_bits_[0] &= ~0x00000200u;
  }
  goodtilldate_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), goodtilldate,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Order.goodTillDate)
}
inline std::string* Order::unsafe_arena_release_goodtilldate() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Order.goodTillDate)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00000200u;
  return goodtilldate_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Order::unsafe_arena_set_allocated_goodtilldate(
    std::string* goodtilldate) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (goodtilldate != nullptr) {
    _has_bits_[0] |= 0x00000200u;
  } else {
    _has_bits_[0] &= ~0x00000200u;
  }
  goodtilldate_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      goodtilldate, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Order.goodTillDate)
}

// string ocaGroup = 27;
inline bool Order::_internal_has_ocagroup() const {
  bool value = (_has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool Order::has_ocagroup() const {
  return _internal_has_ocagroup();
}
inline void Order::clear_ocagroup() {
  ocagroup_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000400u;
}
inline const std::string& Order::ocagroup() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.ocaGroup)
  return _internal_ocagroup();
}
inline void Order::set_ocagroup(const std::string& value) {
  _internal_set_ocagroup(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.ocaGroup)
}
inline std::string* Order::mutable_ocagroup() {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.ocaGroup)
  return _internal_mutable_ocagroup();
}
inline const std::string& Order::_internal_ocagroup() const {
  return ocagroup_.Get();
}
inline void Order::_internal_set_ocagroup(const std::string& value) {
  _has_bits_[0] |= 0x00000400u;
  ocagroup_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Order::set_ocagroup(std::string&& value) {
  _has_bits_[0] |= 0x00000400u;
  ocagroup_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Order.ocaGroup)
}
inline void Order::set_ocagroup(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000400u;
  ocagroup_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Order.ocaGroup)
}
inline void Order::set_ocagroup(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000400u;
  ocagroup_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Order.ocaGroup)
}
inline std::string* Order::_internal_mutable_ocagroup() {
  _has_bits_[0] |= 0x00000400u;
  return ocagroup_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Order::release_ocagroup() {
  // @@protoc_insertion_point(field_release:protobuf.Order.ocaGroup)
  if (!_internal_has_ocagroup()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000400u;
  return ocagroup_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Order::set_allocated_ocagroup(std::string* ocagroup) {
  if (ocagroup != nullptr) {
    _has_bits_[0] |= 0x00000400u;
  } else {
    _has_bits_[0] &= ~0x00000400u;
  }
  ocagroup_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ocagroup,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Order.ocaGroup)
}
inline std::string* Order::unsafe_arena_release_ocagroup() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Order.ocaGroup)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00000400u;
  return ocagroup_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Order::unsafe_arena_set_allocated_ocagroup(
    std::string* ocagroup) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (ocagroup != nullptr) {
    _has_bits_[0] |= 0x00000400u;
  } else {
    _has_bits_[0] &= ~0x00000400u;
  }
  ocagroup_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ocagroup, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Order.ocaGroup)
}

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

// string rule80A = 29;
inline bool Order::_internal_has_rule80a() const {
  bool value = (_has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool Order::has_rule80a() const {
  return _internal_has_rule80a();
}
inline void Order::clear_rule80a() {
  rule80a_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00001000u;
}
inline const std::string& Order::rule80a() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.rule80A)
  return _internal_rule80a();
}
inline void Order::set_rule80a(const std::string& value) {
  _internal_set_rule80a(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.rule80A)
}
inline std::string* Order::mutable_rule80a() {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.rule80A)
  return _internal_mutable_rule80a();
}
inline const std::string& Order::_internal_rule80a() const {
  return rule80a_.Get();
}
inline void Order::_internal_set_rule80a(const std::string& value) {
  _has_bits_[0] |= 0x00001000u;
  rule80a_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Order::set_rule80a(std::string&& value) {
  _has_bits_[0] |= 0x00001000u;
  rule80a_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Order.rule80A)
}
inline void Order::set_rule80a(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00001000u;
  rule80a_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Order.rule80A)
}
inline void Order::set_rule80a(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00001000u;
  rule80a_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Order.rule80A)
}
inline std::string* Order::_internal_mutable_rule80a() {
  _has_bits_[0] |= 0x00001000u;
  return rule80a_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Order::release_rule80a() {
  // @@protoc_insertion_point(field_release:protobuf.Order.rule80A)
  if (!_internal_has_rule80a()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00001000u;
  return rule80a_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Order::set_allocated_rule80a(std::string* rule80a) {
  if (rule80a != nullptr) {
    _has_bits_[0] |= 0x00001000u;
  } else {
    _has_bits_[0] &= ~0x00001000u;
  }
  rule80a_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), rule80a,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Order.rule80A)
}
inline std::string* Order::unsafe_arena_release_rule80a() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Order.rule80A)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00001000u;
  return rule80a_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Order::unsafe_arena_set_allocated_rule80a(
    std::string* rule80a) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (rule80a != nullptr) {
    _has_bits_[0] |= 0x00001000u;
  } else {
    _has_bits_[0] &= ~0x00001000u;
  }
  rule80a_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      rule80a, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Order.rule80A)
}

// int32 ocaType = 30;
inline bool Order::_internal_has_ocatype() const {
  bool value = (_has_bits_[1] & 0x80000000u) != 0;
  return value;
}
inline bool Order::has_ocatype() const {
  return _internal_has_ocatype();
}
inline void Order::clear_ocatype() {
  ocatype_ = 0;
  _has_bits_[1] &= ~0x80000000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::_internal_ocatype() const {
  return ocatype_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::ocatype() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.ocaType)
  return _internal_ocatype();
}
inline void Order::_internal_set_ocatype(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[1] |= 0x80000000u;
  ocatype_ = value;
}
inline void Order::set_ocatype(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_ocatype(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.ocaType)
}

// int32 triggerMethod = 31;
inline bool Order::_internal_has_triggermethod() const {
  bool value = (_has_bits_[2] & 0x00000001u) != 0;
  return value;
}
inline bool Order::has_triggermethod() const {
  return _internal_has_triggermethod();
}
inline void Order::clear_triggermethod() {
  triggermethod_ = 0;
  _has_bits_[2] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::_internal_triggermethod() const {
  return triggermethod_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::triggermethod() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.triggerMethod)
  return _internal_triggermethod();
}
inline void Order::_internal_set_triggermethod(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[2] |= 0x00000001u;
  triggermethod_ = value;
}
inline void Order::set_triggermethod(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_triggermethod(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.triggerMethod)
}

// string activeStartTime = 32;
inline bool Order::_internal_has_activestarttime() const {
  bool value = (_has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool Order::has_activestarttime() const {
  return _internal_has_activestarttime();
}
inline void Order::clear_activestarttime() {
  activestarttime_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00002000u;
}
inline const std::string& Order::activestarttime() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.activeStartTime)
  return _internal_activestarttime();
}
inline void Order::set_activestarttime(const std::string& value) {
  _internal_set_activestarttime(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.activeStartTime)
}
inline std::string* Order::mutable_activestarttime() {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.activeStartTime)
  return _internal_mutable_activestarttime();
}
inline const std::string& Order::_internal_activestarttime() const {
  return activestarttime_.Get();
}
inline void Order::_internal_set_activestarttime(const std::string& value) {
  _has_bits_[0] |= 0x00002000u;
  activestarttime_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Order::set_activestarttime(std::string&& value) {
  _has_bits_[0] |= 0x00002000u;
  activestarttime_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Order.activeStartTime)
}
inline void Order::set_activestarttime(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00002000u;
  activestarttime_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Order.activeStartTime)
}
inline void Order::set_activestarttime(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00002000u;
  activestarttime_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Order.activeStartTime)
}
inline std::string* Order::_internal_mutable_activestarttime() {
  _has_bits_[0] |= 0x00002000u;
  return activestarttime_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Order::release_activestarttime() {
  // @@protoc_insertion_point(field_release:protobuf.Order.activeStartTime)
  if (!_internal_has_activestarttime()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00002000u;
  return activestarttime_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Order::set_allocated_activestarttime(std::string* activestarttime) {
  if (activestarttime != nullptr) {
    _has_bits_[0] |= 0x00002000u;
  } else {
    _has_bits_[0] &= ~0x00002000u;
  }
  activestarttime_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), activestarttime,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Order.activeStartTime)
}
inline std::string* Order::unsafe_arena_release_activestarttime() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Order.activeStartTime)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00002000u;
  return activestarttime_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Order::unsafe_arena_set_allocated_activestarttime(
    std::string* activestarttime) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (activestarttime != nullptr) {
    _has_bits_[0] |= 0x00002000u;
  } else {
    _has_bits_[0] &= ~0x00002000u;
  }
  activestarttime_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      activestarttime, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Order.activeStartTime)
}

// string activeStopTime = 33;
inline bool Order::_internal_has_activestoptime() const {
  bool value = (_has_bits_[0] & 0x00004000u) != 0;
  return value;
}
inline bool Order::has_activestoptime() const {
  return _internal_has_activestoptime();
}
inline void Order::clear_activestoptime() {
  activestoptime_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00004000u;
}
inline const std::string& Order::activestoptime() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.activeStopTime)
  return _internal_activestoptime();
}
inline void Order::set_activestoptime(const std::string& value) {
  _internal_set_activestoptime(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.activeStopTime)
}
inline std::string* Order::mutable_activestoptime() {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.activeStopTime)
  return _internal_mutable_activestoptime();
}
inline const std::string& Order::_internal_activestoptime() const {
  return activestoptime_.Get();
}
inline void Order::_internal_set_activestoptime(const std::string& value) {
  _has_bits_[0] |= 0x00004000u;
  activestoptime_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Order::set_activestoptime(std::string&& value) {
  _has_bits_[0] |= 0x00004000u;
  activestoptime_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Order.activeStopTime)
}
inline void Order::set_activestoptime(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00004000u;
  activestoptime_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Order.activeStopTime)
}
inline void Order::set_activestoptime(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00004000u;
  activestoptime_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Order.activeStopTime)
}
inline std::string* Order::_internal_mutable_activestoptime() {
  _has_bits_[0] |= 0x00004000u;
  return activestoptime_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Order::release_activestoptime() {
  // @@protoc_insertion_point(field_release:protobuf.Order.activeStopTime)
  if (!_internal_has_activestoptime()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00004000u;
  return activestoptime_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Order::set_allocated_activestoptime(std::string* activestoptime) {
  if (activestoptime != nullptr) {
    _has_bits_[0] |= 0x00004000u;
  } else {
    _has_bits_[0] &= ~0x00004000u;
  }
  activestoptime_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), activestoptime,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Order.activeStopTime)
}
inline std::string* Order::unsafe_arena_release_activestoptime() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Order.activeStopTime)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00004000u;
  return activestoptime_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Order::unsafe_arena_set_allocated_activestoptime(
    std::string* activestoptime) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (activestoptime != nullptr) {
    _has_bits_[0] |= 0x00004000u;
  } else {
    _has_bits_[0] &= ~0x00004000u;
  }
  activestoptime_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      activestoptime, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Order.activeStopTime)
}

// string faGroup = 34;
inline bool Order::_internal_has_fagroup() const {
  bool value = (_has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline bool Order::has_fagroup() const {
  return _internal_has_fagroup();
}
inline void Order::clear_fagroup() {
  fagroup_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00008000u;
}
inline const std::string& Order::fagroup() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.faGroup)
  return _internal_fagroup();
}
inline void Order::set_fagroup(const std::string& value) {
  _internal_set_fagroup(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.faGroup)
}
inline std::string* Order::mutable_fagroup() {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.faGroup)
  return _internal_mutable_fagroup();
}
inline const std::string& Order::_internal_fagroup() const {
  return fagroup_.Get();
}
inline void Order::_internal_set_fagroup(const std::string& value) {
  _has_bits_[0] |= 0x00008000u;
  fagroup_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Order::set_fagroup(std::string&& value) {
  _has_bits_[0] |= 0x00008000u;
  fagroup_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Order.faGroup)
}
inline void Order::set_fagroup(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00008000u;
  fagroup_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Order.faGroup)
}
inline void Order::set_fagroup(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00008000u;
  fagroup_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Order.faGroup)
}
inline std::string* Order::_internal_mutable_fagroup() {
  _has_bits_[0] |= 0x00008000u;
  return fagroup_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Order::release_fagroup() {
  // @@protoc_insertion_point(field_release:protobuf.Order.faGroup)
  if (!_internal_has_fagroup()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00008000u;
  return fagroup_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Order::set_allocated_fagroup(std::string* fagroup) {
  if (fagroup != nullptr) {
    _has_bits_[0] |= 0x00008000u;
  } else {
    _has_bits_[0] &= ~0x00008000u;
  }
  fagroup_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), fagroup,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Order.faGroup)
}
inline std::string* Order::unsafe_arena_release_fagroup() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Order.faGroup)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00008000u;
  return fagroup_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Order::unsafe_arena_set_allocated_fagroup(
    std::string* fagroup) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (fagroup != nullptr) {
    _has_bits_[0] |= 0x00008000u;
  } else {
    _has_bits_[0] &= ~0x00008000u;
  }
  fagroup_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      fagroup, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Order.faGroup)
}

// string faMethod = 35;
inline bool Order::_internal_has_famethod() const {
  bool value = (_has_bits_[0] & 0x00010000u) != 0;
  return value;
}
inline bool Order::has_famethod() const {
  return _internal_has_famethod();
}
inline void Order::clear_famethod() {
  famethod_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00010000u;
}
inline const std::string& Order::famethod() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.faMethod)
  return _internal_famethod();
}
inline void Order::set_famethod(const std::string& value) {
  _internal_set_famethod(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.faMethod)
}
inline std::string* Order::mutable_famethod() {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.faMethod)
  return _internal_mutable_famethod();
}
inline const std::string& Order::_internal_famethod() const {
  return famethod_.Get();
}
inline void Order::_internal_set_famethod(const std::string& value) {
  _has_bits_[0] |= 0x00010000u;
  famethod_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Order::set_famethod(std::string&& value) {
  _has_bits_[0] |= 0x00010000u;
  famethod_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Order.faMethod)
}
inline void Order::set_famethod(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00010000u;
  famethod_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Order.faMethod)
}
inline void Order::set_famethod(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00010000u;
  famethod_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Order.faMethod)
}
inline std::string* Order::_internal_mutable_famethod() {
  _has_bits_[0] |= 0x00010000u;
  return famethod_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Order::release_famethod() {
  // @@protoc_insertion_point(field_release:protobuf.Order.faMethod)
  if (!_internal_has_famethod()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00010000u;
  return famethod_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Order::set_allocated_famethod(std::string* famethod) {
  if (famethod != nullptr) {
    _has_bits_[0] |= 0x00010000u;
  } else {
    _has_bits_[0] &= ~0x00010000u;
  }
  famethod_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), famethod,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Order.faMethod)
}
inline std::string* Order::unsafe_arena_release_famethod() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Order.faMethod)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00010000u;
  return famethod_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Order::unsafe_arena_set_allocated_famethod(
    std::string* famethod) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (famethod != nullptr) {
    _has_bits_[0] |= 0x00010000u;
  } else {
    _has_bits_[0] &= ~0x00010000u;
  }
  famethod_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      famethod, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Order.faMethod)
}

// string faPercentage = 36;
inline bool Order::_internal_has_fapercentage() const {
  bool value = (_has_bits_[0] & 0x00020000u) != 0;
  return value;
}
inline bool Order::has_fapercentage() const {
  return _internal_has_fapercentage();
}
inline void Order::clear_fapercentage() {
  fapercentage_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00020000u;
}
inline const std::string& Order::fapercentage() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.faPercentage)
  return _internal_fapercentage();
}
inline void Order::set_fapercentage(const std::string& value) {
  _internal_set_fapercentage(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.faPercentage)
}
inline std::string* Order::mutable_fapercentage() {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.faPercentage)
  return _internal_mutable_fapercentage();
}
inline const std::string& Order::_internal_fapercentage() const {
  return fapercentage_.Get();
}
inline void Order::_internal_set_fapercentage(const std::string& value) {
  _has_bits_[0] |= 0x00020000u;
  fapercentage_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Order::set_fapercentage(std::string&& value) {
  _has_bits_[0] |= 0x00020000u;
  fapercentage_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Order.faPercentage)
}
inline void Order::set_fapercentage(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00020000u;
  fapercentage_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Order.faPercentage)
}
inline void Order::set_fapercentage(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00020000u;
  fapercentage_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Order.faPercentage)
}
inline std::string* Order::_internal_mutable_fapercentage() {
  _has_bits_[0] |= 0x00020000u;
  return fapercentage_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Order::release_fapercentage() {
  // @@protoc_insertion_point(field_release:protobuf.Order.faPercentage)
  if (!_internal_has_fapercentage()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00020000u;
  return fapercentage_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Order::set_allocated_fapercentage(std::string* fapercentage) {
  if (fapercentage != nullptr) {
    _has_bits_[0] |= 0x00020000u;
  } else {
    _has_bits_[0] &= ~0x00020000u;
  }
  fapercentage_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), fapercentage,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Order.faPercentage)
}
inline std::string* Order::unsafe_arena_release_fapercentage() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Order.faPercentage)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00020000u;
  return fapercentage_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Order::unsafe_arena_set_allocated_fapercentage(
    std::string* fapercentage) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (fapercentage != nullptr) {
    _has_bits_[0] |= 0x00020000u;
  } else {
    _has_bits_[0] &= ~0x00020000u;
  }
  fapercentage_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      fapercentage, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Order.faPercentage)
}

// double volatility = 37;
inline bool Order::_internal_has_volatility() const {
  bool value = (_has_bits_[2] & 0x00000002u) != 0;
  return value;
}
inline bool Order::has_volatility() const {
  return _internal_has_volatility();
}
inline void Order::clear_volatility() {
  volatility_ = 0;
  _has_bits_[2] &= ~0x00000002u;
}
inline double Order::_internal_volatility() const {
  return volatility_;
}
inline double Order::volatility() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.volatility)
  return _internal_volatility();
}
inline void Order::_internal_set_volatility(double value) {
  _has_bits_[2] |= 0x00000002u;
  volatility_ = value;
}
inline void Order::set_volatility(double value) {
  _internal_set_volatility(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.volatility)
}

// int32 volatilityType = 38;
inline bool Order::_internal_has_volatilitytype() const {
  bool value = (_has_bits_[2] & 0x00000004u) != 0;
  return value;
}
inline bool Order::has_volatilitytype() const {
  return _internal_has_volatilitytype();
}
inline void Order::clear_volatilitytype() {
  volatilitytype_ = 0;
  _has_bits_[2] &= ~0x00000004u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::_internal_volatilitytype() const {
  return volatilitytype_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::volatilitytype() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.volatilityType)
  return _internal_volatilitytype();
}
inline void Order::_internal_set_volatilitytype(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[2] |= 0x00000004u;
  volatilitytype_ = value;
}
inline void Order::set_volatilitytype(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_volatilitytype(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.volatilityType)
}

// bool continuousUpdate = 39;
inline bool Order::_internal_has_continuousupdate() const {
  bool value = (_has_bits_[2] & 0x00000010u) != 0;
  return value;
}
inline bool Order::has_continuousupdate() const {
  return _internal_has_continuousupdate();
}
inline void Order::clear_continuousupdate() {
  continuousupdate_ = false;
  _has_bits_[2] &= ~0x00000010u;
}
inline bool Order::_internal_continuousupdate() const {
  return continuousupdate_;
}
inline bool Order::continuousupdate() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.continuousUpdate)
  return _internal_continuousupdate();
}
inline void Order::_internal_set_continuousupdate(bool value) {
  _has_bits_[2] |= 0x00000010u;
  continuousupdate_ = value;
}
inline void Order::set_continuousupdate(bool value) {
  _internal_set_continuousupdate(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.continuousUpdate)
}

// int32 referencePriceType = 40;
inline bool Order::_internal_has_referencepricetype() const {
  bool value = (_has_bits_[2] & 0x00000080u) != 0;
  return value;
}
inline bool Order::has_referencepricetype() const {
  return _internal_has_referencepricetype();
}
inline void Order::clear_referencepricetype() {
  referencepricetype_ = 0;
  _has_bits_[2] &= ~0x00000080u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::_internal_referencepricetype() const {
  return referencepricetype_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::referencepricetype() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.referencePriceType)
  return _internal_referencepricetype();
}
inline void Order::_internal_set_referencepricetype(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[2] |= 0x00000080u;
  referencepricetype_ = value;
}
inline void Order::set_referencepricetype(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_referencepricetype(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.referencePriceType)
}

// string deltaNeutralOrderType = 41;
inline bool Order::_internal_has_deltaneutralordertype() const {
  bool value = (_has_bits_[0] & 0x00040000u) != 0;
  return value;
}
inline bool Order::has_deltaneutralordertype() const {
  return _internal_has_deltaneutralordertype();
}
inline void Order::clear_deltaneutralordertype() {
  deltaneutralordertype_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00040000u;
}
inline const std::string& Order::deltaneutralordertype() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.deltaNeutralOrderType)
  return _internal_deltaneutralordertype();
}
inline void Order::set_deltaneutralordertype(const std::string& value) {
  _internal_set_deltaneutralordertype(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.deltaNeutralOrderType)
}
inline std::string* Order::mutable_deltaneutralordertype() {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.deltaNeutralOrderType)
  return _internal_mutable_deltaneutralordertype();
}
inline const std::string& Order::_internal_deltaneutralordertype() const {
  return deltaneutralordertype_.Get();
}
inline void Order::_internal_set_deltaneutralordertype(const std::string& value) {
  _has_bits_[0] |= 0x00040000u;
  deltaneutralordertype_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Order::set_deltaneutralordertype(std::string&& value) {
  _has_bits_[0] |= 0x00040000u;
  deltaneutralordertype_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Order.deltaNeutralOrderType)
}
inline void Order::set_deltaneutralordertype(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00040000u;
  deltaneutralordertype_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Order.deltaNeutralOrderType)
}
inline void Order::set_deltaneutralordertype(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00040000u;
  deltaneutralordertype_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Order.deltaNeutralOrderType)
}
inline std::string* Order::_internal_mutable_deltaneutralordertype() {
  _has_bits_[0] |= 0x00040000u;
  return deltaneutralordertype_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Order::release_deltaneutralordertype() {
  // @@protoc_insertion_point(field_release:protobuf.Order.deltaNeutralOrderType)
  if (!_internal_has_deltaneutralordertype()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00040000u;
  return deltaneutralordertype_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Order::set_allocated_deltaneutralordertype(std::string* deltaneutralordertype) {
  if (deltaneutralordertype != nullptr) {
    _has_bits_[0] |= 0x00040000u;
  } else {
    _has_bits_[0] &= ~0x00040000u;
  }
  deltaneutralordertype_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), deltaneutralordertype,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Order.deltaNeutralOrderType)
}
inline std::string* Order::unsafe_arena_release_deltaneutralordertype() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Order.deltaNeutralOrderType)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00040000u;
  return deltaneutralordertype_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Order::unsafe_arena_set_allocated_deltaneutralordertype(
    std::string* deltaneutralordertype) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (deltaneutralordertype != nullptr) {
    _has_bits_[0] |= 0x00040000u;
  } else {
    _has_bits_[0] &= ~0x00040000u;
  }
  deltaneutralordertype_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      deltaneutralordertype, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Order.deltaNeutralOrderType)
}

// double deltaNeutralAuxPrice = 42;
inline bool Order::_internal_has_deltaneutralauxprice() const {
  bool value = (_has_bits_[2] & 0x00000200u) != 0;
  return value;
}
inline bool Order::has_deltaneutralauxprice() const {
  return _internal_has_deltaneutralauxprice();
}
inline void Order::clear_deltaneutralauxprice() {
  deltaneutralauxprice_ = 0;
  _has_bits_[2] &= ~0x00000200u;
}
inline double Order::_internal_deltaneutralauxprice() const {
  return deltaneutralauxprice_;
}
inline double Order::deltaneutralauxprice() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.deltaNeutralAuxPrice)
  return _internal_deltaneutralauxprice();
}
inline void Order::_internal_set_deltaneutralauxprice(double value) {
  _has_bits_[2] |= 0x00000200u;
  deltaneutralauxprice_ = value;
}
inline void Order::set_deltaneutralauxprice(double value) {
  _internal_set_deltaneutralauxprice(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.deltaNeutralAuxPrice)
}

// int32 deltaNeutralConId = 43;
inline bool Order::_internal_has_deltaneutralconid() const {
  bool value = (_has_bits_[2] & 0x00000100u) != 0;
  return value;
}
inline bool Order::has_deltaneutralconid() const {
  return _internal_has_deltaneutralconid();
}
inline void Order::clear_deltaneutralconid() {
  deltaneutralconid_ = 0;
  _has_bits_[2] &= ~0x00000100u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::_internal_deltaneutralconid() const {
  return deltaneutralconid_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::deltaneutralconid() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.deltaNeutralConId)
  return _internal_deltaneutralconid();
}
inline void Order::_internal_set_deltaneutralconid(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[2] |= 0x00000100u;
  deltaneutralconid_ = value;
}
inline void Order::set_deltaneutralconid(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_deltaneutralconid(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.deltaNeutralConId)
}

// string deltaNeutralOpenClose = 44;
inline bool Order::_internal_has_deltaneutralopenclose() const {
  bool value = (_has_bits_[0] & 0x00080000u) != 0;
  return value;
}
inline bool Order::has_deltaneutralopenclose() const {
  return _internal_has_deltaneutralopenclose();
}
inline void Order::clear_deltaneutralopenclose() {
  deltaneutralopenclose_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00080000u;
}
inline const std::string& Order::deltaneutralopenclose() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.deltaNeutralOpenClose)
  return _internal_deltaneutralopenclose();
}
inline void Order::set_deltaneutralopenclose(const std::string& value) {
  _internal_set_deltaneutralopenclose(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.deltaNeutralOpenClose)
}
inline std::string* Order::mutable_deltaneutralopenclose() {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.deltaNeutralOpenClose)
  return _internal_mutable_deltaneutralopenclose();
}
inline const std::string& Order::_internal_deltaneutralopenclose() const {
  return deltaneutralopenclose_.Get();
}
inline void Order::_internal_set_deltaneutralopenclose(const std::string& value) {
  _has_bits_[0] |= 0x00080000u;
  deltaneutralopenclose_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Order::set_deltaneutralopenclose(std::string&& value) {
  _has_bits_[0] |= 0x00080000u;
  deltaneutralopenclose_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Order.deltaNeutralOpenClose)
}
inline void Order::set_deltaneutralopenclose(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00080000u;
  deltaneutralopenclose_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Order.deltaNeutralOpenClose)
}
inline void Order::set_deltaneutralopenclose(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00080000u;
  deltaneutralopenclose_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Order.deltaNeutralOpenClose)
}
inline std::string* Order::_internal_mutable_deltaneutralopenclose() {
  _has_bits_[0] |= 0x00080000u;
  return deltaneutralopenclose_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Order::release_deltaneutralopenclose() {
  // @@protoc_insertion_point(field_release:protobuf.Order.deltaNeutralOpenClose)
  if (!_internal_has_deltaneutralopenclose()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00080000u;
  return deltaneutralopenclose_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Order::set_allocated_deltaneutralopenclose(std::string* deltaneutralopenclose) {
  if (deltaneutralopenclose != nullptr) {
    _has_bits_[0] |= 0x00080000u;
  } else {
    _has_bits_[0] &= ~0x00080000u;
  }
  deltaneutralopenclose_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), deltaneutralopenclose,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Order.deltaNeutralOpenClose)
}
inline std::string* Order::unsafe_arena_release_deltaneutralopenclose() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Order.deltaNeutralOpenClose)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00080000u;
  return deltaneutralopenclose_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Order::unsafe_arena_set_allocated_deltaneutralopenclose(
    std::string* deltaneutralopenclose) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (deltaneutralopenclose != nullptr) {
    _has_bits_[0] |= 0x00080000u;
  } else {
    _has_bits_[0] &= ~0x00080000u;
  }
  deltaneutralopenclose_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      deltaneutralopenclose, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Order.deltaNeutralOpenClose)
}

// bool deltaNeutralShortSale = 45;
inline bool Order::_internal_has_deltaneutralshortsale() const {
  bool value = (_has_bits_[2] & 0x00000020u) != 0;
  return value;
}
inline bool Order::has_deltaneutralshortsale() const {
  return _internal_has_deltaneutralshortsale();
}
inline void Order::clear_deltaneutralshortsale() {
  deltaneutralshortsale_ = false;
  _has_bits_[2] &= ~0x00000020u;
}
inline bool Order::_internal_deltaneutralshortsale() const {
  return deltaneutralshortsale_;
}
inline bool Order::deltaneutralshortsale() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.deltaNeutralShortSale)
  return _internal_deltaneutralshortsale();
}
inline void Order::_internal_set_deltaneutralshortsale(bool value) {
  _has_bits_[2] |= 0x00000020u;
  deltaneutralshortsale_ = value;
}
inline void Order::set_deltaneutralshortsale(bool value) {
  _internal_set_deltaneutralshortsale(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.deltaNeutralShortSale)
}

// int32 deltaNeutralShortSaleSlot = 46;
inline bool Order::_internal_has_deltaneutralshortsaleslot() const {
  bool value = (_has_bits_[2] & 0x00000400u) != 0;
  return value;
}
inline bool Order::has_deltaneutralshortsaleslot() const {
  return _internal_has_deltaneutralshortsaleslot();
}
inline void Order::clear_deltaneutralshortsaleslot() {
  deltaneutralshortsaleslot_ = 0;
  _has_bits_[2] &= ~0x00000400u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::_internal_deltaneutralshortsaleslot() const {
  return deltaneutralshortsaleslot_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::deltaneutralshortsaleslot() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.deltaNeutralShortSaleSlot)
  return _internal_deltaneutralshortsaleslot();
}
inline void Order::_internal_set_deltaneutralshortsaleslot(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[2] |= 0x00000400u;
  deltaneutralshortsaleslot_ = value;
}
inline void Order::set_deltaneutralshortsaleslot(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_deltaneutralshortsaleslot(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.deltaNeutralShortSaleSlot)
}

// string deltaNeutralDesignatedLocation = 47;
inline bool Order::_internal_has_deltaneutraldesignatedlocation() const {
  bool value = (_has_bits_[0] & 0x00100000u) != 0;
  return value;
}
inline bool Order::has_deltaneutraldesignatedlocation() const {
  return _internal_has_deltaneutraldesignatedlocation();
}
inline void Order::clear_deltaneutraldesignatedlocation() {
  deltaneutraldesignatedlocation_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00100000u;
}
inline const std::string& Order::deltaneutraldesignatedlocation() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.deltaNeutralDesignatedLocation)
  return _internal_deltaneutraldesignatedlocation();
}
inline void Order::set_deltaneutraldesignatedlocation(const std::string& value) {
  _internal_set_deltaneutraldesignatedlocation(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.deltaNeutralDesignatedLocation)
}
inline std::string* Order::mutable_deltaneutraldesignatedlocation() {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.deltaNeutralDesignatedLocation)
  return _internal_mutable_deltaneutraldesignatedlocation();
}
inline const std::string& Order::_internal_deltaneutraldesignatedlocation() const {
  return deltaneutraldesignatedlocation_.Get();
}
inline void Order::_internal_set_deltaneutraldesignatedlocation(const std::string& value) {
  _has_bits_[0] |= 0x00100000u;
  deltaneutraldesignatedlocation_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Order::set_deltaneutraldesignatedlocation(std::string&& value) {
  _has_bits_[0] |= 0x00100000u;
  deltaneutraldesignatedlocation_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Order.deltaNeutralDesignatedLocation)
}
inline void Order::set_deltaneutraldesignatedlocation(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00100000u;
  deltaneutraldesignatedlocation_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Order.deltaNeutralDesignatedLocation)
}
inline void Order::set_deltaneutraldesignatedlocation(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00100000u;
  deltaneutraldesignatedlocation_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Order.deltaNeutralDesignatedLocation)
}
inline std::string* Order::_internal_mutable_deltaneutraldesignatedlocation() {
  _has_bits_[0] |= 0x00100000u;
  return deltaneutraldesignatedlocation_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Order::release_deltaneutraldesignatedlocation() {
  // @@protoc_insertion_point(field_release:protobuf.Order.deltaNeutralDesignatedLocation)
  if (!_internal_has_deltaneutraldesignatedlocation()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00100000u;
  return deltaneutraldesignatedlocation_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Order::set_allocated_deltaneutraldesignatedlocation(std::string* deltaneutraldesignatedlocation) {
  if (deltaneutraldesignatedlocation != nullptr) {
    _has_bits_[0] |= 0x00100000u;
  } else {
    _has_bits_[0] &= ~0x00100000u;
  }
  deltaneutraldesignatedlocation_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), deltaneutraldesignatedlocation,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Order.deltaNeutralDesignatedLocation)
}
inline std::string* Order::unsafe_arena_release_deltaneutraldesignatedlocation() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Order.deltaNeutralDesignatedLocation)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00100000u;
  return deltaneutraldesignatedlocation_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Order::unsafe_arena_set_allocated_deltaneutraldesignatedlocation(
    std::string* deltaneutraldesignatedlocation) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (deltaneutraldesignatedlocation != nullptr) {
    _has_bits_[0] |= 0x00100000u;
  } else {
    _has_bits_[0] &= ~0x00100000u;
  }
  deltaneutraldesignatedlocation_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      deltaneutraldesignatedlocation, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Order.deltaNeutralDesignatedLocation)
}

// int32 scaleInitLevelSize = 48;
inline bool Order::_internal_has_scaleinitlevelsize() const {
  bool value = (_has_bits_[2] & 0x00000800u) != 0;
  return value;
}
inline bool Order::has_scaleinitlevelsize() const {
  return _internal_has_scaleinitlevelsize();
}
inline void Order::clear_scaleinitlevelsize() {
  scaleinitlevelsize_ = 0;
  _has_bits_[2] &= ~0x00000800u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::_internal_scaleinitlevelsize() const {
  return scaleinitlevelsize_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::scaleinitlevelsize() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.scaleInitLevelSize)
  return _internal_scaleinitlevelsize();
}
inline void Order::_internal_set_scaleinitlevelsize(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[2] |= 0x00000800u;
  scaleinitlevelsize_ = value;
}
inline void Order::set_scaleinitlevelsize(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_scaleinitlevelsize(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.scaleInitLevelSize)
}

// int32 scaleSubsLevelSize = 49;
inline bool Order::_internal_has_scalesubslevelsize() const {
  bool value = (_has_bits_[2] & 0x00002000u) != 0;
  return value;
}
inline bool Order::has_scalesubslevelsize() const {
  return _internal_has_scalesubslevelsize();
}
inline void Order::clear_scalesubslevelsize() {
  scalesubslevelsize_ = 0;
  _has_bits_[2] &= ~0x00002000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::_internal_scalesubslevelsize() const {
  return scalesubslevelsize_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::scalesubslevelsize() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.scaleSubsLevelSize)
  return _internal_scalesubslevelsize();
}
inline void Order::_internal_set_scalesubslevelsize(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[2] |= 0x00002000u;
  scalesubslevelsize_ = value;
}
inline void Order::set_scalesubslevelsize(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_scalesubslevelsize(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.scaleSubsLevelSize)
}

// double scalePriceIncrement = 50;
inline bool Order::_internal_has_scalepriceincrement() const {
  bool value = (_has_bits_[2] & 0x00001000u) != 0;
  return value;
}
inline bool Order::has_scalepriceincrement() const {
  return _internal_has_scalepriceincrement();
}
inline void Order::clear_scalepriceincrement() {
  scalepriceincrement_ = 0;
  _has_bits_[2] &= ~0x00001000u;
}
inline double Order::_internal_scalepriceincrement() const {
  return scalepriceincrement_;
}
inline double Order::scalepriceincrement() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.scalePriceIncrement)
  return _internal_scalepriceincrement();
}
inline void Order::_internal_set_scalepriceincrement(double value) {
  _has_bits_[2] |= 0x00001000u;
  scalepriceincrement_ = value;
}
inline void Order::set_scalepriceincrement(double value) {
  _internal_set_scalepriceincrement(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.scalePriceIncrement)
}

// double scalePriceAdjustValue = 51;
inline bool Order::_internal_has_scalepriceadjustvalue() const {
  bool value = (_has_bits_[2] & 0x00008000u) != 0;
  return value;
}
inline bool Order::has_scalepriceadjustvalue() const {
  return _internal_has_scalepriceadjustvalue();
}
inline void Order::clear_scalepriceadjustvalue() {
  scalepriceadjustvalue_ = 0;
  _has_bits_[2] &= ~0x00008000u;
}
inline double Order::_internal_scalepriceadjustvalue() const {
  return scalepriceadjustvalue_;
}
inline double Order::scalepriceadjustvalue() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.scalePriceAdjustValue)
  return _internal_scalepriceadjustvalue();
}
inline void Order::_internal_set_scalepriceadjustvalue(double value) {
  _has_bits_[2] |= 0x00008000u;
  scalepriceadjustvalue_ = value;
}
inline void Order::set_scalepriceadjustvalue(double value) {
  _internal_set_scalepriceadjustvalue(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.scalePriceAdjustValue)
}

// int32 scalePriceAdjustInterval = 52;
inline bool Order::_internal_has_scalepriceadjustinterval() const {
  bool value = (_has_bits_[2] & 0x00004000u) != 0;
  return value;
}
inline bool Order::has_scalepriceadjustinterval() const {
  return _internal_has_scalepriceadjustinterval();
}
inline void Order::clear_scalepriceadjustinterval() {
  scalepriceadjustinterval_ = 0;
  _has_bits_[2] &= ~0x00004000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::_internal_scalepriceadjustinterval() const {
  return scalepriceadjustinterval_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::scalepriceadjustinterval() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.scalePriceAdjustInterval)
  return _internal_scalepriceadjustinterval();
}
inline void Order::_internal_set_scalepriceadjustinterval(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[2] |= 0x00004000u;
  scalepriceadjustinterval_ = value;
}
inline void Order::set_scalepriceadjustinterval(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_scalepriceadjustinterval(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.scalePriceAdjustInterval)
}

// double scaleProfitOffset = 53;
inline bool Order::_internal_has_scaleprofitoffset() const {
  bool value = (_has_bits_[2] & 0x00010000u) != 0;
  return value;
}
inline bool Order::has_scaleprofitoffset() const {
  return _internal_has_scaleprofitoffset();
}
inline void Order::clear_scaleprofitoffset() {
  scaleprofitoffset_ = 0;
  _has_bits_[2] &= ~0x00010000u;
}
inline double Order::_internal_scaleprofitoffset() const {
  return scaleprofitoffset_;
}
inline double Order::scaleprofitoffset() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.scaleProfitOffset)
  return _internal_scaleprofitoffset();
}
inline void Order::_internal_set_scaleprofitoffset(double value) {
  _has_bits_[2] |= 0x00010000u;
  scaleprofitoffset_ = value;
}
inline void Order::set_scaleprofitoffset(double value) {
  _internal_set_scaleprofitoffset(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.scaleProfitOffset)
}

// bool scaleAutoReset = 54;
inline bool Order::_internal_has_scaleautoreset() const {
  bool value = (_has_bits_[2] & 0x00000040u) != 0;
  return value;
}
inline bool Order::has_scaleautoreset() const {
  return _internal_has_scaleautoreset();
}
inline void Order::clear_scaleautoreset() {
  scaleautoreset_ = false;
  _has_bits_[2] &= ~0x00000040u;
}
inline bool Order::_internal_scaleautoreset() const {
  return scaleautoreset_;
}
inline bool Order::scaleautoreset() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.scaleAutoReset)
  return _internal_scaleautoreset();
}
inline void Order::_internal_set_scaleautoreset(bool value) {
  _has_bits_[2] |= 0x00000040u;
  scaleautoreset_ = value;
}
inline void Order::set_scaleautoreset(bool value) {
  _internal_set_scaleautoreset(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.scaleAutoReset)
}

// int32 scaleInitPosition = 55;
inline bool Order::_internal_has_scaleinitposition() const {
  bool value = (_has_bits_[2] & 0x00020000u) != 0;
  return value;
}
inline bool Order::has_scaleinitposition() const {
  return _internal_has_scaleinitposition();
}
inline void Order::clear_scaleinitposition() {
  scaleinitposition_ = 0;
  _has_bits_[2] &= ~0x00020000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::_internal_scaleinitposition() const {
  return scaleinitposition_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::scaleinitposition() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.scaleInitPosition)
  return _internal_scaleinitposition();
}
inline void Order::_internal_set_scaleinitposition(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[2] |= 0x00020000u;
  scaleinitposition_ = value;
}
inline void Order::set_scaleinitposition(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_scaleinitposition(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.scaleInitPosition)
}

// int32 scaleInitFillQty = 56;
inline bool Order::_internal_has_scaleinitfillqty() const {
  bool value = (_has_bits_[2] & 0x00040000u) != 0;
  return value;
}
inline bool Order::has_scaleinitfillqty() const {
  return _internal_has_scaleinitfillqty();
}
inline void Order::clear_scaleinitfillqty() {
  scaleinitfillqty_ = 0;
  _has_bits_[2] &= ~0x00040000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::_internal_scaleinitfillqty() const {
  return scaleinitfillqty_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::scaleinitfillqty() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.scaleInitFillQty)
  return _internal_scaleinitfillqty();
}
inline void Order::_internal_set_scaleinitfillqty(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[2] |= 0x00040000u;
  scaleinitfillqty_ = value;
}
inline void Order::set_scaleinitfillqty(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_scaleinitfillqty(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.scaleInitFillQty)
}

// bool scaleRandomPercent = 57;
inline bool Order::_internal_has_scalerandompercent() const {
  bool value = (_has_bits_[2] & 0x00080000u) != 0;
  return value;
}
inline bool Order::has_scalerandompercent() const {
  return _internal_has_scalerandompercent();
}
inline void Order::clear_scalerandompercent() {
  scalerandompercent_ = false;
  _has_bits_[2] &= ~0x00080000u;
}
inline bool Order::_internal_scalerandompercent() const {
  return scalerandompercent_;
}
inline bool Order::scalerandompercent() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.scaleRandomPercent)
  return _internal_scalerandompercent();
}
inline void Order::_internal_set_scalerandompercent(bool value) {
  _has_bits_[2] |= 0x00080000u;
  scalerandompercent_ = value;
}
inline void Order::set_scalerandompercent(bool value) {
  _internal_set_scalerandompercent(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.scaleRandomPercent)
}

// string scaleTable = 58;
inline bool Order::_internal_has_scaletable() const {
  bool value = (_has_bits_[0] & 0x00200000u) != 0;
  return value;
}
inline bool Order::has_scaletable() const {
  return _internal_has_scaletable();
}
inline void Order::clear_scaletable() {
  scaletable_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00200000u;
}
inline const std::string& Order::scaletable() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.scaleTable)
  return _internal_scaletable();
}
inline void Order::set_scaletable(const std::string& value) {
  _internal_set_scaletable(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.scaleTable)
}
inline std::string* Order::mutable_scaletable() {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.scaleTable)
  return _internal_mutable_scaletable();
}
inline const std::string& Order::_internal_scaletable() const {
  return scaletable_.Get();
}
inline void Order::_internal_set_scaletable(const std::string& value) {
  _has_bits_[0] |= 0x00200000u;
  scaletable_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Order::set_scaletable(std::string&& value) {
  _has_bits_[0] |= 0x00200000u;
  scaletable_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Order.scaleTable)
}
inline void Order::set_scaletable(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00200000u;
  scaletable_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Order.scaleTable)
}
inline void Order::set_scaletable(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00200000u;
  scaletable_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Order.scaleTable)
}
inline std::string* Order::_internal_mutable_scaletable() {
  _has_bits_[0] |= 0x00200000u;
  return scaletable_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Order::release_scaletable() {
  // @@protoc_insertion_point(field_release:protobuf.Order.scaleTable)
  if (!_internal_has_scaletable()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00200000u;
  return scaletable_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Order::set_allocated_scaletable(std::string* scaletable) {
  if (scaletable != nullptr) {
    _has_bits_[0] |= 0x00200000u;
  } else {
    _has_bits_[0] &= ~0x00200000u;
  }
  scaletable_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), scaletable,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Order.scaleTable)
}
inline std::string* Order::unsafe_arena_release_scaletable() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Order.scaleTable)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00200000u;
  return scaletable_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Order::unsafe_arena_set_allocated_scaletable(
    std::string* scaletable) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (scaletable != nullptr) {
    _has_bits_[0] |= 0x00200000u;
  } else {
    _has_bits_[0] &= ~0x00200000u;
  }
  scaletable_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      scaletable, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Order.scaleTable)
}

// string hedgeType = 59;
inline bool Order::_internal_has_hedgetype() const {
  bool value = (_has_bits_[0] & 0x00400000u) != 0;
  return value;
}
inline bool Order::has_hedgetype() const {
  return _internal_has_hedgetype();
}
inline void Order::clear_hedgetype() {
  hedgetype_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00400000u;
}
inline const std::string& Order::hedgetype() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.hedgeType)
  return _internal_hedgetype();
}
inline void Order::set_hedgetype(const std::string& value) {
  _internal_set_hedgetype(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.hedgeType)
}
inline std::string* Order::mutable_hedgetype() {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.hedgeType)
  return _internal_mutable_hedgetype();
}
inline const std::string& Order::_internal_hedgetype() const {
  return hedgetype_.Get();
}
inline void Order::_internal_set_hedgetype(const std::string& value) {
  _has_bits_[0] |= 0x00400000u;
  hedgetype_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Order::set_hedgetype(std::string&& value) {
  _has_bits_[0] |= 0x00400000u;
  hedgetype_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Order.hedgeType)
}
inline void Order::set_hedgetype(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00400000u;
  hedgetype_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Order.hedgeType)
}
inline void Order::set_hedgetype(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00400000u;
  hedgetype_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Order.hedgeType)
}
inline std::string* Order::_internal_mutable_hedgetype() {
  _has_bits_[0] |= 0x00400000u;
  return hedgetype_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Order::release_hedgetype() {
  // @@protoc_insertion_point(field_release:protobuf.Order.hedgeType)
  if (!_internal_has_hedgetype()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00400000u;
  return hedgetype_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Order::set_allocated_hedgetype(std::string* hedgetype) {
  if (hedgetype != nullptr) {
    _has_bits_[0] |= 0x00400000u;
  } else {
    _has_bits_[0] &= ~0x00400000u;
  }
  hedgetype_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), hedgetype,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Order.hedgeType)
}
inline std::string* Order::unsafe_arena_release_hedgetype() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Order.hedgeType)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00400000u;
  return hedgetype_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Order::unsafe_arena_set_allocated_hedgetype(
    std::string* hedgetype) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (hedgetype != nullptr) {
    _has_bits_[0] |= 0x00400000u;
  } else {
    _has_bits_[0] &= ~0x00400000u;
  }
  hedgetype_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      hedgetype, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Order.hedgeType)
}

// string hedgeParam = 60;
inline bool Order::_internal_has_hedgeparam() const {
  bool value = (_has_bits_[0] & 0x00800000u) != 0;
  return value;
}
inline bool Order::has_hedgeparam() const {
  return _internal_has_hedgeparam();
}
inline void Order::clear_hedgeparam() {
  hedgeparam_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00800000u;
}
inline const std::string& Order::hedgeparam() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.hedgeParam)
  return _internal_hedgeparam();
}
inline void Order::set_hedgeparam(const std::string& value) {
  _internal_set_hedgeparam(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.hedgeParam)
}
inline std::string* Order::mutable_hedgeparam() {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.hedgeParam)
  return _internal_mutable_hedgeparam();
}
inline const std::string& Order::_internal_hedgeparam() const {
  return hedgeparam_.Get();
}
inline void Order::_internal_set_hedgeparam(const std::string& value) {
  _has_bits_[0] |= 0x00800000u;
  hedgeparam_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Order::set_hedgeparam(std::string&& value) {
  _has_bits_[0] |= 0x00800000u;
  hedgeparam_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Order.hedgeParam)
}
inline void Order::set_hedgeparam(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00800000u;
  hedgeparam_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Order.hedgeParam)
}
inline void Order::set_hedgeparam(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00800000u;
  hedgeparam_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Order.hedgeParam)
}
inline std::string* Order::_internal_mutable_hedgeparam() {
  _has_bits_[0] |= 0x00800000u;
  return hedgeparam_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Order::release_hedgeparam() {
  // @@protoc_insertion_point(field_release:protobuf.Order.hedgeParam)
  if (!_internal_has_hedgeparam()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00800000u;
  return hedgeparam_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Order::set_allocated_hedgeparam(std::string* hedgeparam) {
  if (hedgeparam != nullptr) {
    _has_bits_[0] |= 0x00800000u;
  } else {
    _has_bits_[0] &= ~0x00800000u;
  }
  hedgeparam_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), hedgeparam,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Order.hedgeParam)
}
inline std::string* Order::unsafe_arena_release_hedgeparam() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Order.hedgeParam)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00800000u;
  return hedgeparam_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Order::unsafe_arena_set_allocated_hedgeparam(
    std::string* hedgeparam) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (hedgeparam != nullptr) {
    _has_bits_[0] |= 0x00800000u;
  } else {
    _has_bits_[0] &= ~0x00800000u;
  }
  hedgeparam_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      hedgeparam, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Order.hedgeParam)
}

// string algoStrategy = 61;
inline bool Order::_internal_has_algostrategy() const {
  bool value = (_has_bits_[0] & 0x01000000u) != 0;
  return value;
}
inline bool Order::has_algostrategy() const {
  return _internal_has_algostrategy();
}
inline void Order::clear_algostrategy() {
  algostrategy_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x01000000u;
}
inline const std::string& Order::algostrategy() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.algoStrategy)
  return _internal_algostrategy();
}
inline void Order::set_algostrategy(const std::string& value) {
  _internal_set_algostrategy(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.algoStrategy)
}
inline std::string* Order::mutable_algostrategy() {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.algoStrategy)
  return _internal_mutable_algostrategy();
}
inline const std::string& Order::_internal_algostrategy() const {
  return algostrategy_.Get();
}
inline void Order::_internal_set_algostrategy(const std::string& value) {
  _has_bits_[0] |= 0x01000000u;
  algostrategy_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Order::set_algostrategy(std::string&& value) {
  _has_bits_[0] |= 0x01000000u;
  algostrategy_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Order.algoStrategy)
}
inline void Order::set_algostrategy(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x01000000u;
  algostrategy_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Order.algoStrategy)
}
inline void Order::set_algostrategy(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x01000000u;
  algostrategy_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Order.algoStrategy)
}
inline std::string* Order::_internal_mutable_algostrategy() {
  _has_bits_[0] |= 0x01000000u;
  return algostrategy_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Order::release_algostrategy() {
  // @@protoc_insertion_point(field_release:protobuf.Order.algoStrategy)
  if (!_internal_has_algostrategy()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x01000000u;
  return algostrategy_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Order::set_allocated_algostrategy(std::string* algostrategy) {
  if (algostrategy != nullptr) {
    _has_bits_[0] |= 0x01000000u;
  } else {
    _has_bits_[0] &= ~0x01000000u;
  }
  algostrategy_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), algostrategy,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Order.algoStrategy)
}
inline std::string* Order::unsafe_arena_release_algostrategy() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Order.algoStrategy)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x01000000u;
  return algostrategy_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Order::unsafe_arena_set_allocated_algostrategy(
    std::string* algostrategy) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (algostrategy != nullptr) {
    _has_bits_[0] |= 0x01000000u;
  } else {
    _has_bits_[0] &= ~0x01000000u;
  }
  algostrategy_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      algostrategy, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Order.algoStrategy)
}

// map<string, string> algoParams = 62;
inline int Order::_internal_algoparams_size() const {
  return algoparams_.size();
}
inline int Order::algoparams_size() const {
  return _internal_algoparams_size();
}
inline void Order::clear_algoparams() {
  algoparams_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
Order::_internal_algoparams() const {
  return algoparams_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
Order::algoparams() const {
  // @@protoc_insertion_point(field_map:protobuf.Order.algoParams)
  return _internal_algoparams();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
Order::_internal_mutable_algoparams() {
  return algoparams_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
Order::mutable_algoparams() {
  // @@protoc_insertion_point(field_mutable_map:protobuf.Order.algoParams)
  return _internal_mutable_algoparams();
}

// string algoId = 63;
inline bool Order::_internal_has_algoid() const {
  bool value = (_has_bits_[0] & 0x02000000u) != 0;
  return value;
}
inline bool Order::has_algoid() const {
  return _internal_has_algoid();
}
inline void Order::clear_algoid() {
  algoid_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x02000000u;
}
inline const std::string& Order::algoid() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.algoId)
  return _internal_algoid();
}
inline void Order::set_algoid(const std::string& value) {
  _internal_set_algoid(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.algoId)
}
inline std::string* Order::mutable_algoid() {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.algoId)
  return _internal_mutable_algoid();
}
inline const std::string& Order::_internal_algoid() const {
  return algoid_.Get();
}
inline void Order::_internal_set_algoid(const std::string& value) {
  _has_bits_[0] |= 0x02000000u;
  algoid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Order::set_algoid(std::string&& value) {
  _has_bits_[0] |= 0x02000000u;
  algoid_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Order.algoId)
}
inline void Order::set_algoid(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x02000000u;
  algoid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Order.algoId)
}
inline void Order::set_algoid(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x02000000u;
  algoid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Order.algoId)
}
inline std::string* Order::_internal_mutable_algoid() {
  _has_bits_[0] |= 0x02000000u;
  return algoid_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Order::release_algoid() {
  // @@protoc_insertion_point(field_release:protobuf.Order.algoId)
  if (!_internal_has_algoid()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x02000000u;
  return algoid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Order::set_allocated_algoid(std::string* algoid) {
  if (algoid != nullptr) {
    _has_bits_[0] |= 0x02000000u;
  } else {
    _has_bits_[0] &= ~0x02000000u;
  }
  algoid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), algoid,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Order.algoId)
}
inline std::string* Order::unsafe_arena_release_algoid() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Order.algoId)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x02000000u;
  return algoid_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Order::unsafe_arena_set_allocated_algoid(
    std::string* algoid) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (algoid != nullptr) {
    _has_bits_[0] |= 0x02000000u;
  } else {
    _has_bits_[0] &= ~0x02000000u;
  }
  algoid_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      algoid, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Order.algoId)
}

// map<string, string> smartComboRoutingParams = 64;
inline int Order::_internal_smartcomboroutingparams_size() const {
  return smartcomboroutingparams_.size();
}
inline int Order::smartcomboroutingparams_size() const {
  return _internal_smartcomboroutingparams_size();
}
inline void Order::clear_smartcomboroutingparams() {
  smartcomboroutingparams_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
Order::_internal_smartcomboroutingparams() const {
  return smartcomboroutingparams_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
Order::smartcomboroutingparams() const {
  // @@protoc_insertion_point(field_map:protobuf.Order.smartComboRoutingParams)
  return _internal_smartcomboroutingparams();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
Order::_internal_mutable_smartcomboroutingparams() {
  return smartcomboroutingparams_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
Order::mutable_smartcomboroutingparams() {
  // @@protoc_insertion_point(field_mutable_map:protobuf.Order.smartComboRoutingParams)
  return _internal_mutable_smartcomboroutingparams();
}

// bool whatIf = 65;
inline bool Order::_internal_has_whatif() const {
  bool value = (_has_bits_[2] & 0x00100000u) != 0;
  return value;
}
inline bool Order::has_whatif() const {
  return _internal_has_whatif();
}
inline void Order::clear_whatif() {
  whatif_ = false;
  _has_bits_[2] &= ~0x00100000u;
}
inline bool Order::_internal_whatif() const {
  return whatif_;
}
inline bool Order::whatif() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.whatIf)
  return _internal_whatif();
}
inline void Order::_internal_set_whatif(bool value) {
  _has_bits_[2] |= 0x00100000u;
  whatif_ = value;
}
inline void Order::set_whatif(bool value) {
  _internal_set_whatif(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.whatIf)
}

// bool transmit = 66;
inline bool Order::_internal_has_transmit() const {
  bool value = (_has_bits_[2] & 0x00200000u) != 0;
  return value;
}
inline bool Order::has_transmit() const {
  return _internal_has_transmit();
}
inline void Order::clear_transmit() {
  transmit_ = false;
  _has_bits_[2] &= ~0x00200000u;
}
inline bool Order::_internal_transmit() const {
  return transmit_;
}
inline bool Order::transmit() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.transmit)
  return _internal_transmit();
}
inline void Order::_internal_set_transmit(bool value) {
  _has_bits_[2] |= 0x00200000u;
  transmit_ = value;
}
inline void Order::set_transmit(bool value) {
  _internal_set_transmit(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.transmit)
}

// bool overridePercentageConstraints = 67;
inline bool Order::_internal_has_overridepercentageconstraints() const {
  bool value = (_has_bits_[2] & 0x00400000u) != 0;
  return value;
}
inline bool Order::has_overridepercentageconstraints() const {
  return _internal_has_overridepercentageconstraints();
}
inline void Order::clear_overridepercentageconstraints() {
  overridepercentageconstraints_ = false;
  _has_bits_[2] &= ~0x00400000u;
}
inline bool Order::_internal_overridepercentageconstraints() const {
  return overridepercentageconstraints_;
}
inline bool Order::overridepercentageconstraints() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.overridePercentageConstraints)
  return _internal_overridepercentageconstraints();
}
inline void Order::_internal_set_overridepercentageconstraints(bool value) {
  _has_bits_[2] |= 0x00400000u;
  overridepercentageconstraints_ = value;
}
inline void Order::set_overridepercentageconstraints(bool value) {
  _internal_set_overridepercentageconstraints(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.overridePercentageConstraints)
}

// string openClose = 68;
inline bool Order::_internal_has_openclose() const {
  bool value = (_has_bits_[0] & 0x04000000u) != 0;
  return value;
}
inline bool Order::has_openclose() const {
  return _internal_has_openclose();
}
inline void Order::clear_openclose() {
  openclose_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x04000000u;
}
inline const std::string& Order::openclose() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.openClose)
  return _internal_openclose();
}
inline void Order::set_openclose(const std::string& value) {
  _internal_set_openclose(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.openClose)
}
inline std::string* Order::mutable_openclose() {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.openClose)
  return _internal_mutable_openclose();
}
inline const std::string& Order::_internal_openclose() const {
  return openclose_.Get();
}
inline void Order::_internal_set_openclose(const std::string& value) {
  _has_bits_[0] |= 0x04000000u;
  openclose_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Order::set_openclose(std::string&& value) {
  _has_bits_[0] |= 0x04000000u;
  openclose_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Order.openClose)
}
inline void Order::set_openclose(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x04000000u;
  openclose_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Order.openClose)
}
inline void Order::set_openclose(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x04000000u;
  openclose_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Order.openClose)
}
inline std::string* Order::_internal_mutable_openclose() {
  _has_bits_[0] |= 0x04000000u;
  return openclose_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Order::release_openclose() {
  // @@protoc_insertion_point(field_release:protobuf.Order.openClose)
  if (!_internal_has_openclose()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x04000000u;
  return openclose_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Order::set_allocated_openclose(std::string* openclose) {
  if (openclose != nullptr) {
    _has_bits_[0] |= 0x04000000u;
  } else {
    _has_bits_[0] &= ~0x04000000u;
  }
  openclose_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), openclose,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Order.openClose)
}
inline std::string* Order::unsafe_arena_release_openclose() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Order.openClose)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x04000000u;
  return openclose_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Order::unsafe_arena_set_allocated_openclose(
    std::string* openclose) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (openclose != nullptr) {
    _has_bits_[0] |= 0x04000000u;
  } else {
    _has_bits_[0] &= ~0x04000000u;
  }
  openclose_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      openclose, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Order.openClose)
}

// int32 origin = 69;
inline bool Order::_internal_has_origin() const {
  bool value = (_has_bits_[2] & 0x00800000u) != 0;
  return value;
}
inline bool Order::has_origin() const {
  return _internal_has_origin();
}
inline void Order::clear_origin() {
  origin_ = 0;
  _has_bits_[2] &= ~0x00800000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::_internal_origin() const {
  return origin_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::origin() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.origin)
  return _internal_origin();
}
inline void Order::_internal_set_origin(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[2] |= 0x00800000u;
  origin_ = value;
}
inline void Order::set_origin(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_origin(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.origin)
}

// int32 shortSaleSlot = 70;
inline bool Order::_internal_has_shortsaleslot() const {
  bool value = (_has_bits_[2] & 0x01000000u) != 0;
  return value;
}
inline bool Order::has_shortsaleslot() const {
  return _internal_has_shortsaleslot();
}
inline void Order::clear_shortsaleslot() {
  shortsaleslot_ = 0;
  _has_bits_[2] &= ~0x01000000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::_internal_shortsaleslot() const {
  return shortsaleslot_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::shortsaleslot() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.shortSaleSlot)
  return _internal_shortsaleslot();
}
inline void Order::_internal_set_shortsaleslot(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[2] |= 0x01000000u;
  shortsaleslot_ = value;
}
inline void Order::set_shortsaleslot(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_shortsaleslot(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.shortSaleSlot)
}

// string designatedLocation = 71;
inline bool Order::_internal_has_designatedlocation() const {
  bool value = (_has_bits_[0] & 0x08000000u) != 0;
  return value;
}
inline bool Order::has_designatedlocation() const {
  return _internal_has_designatedlocation();
}
inline void Order::clear_designatedlocation() {
  designatedlocation_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x08000000u;
}
inline const std::string& Order::designatedlocation() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.designatedLocation)
  return _internal_designatedlocation();
}
inline void Order::set_designatedlocation(const std::string& value) {
  _internal_set_designatedlocation(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.designatedLocation)
}
inline std::string* Order::mutable_designatedlocation() {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.designatedLocation)
  return _internal_mutable_designatedlocation();
}
inline const std::string& Order::_internal_designatedlocation() const {
  return designatedlocation_.Get();
}
inline void Order::_internal_set_designatedlocation(const std::string& value) {
  _has_bits_[0] |= 0x08000000u;
  designatedlocation_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Order::set_designatedlocation(std::string&& value) {
  _has_bits_[0] |= 0x08000000u;
  designatedlocation_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Order.designatedLocation)
}
inline void Order::set_designatedlocation(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x08000000u;
  designatedlocation_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Order.designatedLocation)
}
inline void Order::set_designatedlocation(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x08000000u;
  designatedlocation_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Order.designatedLocation)
}
inline std::string* Order::_internal_mutable_designatedlocation() {
  _has_bits_[0] |= 0x08000000u;
  return designatedlocation_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Order::release_designatedlocation() {
  // @@protoc_insertion_point(field_release:protobuf.Order.designatedLocation)
  if (!_internal_has_designatedlocation()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x08000000u;
  return designatedlocation_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Order::set_allocated_designatedlocation(std::string* designatedlocation) {
  if (designatedlocation != nullptr) {
    _has_bits_[0] |= 0x08000000u;
  } else {
    _has_bits_[0] &= ~0x08000000u;
  }
  designatedlocation_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), designatedlocation,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Order.designatedLocation)
}
inline std::string* Order::unsafe_arena_release_designatedlocation() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Order.designatedLocation)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x08000000u;
  return designatedlocation_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Order::unsafe_arena_set_allocated_designatedlocation(
    std::string* designatedlocation) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (designatedlocation != nullptr) {
    _has_bits_[0] |= 0x08000000u;
  } else {
    _has_bits_[0] &= ~0x08000000u;
  }
  designatedlocation_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      designatedlocation, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Order.designatedLocation)
}

// int32 exemptCode = 72;
inline bool Order::_internal_has_exemptcode() const {
  bool value = (_has_bits_[2] & 0x02000000u) != 0;
  return value;
}
inline bool Order::has_exemptcode() const {
  return _internal_has_exemptcode();
}
inline void Order::clear_exemptcode() {
  exemptcode_ = 0;
  _has_bits_[2] &= ~0x02000000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::_internal_exemptcode() const {
  return exemptcode_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::exemptcode() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.exemptCode)
  return _internal_exemptcode();
}
inline void Order::_internal_set_exemptcode(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[2] |= 0x02000000u;
  exemptcode_ = value;
}
inline void Order::set_exemptcode(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_exemptcode(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.exemptCode)
}

// string deltaNeutralSettlingFirm = 73;
inline bool Order::_internal_has_deltaneutralsettlingfirm() const {
  bool value = (_has_bits_[0] & 0x10000000u) != 0;
  return value;
}
inline bool Order::has_deltaneutralsettlingfirm() const {
  return _internal_has_deltaneutralsettlingfirm();
}
inline void Order::clear_deltaneutralsettlingfirm() {
  deltaneutralsettlingfirm_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x10000000u;
}
inline const std::string& Order::deltaneutralsettlingfirm() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.deltaNeutralSettlingFirm)
  return _internal_deltaneutralsettlingfirm();
}
inline void Order::set_deltaneutralsettlingfirm(const std::string& value) {
  _internal_set_deltaneutralsettlingfirm(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.deltaNeutralSettlingFirm)
}
inline std::string* Order::mutable_deltaneutralsettlingfirm() {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.deltaNeutralSettlingFirm)
  return _internal_mutable_deltaneutralsettlingfirm();
}
inline const std::string& Order::_internal_deltaneutralsettlingfirm() const {
  return deltaneutralsettlingfirm_.Get();
}
inline void Order::_internal_set_deltaneutralsettlingfirm(const std::string& value) {
  _has_bits_[0] |= 0x10000000u;
  deltaneutralsettlingfirm_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Order::set_deltaneutralsettlingfirm(std::string&& value) {
  _has_bits_[0] |= 0x10000000u;
  deltaneutralsettlingfirm_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Order.deltaNeutralSettlingFirm)
}
inline void Order::set_deltaneutralsettlingfirm(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x10000000u;
  deltaneutralsettlingfirm_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Order.deltaNeutralSettlingFirm)
}
inline void Order::set_deltaneutralsettlingfirm(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x10000000u;
  deltaneutralsettlingfirm_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Order.deltaNeutralSettlingFirm)
}
inline std::string* Order::_internal_mutable_deltaneutralsettlingfirm() {
  _has_bits_[0] |= 0x10000000u;
  return deltaneutralsettlingfirm_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Order::release_deltaneutralsettlingfirm() {
  // @@protoc_insertion_point(field_release:protobuf.Order.deltaNeutralSettlingFirm)
  if (!_internal_has_deltaneutralsettlingfirm()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x10000000u;
  return deltaneutralsettlingfirm_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Order::set_allocated_deltaneutralsettlingfirm(std::string* deltaneutralsettlingfirm) {
  if (deltaneutralsettlingfirm != nullptr) {
    _has_bits_[0] |= 0x10000000u;
  } else {
    _has_bits_[0] &= ~0x10000000u;
  }
  deltaneutralsettlingfirm_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), deltaneutralsettlingfirm,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Order.deltaNeutralSettlingFirm)
}
inline std::string* Order::unsafe_arena_release_deltaneutralsettlingfirm() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Order.deltaNeutralSettlingFirm)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x10000000u;
  return deltaneutralsettlingfirm_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Order::unsafe_arena_set_allocated_deltaneutralsettlingfirm(
    std::string* deltaneutralsettlingfirm) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (deltaneutralsettlingfirm != nullptr) {
    _has_bits_[0] |= 0x10000000u;
  } else {
    _has_bits_[0] &= ~0x10000000u;
  }
  deltaneutralsettlingfirm_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      deltaneutralsettlingfirm, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Order.deltaNeutralSettlingFirm)
}

// string deltaNeutralClearingAccount = 74;
inline bool Order::_internal_has_deltaneutralclearingaccount() const {
  bool value = (_has_bits_[0] & 0x20000000u) != 0;
  return value;
}
inline bool Order::has_deltaneutralclearingaccount() const {
  return _internal_has_deltaneutralclearingaccount();
}
inline void Order::clear_deltaneutralclearingaccount() {
  deltaneutralclearingaccount_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x20000000u;
}
inline const std::string& Order::deltaneutralclearingaccount() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.deltaNeutralClearingAccount)
  return _internal_deltaneutralclearingaccount();
}
inline void Order::set_deltaneutralclearingaccount(const std::string& value) {
  _internal_set_deltaneutralclearingaccount(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.deltaNeutralClearingAccount)
}
inline std::string* Order::mutable_deltaneutralclearingaccount() {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.deltaNeutralClearingAccount)
  return _internal_mutable_deltaneutralclearingaccount();
}
inline const std::string& Order::_internal_deltaneutralclearingaccount() const {
  return deltaneutralclearingaccount_.Get();
}
inline void Order::_internal_set_deltaneutralclearingaccount(const std::string& value) {
  _has_bits_[0] |= 0x20000000u;
  deltaneutralclearingaccount_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Order::set_deltaneutralclearingaccount(std::string&& value) {
  _has_bits_[0] |= 0x20000000u;
  deltaneutralclearingaccount_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Order.deltaNeutralClearingAccount)
}
inline void Order::set_deltaneutralclearingaccount(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x20000000u;
  deltaneutralclearingaccount_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Order.deltaNeutralClearingAccount)
}
inline void Order::set_deltaneutralclearingaccount(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x20000000u;
  deltaneutralclearingaccount_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Order.deltaNeutralClearingAccount)
}
inline std::string* Order::_internal_mutable_deltaneutralclearingaccount() {
  _has_bits_[0] |= 0x20000000u;
  return deltaneutralclearingaccount_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Order::release_deltaneutralclearingaccount() {
  // @@protoc_insertion_point(field_release:protobuf.Order.deltaNeutralClearingAccount)
  if (!_internal_has_deltaneutralclearingaccount()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x20000000u;
  return deltaneutralclearingaccount_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Order::set_allocated_deltaneutralclearingaccount(std::string* deltaneutralclearingaccount) {
  if (deltaneutralclearingaccount != nullptr) {
    _has_bits_[0] |= 0x20000000u;
  } else {
    _has_bits_[0] &= ~0x20000000u;
  }
  deltaneutralclearingaccount_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), deltaneutralclearingaccount,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Order.deltaNeutralClearingAccount)
}
inline std::string* Order::unsafe_arena_release_deltaneutralclearingaccount() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Order.deltaNeutralClearingAccount)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x20000000u;
  return deltaneutralclearingaccount_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Order::unsafe_arena_set_allocated_deltaneutralclearingaccount(
    std::string* deltaneutralclearingaccount) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (deltaneutralclearingaccount != nullptr) {
    _has_bits_[0] |= 0x20000000u;
  } else {
    _has_bits_[0] &= ~0x20000000u;
  }
  deltaneutralclearingaccount_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      deltaneutralclearingaccount, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Order.deltaNeutralClearingAccount)
}

// string deltaNeutralClearingIntent = 75;
inline bool Order::_internal_has_deltaneutralclearingintent() const {
  bool value = (_has_bits_[0] & 0x40000000u) != 0;
  return value;
}
inline bool Order::has_deltaneutralclearingintent() const {
  return _internal_has_deltaneutralclearingintent();
}
inline void Order::clear_deltaneutralclearingintent() {
  deltaneutralclearingintent_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x40000000u;
}
inline const std::string& Order::deltaneutralclearingintent() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.deltaNeutralClearingIntent)
  return _internal_deltaneutralclearingintent();
}
inline void Order::set_deltaneutralclearingintent(const std::string& value) {
  _internal_set_deltaneutralclearingintent(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.deltaNeutralClearingIntent)
}
inline std::string* Order::mutable_deltaneutralclearingintent() {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.deltaNeutralClearingIntent)
  return _internal_mutable_deltaneutralclearingintent();
}
inline const std::string& Order::_internal_deltaneutralclearingintent() const {
  return deltaneutralclearingintent_.Get();
}
inline void Order::_internal_set_deltaneutralclearingintent(const std::string& value) {
  _has_bits_[0] |= 0x40000000u;
  deltaneutralclearingintent_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Order::set_deltaneutralclearingintent(std::string&& value) {
  _has_bits_[0] |= 0x40000000u;
  deltaneutralclearingintent_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Order.deltaNeutralClearingIntent)
}
inline void Order::set_deltaneutralclearingintent(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x40000000u;
  deltaneutralclearingintent_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Order.deltaNeutralClearingIntent)
}
inline void Order::set_deltaneutralclearingintent(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x40000000u;
  deltaneutralclearingintent_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Order.deltaNeutralClearingIntent)
}
inline std::string* Order::_internal_mutable_deltaneutralclearingintent() {
  _has_bits_[0] |= 0x40000000u;
  return deltaneutralclearingintent_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Order::release_deltaneutralclearingintent() {
  // @@protoc_insertion_point(field_release:protobuf.Order.deltaNeutralClearingIntent)
  if (!_internal_has_deltaneutralclearingintent()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x40000000u;
  return deltaneutralclearingintent_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Order::set_allocated_deltaneutralclearingintent(std::string* deltaneutralclearingintent) {
  if (deltaneutralclearingintent != nullptr) {
    _has_bits_[0] |= 0x40000000u;
  } else {
    _has_bits_[0] &= ~0x40000000u;
  }
  deltaneutralclearingintent_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), deltaneutralclearingintent,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Order.deltaNeutralClearingIntent)
}
inline std::string* Order::unsafe_arena_release_deltaneutralclearingintent() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Order.deltaNeutralClearingIntent)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x40000000u;
  return deltaneutralclearingintent_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Order::unsafe_arena_set_allocated_deltaneutralclearingintent(
    std::string* deltaneutralclearingintent) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (deltaneutralclearingintent != nullptr) {
    _has_bits_[0] |= 0x40000000u;
  } else {
    _has_bits_[0] &= ~0x40000000u;
  }
  deltaneutralclearingintent_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      deltaneutralclearingintent, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Order.deltaNeutralClearingIntent)
}

// double discretionaryAmt = 76;
inline bool Order::_internal_has_discretionaryamt() const {
  bool value = (_has_bits_[2] & 0x04000000u) != 0;
  return value;
}
inline bool Order::has_discretionaryamt() const {
  return _internal_has_discretionaryamt();
}
inline void Order::clear_discretionaryamt() {
  discretionaryamt_ = 0;
  _has_bits_[2] &= ~0x04000000u;
}
inline double Order::_internal_discretionaryamt() const {
  return discretionaryamt_;
}
inline double Order::discretionaryamt() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.discretionaryAmt)
  return _internal_discretionaryamt();
}
inline void Order::_internal_set_discretionaryamt(double value) {
  _has_bits_[2] |= 0x04000000u;
  discretionaryamt_ = value;
}
inline void Order::set_discretionaryamt(double value) {
  _internal_set_discretionaryamt(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.discretionaryAmt)
}

// bool optOutSmartRouting = 77;
inline bool Order::_internal_has_optoutsmartrouting() const {
  bool value = (_has_bits_[3] & 0x00000001u) != 0;
  return value;
}
inline bool Order::has_optoutsmartrouting() const {
  return _internal_has_optoutsmartrouting();
}
inline void Order::clear_optoutsmartrouting() {
  optoutsmartrouting_ = false;
  _has_bits_[3] &= ~0x00000001u;
}
inline bool Order::_internal_optoutsmartrouting() const {
  return optoutsmartrouting_;
}
inline bool Order::optoutsmartrouting() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.optOutSmartRouting)
  return _internal_optoutsmartrouting();
}
inline void Order::_internal_set_optoutsmartrouting(bool value) {
  _has_bits_[3] |= 0x00000001u;
  optoutsmartrouting_ = value;
}
inline void Order::set_optoutsmartrouting(bool value) {
  _internal_set_optoutsmartrouting(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.optOutSmartRouting)
}

// double startingPrice = 78;
inline bool Order::_internal_has_startingprice() const {
  bool value = (_has_bits_[2] & 0x08000000u) != 0;
  return value;
}
inline bool Order::has_startingprice() const {
  return _internal_has_startingprice();
}
inline void Order::clear_startingprice() {
  startingprice_ = 0;
  _has_bits_[2] &= ~0x08000000u;
}
inline double Order::_internal_startingprice() const {
  return startingprice_;
}
inline double Order::startingprice() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.startingPrice)
  return _internal_startingprice();
}
inline void Order::_internal_set_startingprice(double value) {
  _has_bits_[2] |= 0x08000000u;
  startingprice_ = value;
}
inline void Order::set_startingprice(double value) {
  _internal_set_startingprice(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.startingPrice)
}

// double stockRefPrice = 79;
inline bool Order::_internal_has_stockrefprice() const {
  bool value = (_has_bits_[2] & 0x10000000u) != 0;
  return value;
}
inline bool Order::has_stockrefprice() const {
  return _internal_has_stockrefprice();
}
inline void Order::clear_stockrefprice() {
  stockrefprice_ = 0;
  _has_bits_[2] &= ~0x10000000u;
}
inline double Order::_internal_stockrefprice() const {
  return stockrefprice_;
}
inline double Order::stockrefprice() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.stockRefPrice)
  return _internal_stockrefprice();
}
inline void Order::_internal_set_stockrefprice(double value) {
  _has_bits_[2] |= 0x10000000u;
  stockrefprice_ = value;
}
inline void Order::set_stockrefprice(double value) {
  _internal_set_stockrefprice(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.stockRefPrice)
}

// double delta = 80;
inline bool Order::_internal_has_delta() const {
  bool value = (_has_bits_[2] & 0x20000000u) != 0;
  return value;
}
inline bool Order::has_delta() const {
  return _internal_has_delta();
}
inline void Order::clear_delta() {
  delta_ = 0;
  _has_bits_[2] &= ~0x20000000u;
}
inline double Order::_internal_delta() const {
  return delta_;
}
inline double Order::delta() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.delta)
  return _internal_delta();
}
inline void Order::_internal_set_delta(double value) {
  _has_bits_[2] |= 0x20000000u;
  delta_ = value;
}
inline void Order::set_delta(double value) {
  _internal_set_delta(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.delta)
}

// double stockRangeLower = 81;
inline bool Order::_internal_has_stockrangelower() const {
  bool value = (_has_bits_[2] & 0x40000000u) != 0;
  return value;
}
inline bool Order::has_stockrangelower() const {
  return _internal_has_stockrangelower();
}
inline void Order::clear_stockrangelower() {
  stockrangelower_ = 0;
  _has_bits_[2] &= ~0x40000000u;
}
inline double Order::_internal_stockrangelower() const {
  return stockrangelower_;
}
inline double Order::stockrangelower() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.stockRangeLower)
  return _internal_stockrangelower();
}
inline void Order::_internal_set_stockrangelower(double value) {
  _has_bits_[2] |= 0x40000000u;
  stockrangelower_ = value;
}
inline void Order::set_stockrangelower(double value) {
  _internal_set_stockrangelower(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.stockRangeLower)
}

// double stockRangeUpper = 82;
inline bool Order::_internal_has_stockrangeupper() const {
  bool value = (_has_bits_[2] & 0x80000000u) != 0;
  return value;
}
inline bool Order::has_stockrangeupper() const {
  return _internal_has_stockrangeupper();
}
inline void Order::clear_stockrangeupper() {
  stockrangeupper_ = 0;
  _has_bits_[2] &= ~0x80000000u;
}
inline double Order::_internal_stockrangeupper() const {
  return stockrangeupper_;
}
inline double Order::stockrangeupper() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.stockRangeUpper)
  return _internal_stockrangeupper();
}
inline void Order::_internal_set_stockrangeupper(double value) {
  _has_bits_[2] |= 0x80000000u;
  stockrangeupper_ = value;
}
inline void Order::set_stockrangeupper(double value) {
  _internal_set_stockrangeupper(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.stockRangeUpper)
}

// bool notHeld = 83;
inline bool Order::_internal_has_notheld() const {
  bool value = (_has_bits_[3] & 0x00000002u) != 0;
  return value;
}
inline bool Order::has_notheld() const {
  return _internal_has_notheld();
}
inline void Order::clear_notheld() {
  notheld_ = false;
  _has_bits_[3] &= ~0x00000002u;
}
inline bool Order::_internal_notheld() const {
  return notheld_;
}
inline bool Order::notheld() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.notHeld)
  return _internal_notheld();
}
inline void Order::_internal_set_notheld(bool value) {
  _has_bits_[3] |= 0x00000002u;
  notheld_ = value;
}
inline void Order::set_notheld(bool value) {
  _internal_set_notheld(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.notHeld)
}

// map<string, string> orderMiscOptions = 84;
inline int Order::_internal_ordermiscoptions_size() const {
  return ordermiscoptions_.size();
}
inline int Order::ordermiscoptions_size() const {
  return _internal_ordermiscoptions_size();
}
inline void Order::clear_ordermiscoptions() {
  ordermiscoptions_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
Order::_internal_ordermiscoptions() const {
  return ordermiscoptions_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
Order::ordermiscoptions() const {
  // @@protoc_insertion_point(field_map:protobuf.Order.orderMiscOptions)
  return _internal_ordermiscoptions();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
Order::_internal_mutable_ordermiscoptions() {
  return ordermiscoptions_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
Order::mutable_ordermiscoptions() {
  // @@protoc_insertion_point(field_mutable_map:protobuf.Order.orderMiscOptions)
  return _internal_mutable_ordermiscoptions();
}

// bool solicited = 85;
inline bool Order::_internal_has_solicited() const {
  bool value = (_has_bits_[3] & 0x00000004u) != 0;
  return value;
}
inline bool Order::has_solicited() const {
  return _internal_has_solicited();
}
inline void Order::clear_solicited() {
  solicited_ = false;
  _has_bits_[3] &= ~0x00000004u;
}
inline bool Order::_internal_solicited() const {
  return solicited_;
}
inline bool Order::solicited() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.solicited)
  return _internal_solicited();
}
inline void Order::_internal_set_solicited(bool value) {
  _has_bits_[3] |= 0x00000004u;
  solicited_ = value;
}
inline void Order::set_solicited(bool value) {
  _internal_set_solicited(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.solicited)
}

// bool randomizeSize = 86;
inline bool Order::_internal_has_randomizesize() const {
  bool value = (_has_bits_[3] & 0x00000008u) != 0;
  return value;
}
inline bool Order::has_randomizesize() const {
  return _internal_has_randomizesize();
}
inline void Order::clear_randomizesize() {
  randomizesize_ = false;
  _has_bits_[3] &= ~0x00000008u;
}
inline bool Order::_internal_randomizesize() const {
  return randomizesize_;
}
inline bool Order::randomizesize() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.randomizeSize)
  return _internal_randomizesize();
}
inline void Order::_internal_set_randomizesize(bool value) {
  _has_bits_[3] |= 0x00000008u;
  randomizesize_ = value;
}
inline void Order::set_randomizesize(bool value) {
  _internal_set_randomizesize(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.randomizeSize)
}

// bool randomizePrice = 87;
inline bool Order::_internal_has_randomizeprice() const {
  bool value = (_has_bits_[3] & 0x00000200u) != 0;
  return value;
}
inline bool Order::has_randomizeprice() const {
  return _internal_has_randomizeprice();
}
inline void Order::clear_randomizeprice() {
  randomizeprice_ = false;
  _has_bits_[3] &= ~0x00000200u;
}
inline bool Order::_internal_randomizeprice() const {
  return randomizeprice_;
}
inline bool Order::randomizeprice() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.randomizePrice)
  return _internal_randomizeprice();
}
inline void Order::_internal_set_randomizeprice(bool value) {
  _has_bits_[3] |= 0x00000200u;
  randomizeprice_ = value;
}
inline void Order::set_randomizeprice(bool value) {
  _internal_set_randomizeprice(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.randomizePrice)
}

// int32 referenceContractId = 88;
inline bool Order::_internal_has_referencecontractid() const {
  bool value = (_has_bits_[3] & 0x00000010u) != 0;
  return value;
}
inline bool Order::has_referencecontractid() const {
  return _internal_has_referencecontractid();
}
inline void Order::clear_referencecontractid() {
  referencecontractid_ = 0;
  _has_bits_[3] &= ~0x00000010u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::_internal_referencecontractid() const {
  return referencecontractid_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::referencecontractid() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.referenceContractId)
  return _internal_referencecontractid();
}
inline void Order::_internal_set_referencecontractid(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[3] |= 0x00000010u;
  referencecontractid_ = value;
}
inline void Order::set_referencecontractid(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_referencecontractid(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.referenceContractId)
}

// double peggedChangeAmount = 89;
inline bool Order::_internal_has_peggedchangeamount() const {
  bool value = (_has_bits_[3] & 0x00000020u) != 0;
  return value;
}
inline bool Order::has_peggedchangeamount() const {
  return _internal_has_peggedchangeamount();
}
inline void Order::clear_peggedchangeamount() {
  peggedchangeamount_ = 0;
  _has_bits_[3] &= ~0x00000020u;
}
inline double Order::_internal_peggedchangeamount() const {
  return peggedchangeamount_;
}
inline double Order::peggedchangeamount() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.peggedChangeAmount)
  return _internal_peggedchangeamount();
}
inline void Order::_internal_set_peggedchangeamount(double value) {
  _has_bits_[3] |= 0x00000020u;
  peggedchangeamount_ = value;
}
inline void Order::set_peggedchangeamount(double value) {
  _internal_set_peggedchangeamount(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.peggedChangeAmount)
}

// bool isPeggedChangeAmountDecrease = 90;
inline bool Order::_internal_has_ispeggedchangeamountdecrease() const {
  bool value = (_has_bits_[3] & 0x00000400u) != 0;
  return value;
}
inline bool Order::has_ispeggedchangeamountdecrease() const {
  return _internal_has_ispeggedchangeamountdecrease();
}
inline void Order::clear_ispeggedchangeamountdecrease() {
  ispeggedchangeamountdecrease_ = false;
  _has_bits_[3] &= ~0x00000400u;
}
inline bool Order::_internal_ispeggedchangeamountdecrease() const {
  return ispeggedchangeamountdecrease_;
}
inline bool Order::ispeggedchangeamountdecrease() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.isPeggedChangeAmountDecrease)
  return _internal_ispeggedchangeamountdecrease();
}
inline void Order::_internal_set_ispeggedchangeamountdecrease(bool value) {
  _has_bits_[3] |= 0x00000400u;
  ispeggedchangeamountdecrease_ = value;
}
inline void Order::set_ispeggedchangeamountdecrease(bool value) {
  _internal_set_ispeggedchangeamountdecrease(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.isPeggedChangeAmountDecrease)
}

// double referenceChangeAmount = 91;
inline bool Order::_internal_has_referencechangeamount() const {
  bool value = (_has_bits_[3] & 0x00000040u) != 0;
  return value;
}
inline bool Order::has_referencechangeamount() const {
  return _internal_has_referencechangeamount();
}
inline void Order::clear_referencechangeamount() {
  referencechangeamount_ = 0;
  _has_bits_[3] &= ~0x00000040u;
}
inline double Order::_internal_referencechangeamount() const {
  return referencechangeamount_;
}
inline double Order::referencechangeamount() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.referenceChangeAmount)
  return _internal_referencechangeamount();
}
inline void Order::_internal_set_referencechangeamount(double value) {
  _has_bits_[3] |= 0x00000040u;
  referencechangeamount_ = value;
}
inline void Order::set_referencechangeamount(double value) {
  _internal_set_referencechangeamount(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.referenceChangeAmount)
}

// string referenceExchangeId = 92;
inline bool Order::_internal_has_referenceexchangeid() const {
  bool value = (_has_bits_[0] & 0x80000000u) != 0;
  return value;
}
inline bool Order::has_referenceexchangeid() const {
  return _internal_has_referenceexchangeid();
}
inline void Order::clear_referenceexchangeid() {
  referenceexchangeid_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x80000000u;
}
inline const std::string& Order::referenceexchangeid() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.referenceExchangeId)
  return _internal_referenceexchangeid();
}
inline void Order::set_referenceexchangeid(const std::string& value) {
  _internal_set_referenceexchangeid(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.referenceExchangeId)
}
inline std::string* Order::mutable_referenceexchangeid() {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.referenceExchangeId)
  return _internal_mutable_referenceexchangeid();
}
inline const std::string& Order::_internal_referenceexchangeid() const {
  return referenceexchangeid_.Get();
}
inline void Order::_internal_set_referenceexchangeid(const std::string& value) {
  _has_bits_[0] |= 0x80000000u;
  referenceexchangeid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Order::set_referenceexchangeid(std::string&& value) {
  _has_bits_[0] |= 0x80000000u;
  referenceexchangeid_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Order.referenceExchangeId)
}
inline void Order::set_referenceexchangeid(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x80000000u;
  referenceexchangeid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Order.referenceExchangeId)
}
inline void Order::set_referenceexchangeid(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x80000000u;
  referenceexchangeid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Order.referenceExchangeId)
}
inline std::string* Order::_internal_mutable_referenceexchangeid() {
  _has_bits_[0] |= 0x80000000u;
  return referenceexchangeid_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Order::release_referenceexchangeid() {
  // @@protoc_insertion_point(field_release:protobuf.Order.referenceExchangeId)
  if (!_internal_has_referenceexchangeid()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x80000000u;
  return referenceexchangeid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Order::set_allocated_referenceexchangeid(std::string* referenceexchangeid) {
  if (referenceexchangeid != nullptr) {
    _has_bits_[0] |= 0x80000000u;
  } else {
    _has_bits_[0] &= ~0x80000000u;
  }
  referenceexchangeid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), referenceexchangeid,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Order.referenceExchangeId)
}
inline std::string* Order::unsafe_arena_release_referenceexchangeid() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Order.referenceExchangeId)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x80000000u;
  return referenceexchangeid_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Order::unsafe_arena_set_allocated_referenceexchangeid(
    std::string* referenceexchangeid) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (referenceexchangeid != nullptr) {
    _has_bits_[0] |= 0x80000000u;
  } else {
    _has_bits_[0] &= ~0x80000000u;
  }
  referenceexchangeid_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      referenceexchangeid, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Order.referenceExchangeId)
}

// string adjustedOrderType = 93;
inline bool Order::_internal_has_adjustedordertype() const {
  bool value = (_has_bits_[1] & 0x00000001u) != 0;
  return value;
}
inline bool Order::has_adjustedordertype() const {
  return _internal_has_adjustedordertype();
}
inline void Order::clear_adjustedordertype() {
  adjustedordertype_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[1] &= ~0x00000001u;
}
inline const std::string& Order::adjustedordertype() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.adjustedOrderType)
  return _internal_adjustedordertype();
}
inline void Order::set_adjustedordertype(const std::string& value) {
  _internal_set_adjustedordertype(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.adjustedOrderType)
}
inline std::string* Order::mutable_adjustedordertype() {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.adjustedOrderType)
  return _internal_mutable_adjustedordertype();
}
inline const std::string& Order::_internal_adjustedordertype() const {
  return adjustedordertype_.Get();
}
inline void Order::_internal_set_adjustedordertype(const std::string& value) {
  _has_bits_[1] |= 0x00000001u;
  adjustedordertype_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Order::set_adjustedordertype(std::string&& value) {
  _has_bits_[1] |= 0x00000001u;
  adjustedordertype_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Order.adjustedOrderType)
}
inline void Order::set_adjustedordertype(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[1] |= 0x00000001u;
  adjustedordertype_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Order.adjustedOrderType)
}
inline void Order::set_adjustedordertype(const char* value,
    size_t size) {
  _has_bits_[1] |= 0x00000001u;
  adjustedordertype_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Order.adjustedOrderType)
}
inline std::string* Order::_internal_mutable_adjustedordertype() {
  _has_bits_[1] |= 0x00000001u;
  return adjustedordertype_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Order::release_adjustedordertype() {
  // @@protoc_insertion_point(field_release:protobuf.Order.adjustedOrderType)
  if (!_internal_has_adjustedordertype()) {
    return nullptr;
  }
  _has_bits_[1] &= ~0x00000001u;
  return adjustedordertype_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Order::set_allocated_adjustedordertype(std::string* adjustedordertype) {
  if (adjustedordertype != nullptr) {
    _has_bits_[1] |= 0x00000001u;
  } else {
    _has_bits_[1] &= ~0x00000001u;
  }
  adjustedordertype_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), adjustedordertype,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Order.adjustedOrderType)
}
inline std::string* Order::unsafe_arena_release_adjustedordertype() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Order.adjustedOrderType)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[1] &= ~0x00000001u;
  return adjustedordertype_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Order::unsafe_arena_set_allocated_adjustedordertype(
    std::string* adjustedordertype) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (adjustedordertype != nullptr) {
    _has_bits_[1] |= 0x00000001u;
  } else {
    _has_bits_[1] &= ~0x00000001u;
  }
  adjustedordertype_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      adjustedordertype, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Order.adjustedOrderType)
}

// double triggerPrice = 94;
inline bool Order::_internal_has_triggerprice() const {
  bool value = (_has_bits_[3] & 0x00000080u) != 0;
  return value;
}
inline bool Order::has_triggerprice() const {
  return _internal_has_triggerprice();
}
inline void Order::clear_triggerprice() {
  triggerprice_ = 0;
  _has_bits_[3] &= ~0x00000080u;
}
inline double Order::_internal_triggerprice() const {
  return triggerprice_;
}
inline double Order::triggerprice() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.triggerPrice)
  return _internal_triggerprice();
}
inline void Order::_internal_set_triggerprice(double value) {
  _has_bits_[3] |= 0x00000080u;
  triggerprice_ = value;
}
inline void Order::set_triggerprice(double value) {
  _internal_set_triggerprice(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.triggerPrice)
}

// double adjustedStopPrice = 95;
inline bool Order::_internal_has_adjustedstopprice() const {
  bool value = (_has_bits_[3] & 0x00000100u) != 0;
  return value;
}
inline bool Order::has_adjustedstopprice() const {
  return _internal_has_adjustedstopprice();
}
inline void Order::clear_adjustedstopprice() {
  adjustedstopprice_ = 0;
  _has_bits_[3] &= ~0x00000100u;
}
inline double Order::_internal_adjustedstopprice() const {
  return adjustedstopprice_;
}
inline double Order::adjustedstopprice() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.adjustedStopPrice)
  return _internal_adjustedstopprice();
}
inline void Order::_internal_set_adjustedstopprice(double value) {
  _has_bits_[3] |= 0x00000100u;
  adjustedstopprice_ = value;
}
inline void Order::set_adjustedstopprice(double value) {
  _internal_set_adjustedstopprice(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.adjustedStopPrice)
}

// double adjustedStopLimitPrice = 96;
inline bool Order::_internal_has_adjustedstoplimitprice() const {
  bool value = (_has_bits_[3] & 0x00004000u) != 0;
  return value;
}
inline bool Order::has_adjustedstoplimitprice() const {
  return _internal_has_adjustedstoplimitprice();
}
inline void Order::clear_adjustedstoplimitprice() {
  adjustedstoplimitprice_ = 0;
  _has_bits_[3] &= ~0x00004000u;
}
inline double Order::_internal_adjustedstoplimitprice() const {
  return adjustedstoplimitprice_;
}
inline double Order::adjustedstoplimitprice() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.adjustedStopLimitPrice)
  return _internal_adjustedstoplimitprice();
}
inline void Order::_internal_set_adjustedstoplimitprice(double value) {
  _has_bits_[3] |= 0x00004000u;
  adjustedstoplimitprice_ = value;
}
inline void Order::set_adjustedstoplimitprice(double value) {
  _internal_set_adjustedstoplimitprice(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.adjustedStopLimitPrice)
}

// double adjustedTrailingAmount = 97;
inline bool Order::_internal_has_adjustedtrailingamount() const {
  bool value = (_has_bits_[3] & 0x00008000u) != 0;
  return value;
}
inline bool Order::has_adjustedtrailingamount() const {
  return _internal_has_adjustedtrailingamount();
}
inline void Order::clear_adjustedtrailingamount() {
  adjustedtrailingamount_ = 0;
  _has_bits_[3] &= ~0x00008000u;
}
inline double Order::_internal_adjustedtrailingamount() const {
  return adjustedtrailingamount_;
}
inline double Order::adjustedtrailingamount() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.adjustedTrailingAmount)
  return _internal_adjustedtrailingamount();
}
inline void Order::_internal_set_adjustedtrailingamount(double value) {
  _has_bits_[3] |= 0x00008000u;
  adjustedtrailingamount_ = value;
}
inline void Order::set_adjustedtrailingamount(double value) {
  _internal_set_adjustedtrailingamount(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.adjustedTrailingAmount)
}

// int32 adjustableTrailingUnit = 98;
inline bool Order::_internal_has_adjustabletrailingunit() const {
  bool value = (_has_bits_[3] & 0x00002000u) != 0;
  return value;
}
inline bool Order::has_adjustabletrailingunit() const {
  return _internal_has_adjustabletrailingunit();
}
inline void Order::clear_adjustabletrailingunit() {
  adjustabletrailingunit_ = 0;
  _has_bits_[3] &= ~0x00002000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::_internal_adjustabletrailingunit() const {
  return adjustabletrailingunit_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::adjustabletrailingunit() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.adjustableTrailingUnit)
  return _internal_adjustabletrailingunit();
}
inline void Order::_internal_set_adjustabletrailingunit(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[3] |= 0x00002000u;
  adjustabletrailingunit_ = value;
}
inline void Order::set_adjustabletrailingunit(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_adjustabletrailingunit(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.adjustableTrailingUnit)
}

// double lmtPriceOffset = 99;
inline bool Order::_internal_has_lmtpriceoffset() const {
  bool value = (_has_bits_[3] & 0x00010000u) != 0;
  return value;
}
inline bool Order::has_lmtpriceoffset() const {
  return _internal_has_lmtpriceoffset();
}
inline void Order::clear_lmtpriceoffset() {
  lmtpriceoffset_ = 0;
  _has_bits_[3] &= ~0x00010000u;
}
inline double Order::_internal_lmtpriceoffset() const {
  return lmtpriceoffset_;
}
inline double Order::lmtpriceoffset() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.lmtPriceOffset)
  return _internal_lmtpriceoffset();
}
inline void Order::_internal_set_lmtpriceoffset(double value) {
  _has_bits_[3] |= 0x00010000u;
  lmtpriceoffset_ = value;
}
inline void Order::set_lmtpriceoffset(double value) {
  _internal_set_lmtpriceoffset(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.lmtPriceOffset)
}

// repeated .protobuf.OrderCondition conditions = 100;
inline int Order::_internal_conditions_size() const {
  return conditions_.size();
}
inline int Order::conditions_size() const {
  return _internal_conditions_size();
}
inline ::protobuf::OrderCondition* Order::mutable_conditions(int index) {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.conditions)
  return conditions_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::protobuf::OrderCondition >*
Order::mutable_conditions() {
  // @@protoc_insertion_point(field_mutable_list:protobuf.Order.conditions)
  return &conditions_;
}
inline const ::protobuf::OrderCondition& Order::_internal_conditions(int index) const {
  return conditions_.Get(index);
}
inline const ::protobuf::OrderCondition& Order::conditions(int index) const {
  // @@protoc_insertion_point(field_get:protobuf.Order.conditions)
  return _internal_conditions(index);
}
inline ::protobuf::OrderCondition* Order::_internal_add_conditions() {
  return conditions_.Add();
}
inline ::protobuf::OrderCondition* Order::add_conditions() {
  // @@protoc_insertion_point(field_add:protobuf.Order.conditions)
  return _internal_add_conditions();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::protobuf::OrderCondition >&
Order::conditions() const {
  // @@protoc_insertion_point(field_list:protobuf.Order.conditions)
  return conditions_;
}

// bool conditionsCancelOrder = 101;
inline bool Order::_internal_has_conditionscancelorder() const {
  bool value = (_has_bits_[3] & 0x00000800u) != 0;
  return value;
}
inline bool Order::has_conditionscancelorder() const {
  return _internal_has_conditionscancelorder();
}
inline void Order::clear_conditionscancelorder() {
  conditionscancelorder_ = false;
  _has_bits_[3] &= ~0x00000800u;
}
inline bool Order::_internal_conditionscancelorder() const {
  return conditionscancelorder_;
}
inline bool Order::conditionscancelorder() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.conditionsCancelOrder)
  return _internal_conditionscancelorder();
}
inline void Order::_internal_set_conditionscancelorder(bool value) {
  _has_bits_[3] |= 0x00000800u;
  conditionscancelorder_ = value;
}
inline void Order::set_conditionscancelorder(bool value) {
  _internal_set_conditionscancelorder(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.conditionsCancelOrder)
}

// bool conditionsIgnoreRth = 102;
inline bool Order::_internal_has_conditionsignorerth() const {
  bool value = (_has_bits_[3] & 0x00001000u) != 0;
  return value;
}
inline bool Order::has_conditionsignorerth() const {
  return _internal_has_conditionsignorerth();
}
inline void Order::clear_conditionsignorerth() {
  conditionsignorerth_ = false;
  _has_bits_[3] &= ~0x00001000u;
}
inline bool Order::_internal_conditionsignorerth() const {
  return conditionsignorerth_;
}
inline bool Order::conditionsignorerth() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.conditionsIgnoreRth)
  return _internal_conditionsignorerth();
}
inline void Order::_internal_set_conditionsignorerth(bool value) {
  _has_bits_[3] |= 0x00001000u;
  conditionsignorerth_ = value;
}
inline void Order::set_conditionsignorerth(bool value) {
  _internal_set_conditionsignorerth(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.conditionsIgnoreRth)
}

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

// string extOperator = 104;
inline bool Order::_internal_has_extoperator() const {
  bool value = (_has_bits_[1] & 0x00000004u) != 0;
  return value;
}
inline bool Order::has_extoperator() const {
  return _internal_has_extoperator();
}
inline void Order::clear_extoperator() {
  extoperator_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[1] &= ~0x00000004u;
}
inline const std::string& Order::extoperator() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.extOperator)
  return _internal_extoperator();
}
inline void Order::set_extoperator(const std::string& value) {
  _internal_set_extoperator(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.extOperator)
}
inline std::string* Order::mutable_extoperator() {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.extOperator)
  return _internal_mutable_extoperator();
}
inline const std::string& Order::_internal_extoperator() const {
  return extoperator_.Get();
}
inline void Order::_internal_set_extoperator(const std::string& value) {
  _has_bits_[1] |= 0x00000004u;
  extoperator_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Order::set_extoperator(std::string&& value) {
  _has_bits_[1] |= 0x00000004u;
  extoperator_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Order.extOperator)
}
inline void Order::set_extoperator(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[1] |= 0x00000004u;
  extoperator_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Order.extOperator)
}
inline void Order::set_extoperator(const char* value,
    size_t size) {
  _has_bits_[1] |= 0x00000004u;
  extoperator_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Order.extOperator)
}
inline std::string* Order::_internal_mutable_extoperator() {
  _has_bits_[1] |= 0x00000004u;
  return extoperator_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Order::release_extoperator() {
  // @@protoc_insertion_point(field_release:protobuf.Order.extOperator)
  if (!_internal_has_extoperator()) {
    return nullptr;
  }
  _has_bits_[1] &= ~0x00000004u;
  return extoperator_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Order::set_allocated_extoperator(std::string* extoperator) {
  if (extoperator != nullptr) {
    _has_bits_[1] |= 0x00000004u;
  } else {
    _has_bits_[1] &= ~0x00000004u;
  }
  extoperator_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), extoperator,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Order.extOperator)
}
inline std::string* Order::unsafe_arena_release_extoperator() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Order.extOperator)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[1] &= ~0x00000004u;
  return extoperator_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Order::unsafe_arena_set_allocated_extoperator(
    std::string* extoperator) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (extoperator != nullptr) {
    _has_bits_[1] |= 0x00000004u;
  } else {
    _has_bits_[1] &= ~0x00000004u;
  }
  extoperator_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      extoperator, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Order.extOperator)
}

// .protobuf.SoftDollarTier softDollarTier = 105;
inline bool Order::_internal_has_softdollartier() const {
  bool value = (_has_bits_[1] & 0x00008000u) != 0;
  PROTOBUF_ASSUME(!value || softdollartier_ != nullptr);
  return value;
}
inline bool Order::has_softdollartier() const {
  return _internal_has_softdollartier();
}
inline const ::protobuf::SoftDollarTier& Order::_internal_softdollartier() const {
  const ::protobuf::SoftDollarTier* p = softdollartier_;
  return p != nullptr ? *p : *reinterpret_cast<const ::protobuf::SoftDollarTier*>(
      &::protobuf::_SoftDollarTier_default_instance_);
}
inline const ::protobuf::SoftDollarTier& Order::softdollartier() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.softDollarTier)
  return _internal_softdollartier();
}
inline void Order::unsafe_arena_set_allocated_softdollartier(
    ::protobuf::SoftDollarTier* softdollartier) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(softdollartier_);
  }
  softdollartier_ = softdollartier;
  if (softdollartier) {
    _has_bits_[1] |= 0x00008000u;
  } else {
    _has_bits_[1] &= ~0x00008000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Order.softDollarTier)
}
inline ::protobuf::SoftDollarTier* Order::release_softdollartier() {
  auto temp = unsafe_arena_release_softdollartier();
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::protobuf::SoftDollarTier* Order::unsafe_arena_release_softdollartier() {
  // @@protoc_insertion_point(field_release:protobuf.Order.softDollarTier)
  _has_bits_[1] &= ~0x00008000u;
  ::protobuf::SoftDollarTier* temp = softdollartier_;
  softdollartier_ = nullptr;
  return temp;
}
inline ::protobuf::SoftDollarTier* Order::_internal_mutable_softdollartier() {
  _has_bits_[1] |= 0x00008000u;
  if (softdollartier_ == nullptr) {
    auto* p = CreateMaybeMessage<::protobuf::SoftDollarTier>(GetArena());
    softdollartier_ = p;
  }
  return softdollartier_;
}
inline ::protobuf::SoftDollarTier* Order::mutable_softdollartier() {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.softDollarTier)
  return _internal_mutable_softdollartier();
}
inline void Order::set_allocated_softdollartier(::protobuf::SoftDollarTier* softdollartier) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(softdollartier_);
  }
  if (softdollartier) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(softdollartier)->GetArena();
    if (message_arena != submessage_arena) {
      softdollartier = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, softdollartier, submessage_arena);
    }
    _has_bits_[1] |= 0x00008000u;
  } else {
    _has_bits_[1] &= ~0x00008000u;
  }
  softdollartier_ = softdollartier;
  // @@protoc_insertion_point(field_set_allocated:protobuf.Order.softDollarTier)
}

// double cashQty = 106;
inline bool Order::_internal_has_cashqty() const {
  bool value = (_has_bits_[3] & 0x00020000u) != 0;
  return value;
}
inline bool Order::has_cashqty() const {
  return _internal_has_cashqty();
}
inline void Order::clear_cashqty() {
  cashqty_ = 0;
  _has_bits_[3] &= ~0x00020000u;
}
inline double Order::_internal_cashqty() const {
  return cashqty_;
}
inline double Order::cashqty() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.cashQty)
  return _internal_cashqty();
}
inline void Order::_internal_set_cashqty(double value) {
  _has_bits_[3] |= 0x00020000u;
  cashqty_ = value;
}
inline void Order::set_cashqty(double value) {
  _internal_set_cashqty(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.cashQty)
}

// string mifid2DecisionMaker = 107;
inline bool Order::_internal_has_mifid2decisionmaker() const {
  bool value = (_has_bits_[1] & 0x00000008u) != 0;
  return value;
}
inline bool Order::has_mifid2decisionmaker() const {
  return _internal_has_mifid2decisionmaker();
}
inline void Order::clear_mifid2decisionmaker() {
  mifid2decisionmaker_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[1] &= ~0x00000008u;
}
inline const std::string& Order::mifid2decisionmaker() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.mifid2DecisionMaker)
  return _internal_mifid2decisionmaker();
}
inline void Order::set_mifid2decisionmaker(const std::string& value) {
  _internal_set_mifid2decisionmaker(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.mifid2DecisionMaker)
}
inline std::string* Order::mutable_mifid2decisionmaker() {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.mifid2DecisionMaker)
  return _internal_mutable_mifid2decisionmaker();
}
inline const std::string& Order::_internal_mifid2decisionmaker() const {
  return mifid2decisionmaker_.Get();
}
inline void Order::_internal_set_mifid2decisionmaker(const std::string& value) {
  _has_bits_[1] |= 0x00000008u;
  mifid2decisionmaker_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Order::set_mifid2decisionmaker(std::string&& value) {
  _has_bits_[1] |= 0x00000008u;
  mifid2decisionmaker_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Order.mifid2DecisionMaker)
}
inline void Order::set_mifid2decisionmaker(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[1] |= 0x00000008u;
  mifid2decisionmaker_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Order.mifid2DecisionMaker)
}
inline void Order::set_mifid2decisionmaker(const char* value,
    size_t size) {
  _has_bits_[1] |= 0x00000008u;
  mifid2decisionmaker_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Order.mifid2DecisionMaker)
}
inline std::string* Order::_internal_mutable_mifid2decisionmaker() {
  _has_bits_[1] |= 0x00000008u;
  return mifid2decisionmaker_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Order::release_mifid2decisionmaker() {
  // @@protoc_insertion_point(field_release:protobuf.Order.mifid2DecisionMaker)
  if (!_internal_has_mifid2decisionmaker()) {
    return nullptr;
  }
  _has_bits_[1] &= ~0x00000008u;
  return mifid2decisionmaker_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Order::set_allocated_mifid2decisionmaker(std::string* mifid2decisionmaker) {
  if (mifid2decisionmaker != nullptr) {
    _has_bits_[1] |= 0x00000008u;
  } else {
    _has_bits_[1] &= ~0x00000008u;
  }
  mifid2decisionmaker_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), mifid2decisionmaker,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Order.mifid2DecisionMaker)
}
inline std::string* Order::unsafe_arena_release_mifid2decisionmaker() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Order.mifid2DecisionMaker)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[1] &= ~0x00000008u;
  return mifid2decisionmaker_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Order::unsafe_arena_set_allocated_mifid2decisionmaker(
    std::string* mifid2decisionmaker) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (mifid2decisionmaker != nullptr) {
    _has_bits_[1] |= 0x00000008u;
  } else {
    _has_bits_[1] &= ~0x00000008u;
  }
  mifid2decisionmaker_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      mifid2decisionmaker, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Order.mifid2DecisionMaker)
}

// string mifid2DecisionAlgo = 108;
inline bool Order::_internal_has_mifid2decisionalgo() const {
  bool value = (_has_bits_[1] & 0x00000010u) != 0;
  return value;
}
inline bool Order::has_mifid2decisionalgo() const {
  return _internal_has_mifid2decisionalgo();
}
inline void Order::clear_mifid2decisionalgo() {
  mifid2decisionalgo_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[1] &= ~0x00000010u;
}
inline const std::string& Order::mifid2decisionalgo() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.mifid2DecisionAlgo)
  return _internal_mifid2decisionalgo();
}
inline void Order::set_mifid2decisionalgo(const std::string& value) {
  _internal_set_mifid2decisionalgo(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.mifid2DecisionAlgo)
}
inline std::string* Order::mutable_mifid2decisionalgo() {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.mifid2DecisionAlgo)
  return _internal_mutable_mifid2decisionalgo();
}
inline const std::string& Order::_internal_mifid2decisionalgo() const {
  return mifid2decisionalgo_.Get();
}
inline void Order::_internal_set_mifid2decisionalgo(const std::string& value) {
  _has_bits_[1] |= 0x00000010u;
  mifid2decisionalgo_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Order::set_mifid2decisionalgo(std::string&& value) {
  _has_bits_[1] |= 0x00000010u;
  mifid2decisionalgo_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Order.mifid2DecisionAlgo)
}
inline void Order::set_mifid2decisionalgo(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[1] |= 0x00000010u;
  mifid2decisionalgo_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Order.mifid2DecisionAlgo)
}
inline void Order::set_mifid2decisionalgo(const char* value,
    size_t size) {
  _has_bits_[1] |= 0x00000010u;
  mifid2decisionalgo_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Order.mifid2DecisionAlgo)
}
inline std::string* Order::_internal_mutable_mifid2decisionalgo() {
  _has_bits_[1] |= 0x00000010u;
  return mifid2decisionalgo_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Order::release_mifid2decisionalgo() {
  // @@protoc_insertion_point(field_release:protobuf.Order.mifid2DecisionAlgo)
  if (!_internal_has_mifid2decisionalgo()) {
    return nullptr;
  }
  _has_bits_[1] &= ~0x00000010u;
  return mifid2decisionalgo_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Order::set_allocated_mifid2decisionalgo(std::string* mifid2decisionalgo) {
  if (mifid2decisionalgo != nullptr) {
    _has_bits_[1] |= 0x00000010u;
  } else {
    _has_bits_[1] &= ~0x00000010u;
  }
  mifid2decisionalgo_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), mifid2decisionalgo,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Order.mifid2DecisionAlgo)
}
inline std::string* Order::unsafe_arena_release_mifid2decisionalgo() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Order.mifid2DecisionAlgo)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[1] &= ~0x00000010u;
  return mifid2decisionalgo_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Order::unsafe_arena_set_allocated_mifid2decisionalgo(
    std::string* mifid2decisionalgo) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (mifid2decisionalgo != nullptr) {
    _has_bits_[1] |= 0x00000010u;
  } else {
    _has_bits_[1] &= ~0x00000010u;
  }
  mifid2decisionalgo_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      mifid2decisionalgo, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Order.mifid2DecisionAlgo)
}

// string mifid2ExecutionTrader = 109;
inline bool Order::_internal_has_mifid2executiontrader() const {
  bool value = (_has_bits_[1] & 0x00000020u) != 0;
  return value;
}
inline bool Order::has_mifid2executiontrader() const {
  return _internal_has_mifid2executiontrader();
}
inline void Order::clear_mifid2executiontrader() {
  mifid2executiontrader_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[1] &= ~0x00000020u;
}
inline const std::string& Order::mifid2executiontrader() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.mifid2ExecutionTrader)
  return _internal_mifid2executiontrader();
}
inline void Order::set_mifid2executiontrader(const std::string& value) {
  _internal_set_mifid2executiontrader(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.mifid2ExecutionTrader)
}
inline std::string* Order::mutable_mifid2executiontrader() {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.mifid2ExecutionTrader)
  return _internal_mutable_mifid2executiontrader();
}
inline const std::string& Order::_internal_mifid2executiontrader() const {
  return mifid2executiontrader_.Get();
}
inline void Order::_internal_set_mifid2executiontrader(const std::string& value) {
  _has_bits_[1] |= 0x00000020u;
  mifid2executiontrader_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Order::set_mifid2executiontrader(std::string&& value) {
  _has_bits_[1] |= 0x00000020u;
  mifid2executiontrader_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Order.mifid2ExecutionTrader)
}
inline void Order::set_mifid2executiontrader(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[1] |= 0x00000020u;
  mifid2executiontrader_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Order.mifid2ExecutionTrader)
}
inline void Order::set_mifid2executiontrader(const char* value,
    size_t size) {
  _has_bits_[1] |= 0x00000020u;
  mifid2executiontrader_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Order.mifid2ExecutionTrader)
}
inline std::string* Order::_internal_mutable_mifid2executiontrader() {
  _has_bits_[1] |= 0x00000020u;
  return mifid2executiontrader_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Order::release_mifid2executiontrader() {
  // @@protoc_insertion_point(field_release:protobuf.Order.mifid2ExecutionTrader)
  if (!_internal_has_mifid2executiontrader()) {
    return nullptr;
  }
  _has_bits_[1] &= ~0x00000020u;
  return mifid2executiontrader_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Order::set_allocated_mifid2executiontrader(std::string* mifid2executiontrader) {
  if (mifid2executiontrader != nullptr) {
    _has_bits_[1] |= 0x00000020u;
  } else {
    _has_bits_[1] &= ~0x00000020u;
  }
  mifid2executiontrader_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), mifid2executiontrader,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Order.mifid2ExecutionTrader)
}
inline std::string* Order::unsafe_arena_release_mifid2executiontrader() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Order.mifid2ExecutionTrader)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[1] &= ~0x00000020u;
  return mifid2executiontrader_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Order::unsafe_arena_set_allocated_mifid2executiontrader(
    std::string* mifid2executiontrader) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (mifid2executiontrader != nullptr) {
    _has_bits_[1] |= 0x00000020u;
  } else {
    _has_bits_[1] &= ~0x00000020u;
  }
  mifid2executiontrader_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      mifid2executiontrader, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Order.mifid2ExecutionTrader)
}

// string mifid2ExecutionAlgo = 110;
inline bool Order::_internal_has_mifid2executionalgo() const {
  bool value = (_has_bits_[1] & 0x00000040u) != 0;
  return value;
}
inline bool Order::has_mifid2executionalgo() const {
  return _internal_has_mifid2executionalgo();
}
inline void Order::clear_mifid2executionalgo() {
  mifid2executionalgo_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[1] &= ~0x00000040u;
}
inline const std::string& Order::mifid2executionalgo() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.mifid2ExecutionAlgo)
  return _internal_mifid2executionalgo();
}
inline void Order::set_mifid2executionalgo(const std::string& value) {
  _internal_set_mifid2executionalgo(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.mifid2ExecutionAlgo)
}
inline std::string* Order::mutable_mifid2executionalgo() {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.mifid2ExecutionAlgo)
  return _internal_mutable_mifid2executionalgo();
}
inline const std::string& Order::_internal_mifid2executionalgo() const {
  return mifid2executionalgo_.Get();
}
inline void Order::_internal_set_mifid2executionalgo(const std::string& value) {
  _has_bits_[1] |= 0x00000040u;
  mifid2executionalgo_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Order::set_mifid2executionalgo(std::string&& value) {
  _has_bits_[1] |= 0x00000040u;
  mifid2executionalgo_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Order.mifid2ExecutionAlgo)
}
inline void Order::set_mifid2executionalgo(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[1] |= 0x00000040u;
  mifid2executionalgo_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Order.mifid2ExecutionAlgo)
}
inline void Order::set_mifid2executionalgo(const char* value,
    size_t size) {
  _has_bits_[1] |= 0x00000040u;
  mifid2executionalgo_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Order.mifid2ExecutionAlgo)
}
inline std::string* Order::_internal_mutable_mifid2executionalgo() {
  _has_bits_[1] |= 0x00000040u;
  return mifid2executionalgo_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Order::release_mifid2executionalgo() {
  // @@protoc_insertion_point(field_release:protobuf.Order.mifid2ExecutionAlgo)
  if (!_internal_has_mifid2executionalgo()) {
    return nullptr;
  }
  _has_bits_[1] &= ~0x00000040u;
  return mifid2executionalgo_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Order::set_allocated_mifid2executionalgo(std::string* mifid2executionalgo) {
  if (mifid2executionalgo != nullptr) {
    _has_bits_[1] |= 0x00000040u;
  } else {
    _has_bits_[1] &= ~0x00000040u;
  }
  mifid2executionalgo_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), mifid2executionalgo,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Order.mifid2ExecutionAlgo)
}
inline std::string* Order::unsafe_arena_release_mifid2executionalgo() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Order.mifid2ExecutionAlgo)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[1] &= ~0x00000040u;
  return mifid2executionalgo_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Order::unsafe_arena_set_allocated_mifid2executionalgo(
    std::string* mifid2executionalgo) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (mifid2executionalgo != nullptr) {
    _has_bits_[1] |= 0x00000040u;
  } else {
    _has_bits_[1] &= ~0x00000040u;
  }
  mifid2executionalgo_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      mifid2executionalgo, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Order.mifid2ExecutionAlgo)
}

// bool dontUseAutoPriceForHedge = 111;
inline bool Order::_internal_has_dontuseautopriceforhedge() const {
  bool value = (_has_bits_[3] & 0x00040000u) != 0;
  return value;
}
inline bool Order::has_dontuseautopriceforhedge() const {
  return _internal_has_dontuseautopriceforhedge();
}
inline void Order::clear_dontuseautopriceforhedge() {
  dontuseautopriceforhedge_ = false;
  _has_bits_[3] &= ~0x00040000u;
}
inline bool Order::_internal_dontuseautopriceforhedge() const {
  return dontuseautopriceforhedge_;
}
inline bool Order::dontuseautopriceforhedge() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.dontUseAutoPriceForHedge)
  return _internal_dontuseautopriceforhedge();
}
inline void Order::_internal_set_dontuseautopriceforhedge(bool value) {
  _has_bits_[3] |= 0x00040000u;
  dontuseautopriceforhedge_ = value;
}
inline void Order::set_dontuseautopriceforhedge(bool value) {
  _internal_set_dontuseautopriceforhedge(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.dontUseAutoPriceForHedge)
}

// bool isOmsContainer = 112;
inline bool Order::_internal_has_isomscontainer() const {
  bool value = (_has_bits_[3] & 0x00080000u) != 0;
  return value;
}
inline bool Order::has_isomscontainer() const {
  return _internal_has_isomscontainer();
}
inline void Order::clear_isomscontainer() {
  isomscontainer_ = false;
  _has_bits_[3] &= ~0x00080000u;
}
inline bool Order::_internal_isomscontainer() const {
  return isomscontainer_;
}
inline bool Order::isomscontainer() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.isOmsContainer)
  return _internal_isomscontainer();
}
inline void Order::_internal_set_isomscontainer(bool value) {
  _has_bits_[3] |= 0x00080000u;
  isomscontainer_ = value;
}
inline void Order::set_isomscontainer(bool value) {
  _internal_set_isomscontainer(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.isOmsContainer)
}

// bool discretionaryUpToLimitPrice = 113;
inline bool Order::_internal_has_discretionaryuptolimitprice() const {
  bool value = (_has_bits_[3] & 0x00100000u) != 0;
  return value;
}
inline bool Order::has_discretionaryuptolimitprice() const {
  return _internal_has_discretionaryuptolimitprice();
}
inline void Order::clear_discretionaryuptolimitprice() {
  discretionaryuptolimitprice_ = false;
  _has_bits_[3] &= ~0x00100000u;
}
inline bool Order::_internal_discretionaryuptolimitprice() const {
  return discretionaryuptolimitprice_;
}
inline bool Order::discretionaryuptolimitprice() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.discretionaryUpToLimitPrice)
  return _internal_discretionaryuptolimitprice();
}
inline void Order::_internal_set_discretionaryuptolimitprice(bool value) {
  _has_bits_[3] |= 0x00100000u;
  discretionaryuptolimitprice_ = value;
}
inline void Order::set_discretionaryuptolimitprice(bool value) {
  _internal_set_discretionaryuptolimitprice(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.discretionaryUpToLimitPrice)
}

// string autoCancelDate = 114;
inline bool Order::_internal_has_autocanceldate() const {
  bool value = (_has_bits_[1] & 0x00000080u) != 0;
  return value;
}
inline bool Order::has_autocanceldate() const {
  return _internal_has_autocanceldate();
}
inline void Order::clear_autocanceldate() {
  autocanceldate_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[1] &= ~0x00000080u;
}
inline const std::string& Order::autocanceldate() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.autoCancelDate)
  return _internal_autocanceldate();
}
inline void Order::set_autocanceldate(const std::string& value) {
  _internal_set_autocanceldate(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.autoCancelDate)
}
inline std::string* Order::mutable_autocanceldate() {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.autoCancelDate)
  return _internal_mutable_autocanceldate();
}
inline const std::string& Order::_internal_autocanceldate() const {
  return autocanceldate_.Get();
}
inline void Order::_internal_set_autocanceldate(const std::string& value) {
  _has_bits_[1] |= 0x00000080u;
  autocanceldate_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Order::set_autocanceldate(std::string&& value) {
  _has_bits_[1] |= 0x00000080u;
  autocanceldate_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Order.autoCancelDate)
}
inline void Order::set_autocanceldate(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[1] |= 0x00000080u;
  autocanceldate_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Order.autoCancelDate)
}
inline void Order::set_autocanceldate(const char* value,
    size_t size) {
  _has_bits_[1] |= 0x00000080u;
  autocanceldate_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Order.autoCancelDate)
}
inline std::string* Order::_internal_mutable_autocanceldate() {
  _has_bits_[1] |= 0x00000080u;
  return autocanceldate_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Order::release_autocanceldate() {
  // @@protoc_insertion_point(field_release:protobuf.Order.autoCancelDate)
  if (!_internal_has_autocanceldate()) {
    return nullptr;
  }
  _has_bits_[1] &= ~0x00000080u;
  return autocanceldate_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Order::set_allocated_autocanceldate(std::string* autocanceldate) {
  if (autocanceldate != nullptr) {
    _has_bits_[1] |= 0x00000080u;
  } else {
    _has_bits_[1] &= ~0x00000080u;
  }
  autocanceldate_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), autocanceldate,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Order.autoCancelDate)
}
inline std::string* Order::unsafe_arena_release_autocanceldate() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Order.autoCancelDate)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[1] &= ~0x00000080u;
  return autocanceldate_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Order::unsafe_arena_set_allocated_autocanceldate(
    std::string* autocanceldate) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (autocanceldate != nullptr) {
    _has_bits_[1] |= 0x00000080u;
  } else {
    _has_bits_[1] &= ~0x00000080u;
  }
  autocanceldate_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      autocanceldate, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Order.autoCancelDate)
}

// string filledQuantity = 115;
inline bool Order::_internal_has_filledquantity() const {
  bool value = (_has_bits_[1] & 0x00000100u) != 0;
  return value;
}
inline bool Order::has_filledquantity() const {
  return _internal_has_filledquantity();
}
inline void Order::clear_filledquantity() {
  filledquantity_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[1] &= ~0x00000100u;
}
inline const std::string& Order::filledquantity() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.filledQuantity)
  return _internal_filledquantity();
}
inline void Order::set_filledquantity(const std::string& value) {
  _internal_set_filledquantity(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.filledQuantity)
}
inline std::string* Order::mutable_filledquantity() {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.filledQuantity)
  return _internal_mutable_filledquantity();
}
inline const std::string& Order::_internal_filledquantity() const {
  return filledquantity_.Get();
}
inline void Order::_internal_set_filledquantity(const std::string& value) {
  _has_bits_[1] |= 0x00000100u;
  filledquantity_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Order::set_filledquantity(std::string&& value) {
  _has_bits_[1] |= 0x00000100u;
  filledquantity_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Order.filledQuantity)
}
inline void Order::set_filledquantity(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[1] |= 0x00000100u;
  filledquantity_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Order.filledQuantity)
}
inline void Order::set_filledquantity(const char* value,
    size_t size) {
  _has_bits_[1] |= 0x00000100u;
  filledquantity_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Order.filledQuantity)
}
inline std::string* Order::_internal_mutable_filledquantity() {
  _has_bits_[1] |= 0x00000100u;
  return filledquantity_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Order::release_filledquantity() {
  // @@protoc_insertion_point(field_release:protobuf.Order.filledQuantity)
  if (!_internal_has_filledquantity()) {
    return nullptr;
  }
  _has_bits_[1] &= ~0x00000100u;
  return filledquantity_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Order::set_allocated_filledquantity(std::string* filledquantity) {
  if (filledquantity != nullptr) {
    _has_bits_[1] |= 0x00000100u;
  } else {
    _has_bits_[1] &= ~0x00000100u;
  }
  filledquantity_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), filledquantity,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Order.filledQuantity)
}
inline std::string* Order::unsafe_arena_release_filledquantity() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Order.filledQuantity)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[1] &= ~0x00000100u;
  return filledquantity_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Order::unsafe_arena_set_allocated_filledquantity(
    std::string* filledquantity) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (filledquantity != nullptr) {
    _has_bits_[1] |= 0x00000100u;
  } else {
    _has_bits_[1] &= ~0x00000100u;
  }
  filledquantity_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      filledquantity, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Order.filledQuantity)
}

// int32 refFuturesConId = 116;
inline bool Order::_internal_has_reffuturesconid() const {
  bool value = (_has_bits_[3] & 0x00400000u) != 0;
  return value;
}
inline bool Order::has_reffuturesconid() const {
  return _internal_has_reffuturesconid();
}
inline void Order::clear_reffuturesconid() {
  reffuturesconid_ = 0;
  _has_bits_[3] &= ~0x00400000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::_internal_reffuturesconid() const {
  return reffuturesconid_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::reffuturesconid() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.refFuturesConId)
  return _internal_reffuturesconid();
}
inline void Order::_internal_set_reffuturesconid(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[3] |= 0x00400000u;
  reffuturesconid_ = value;
}
inline void Order::set_reffuturesconid(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_reffuturesconid(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.refFuturesConId)
}

// bool autoCancelParent = 117;
inline bool Order::_internal_has_autocancelparent() const {
  bool value = (_has_bits_[3] & 0x00200000u) != 0;
  return value;
}
inline bool Order::has_autocancelparent() const {
  return _internal_has_autocancelparent();
}
inline void Order::clear_autocancelparent() {
  autocancelparent_ = false;
  _has_bits_[3] &= ~0x00200000u;
}
inline bool Order::_internal_autocancelparent() const {
  return autocancelparent_;
}
inline bool Order::autocancelparent() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.autoCancelParent)
  return _internal_autocancelparent();
}
inline void Order::_internal_set_autocancelparent(bool value) {
  _has_bits_[3] |= 0x00200000u;
  autocancelparent_ = value;
}
inline void Order::set_autocancelparent(bool value) {
  _internal_set_autocancelparent(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.autoCancelParent)
}

// string shareholder = 118;
inline bool Order::_internal_has_shareholder() const {
  bool value = (_has_bits_[1] & 0x00000200u) != 0;
  return value;
}
inline bool Order::has_shareholder() const {
  return _internal_has_shareholder();
}
inline void Order::clear_shareholder() {
  shareholder_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[1] &= ~0x00000200u;
}
inline const std::string& Order::shareholder() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.shareholder)
  return _internal_shareholder();
}
inline void Order::set_shareholder(const std::string& value) {
  _internal_set_shareholder(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.shareholder)
}
inline std::string* Order::mutable_shareholder() {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.shareholder)
  return _internal_mutable_shareholder();
}
inline const std::string& Order::_internal_shareholder() const {
  return shareholder_.Get();
}
inline void Order::_internal_set_shareholder(const std::string& value) {
  _has_bits_[1] |= 0x00000200u;
  shareholder_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Order::set_shareholder(std::string&& value) {
  _has_bits_[1] |= 0x00000200u;
  shareholder_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Order.shareholder)
}
inline void Order::set_shareholder(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[1] |= 0x00000200u;
  shareholder_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Order.shareholder)
}
inline void Order::set_shareholder(const char* value,
    size_t size) {
  _has_bits_[1] |= 0x00000200u;
  shareholder_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Order.shareholder)
}
inline std::string* Order::_internal_mutable_shareholder() {
  _has_bits_[1] |= 0x00000200u;
  return shareholder_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Order::release_shareholder() {
  // @@protoc_insertion_point(field_release:protobuf.Order.shareholder)
  if (!_internal_has_shareholder()) {
    return nullptr;
  }
  _has_bits_[1] &= ~0x00000200u;
  return shareholder_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Order::set_allocated_shareholder(std::string* shareholder) {
  if (shareholder != nullptr) {
    _has_bits_[1] |= 0x00000200u;
  } else {
    _has_bits_[1] &= ~0x00000200u;
  }
  shareholder_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), shareholder,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Order.shareholder)
}
inline std::string* Order::unsafe_arena_release_shareholder() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Order.shareholder)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[1] &= ~0x00000200u;
  return shareholder_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Order::unsafe_arena_set_allocated_shareholder(
    std::string* shareholder) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (shareholder != nullptr) {
    _has_bits_[1] |= 0x00000200u;
  } else {
    _has_bits_[1] &= ~0x00000200u;
  }
  shareholder_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      shareholder, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Order.shareholder)
}

// bool imbalanceOnly = 119;
inline bool Order::_internal_has_imbalanceonly() const {
  bool value = (_has_bits_[3] & 0x08000000u) != 0;
  return value;
}
inline bool Order::has_imbalanceonly() const {
  return _internal_has_imbalanceonly();
}
inline void Order::clear_imbalanceonly() {
  imbalanceonly_ = false;
  _has_bits_[3] &= ~0x08000000u;
}
inline bool Order::_internal_imbalanceonly() const {
  return imbalanceonly_;
}
inline bool Order::imbalanceonly() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.imbalanceOnly)
  return _internal_imbalanceonly();
}
inline void Order::_internal_set_imbalanceonly(bool value) {
  _has_bits_[3] |= 0x08000000u;
  imbalanceonly_ = value;
}
inline void Order::set_imbalanceonly(bool value) {
  _internal_set_imbalanceonly(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.imbalanceOnly)
}

// bool routeMarketableToBbo = 120;
inline bool Order::_internal_has_routemarketabletobbo() const {
  bool value = (_has_bits_[3] & 0x10000000u) != 0;
  return value;
}
inline bool Order::has_routemarketabletobbo() const {
  return _internal_has_routemarketabletobbo();
}
inline void Order::clear_routemarketabletobbo() {
  routemarketabletobbo_ = false;
  _has_bits_[3] &= ~0x10000000u;
}
inline bool Order::_internal_routemarketabletobbo() const {
  return routemarketabletobbo_;
}
inline bool Order::routemarketabletobbo() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.routeMarketableToBbo)
  return _internal_routemarketabletobbo();
}
inline void Order::_internal_set_routemarketabletobbo(bool value) {
  _has_bits_[3] |= 0x10000000u;
  routemarketabletobbo_ = value;
}
inline void Order::set_routemarketabletobbo(bool value) {
  _internal_set_routemarketabletobbo(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.routeMarketableToBbo)
}

// int64 parentPermId = 121;
inline bool Order::_internal_has_parentpermid() const {
  bool value = (_has_bits_[3] & 0x00800000u) != 0;
  return value;
}
inline bool Order::has_parentpermid() const {
  return _internal_has_parentpermid();
}
inline void Order::clear_parentpermid() {
  parentpermid_ = PROTOBUF_LONGLONG(0);
  _has_bits_[3] &= ~0x00800000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 Order::_internal_parentpermid() const {
  return parentpermid_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 Order::parentpermid() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.parentPermId)
  return _internal_parentpermid();
}
inline void Order::_internal_set_parentpermid(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _has_bits_[3] |= 0x00800000u;
  parentpermid_ = value;
}
inline void Order::set_parentpermid(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_parentpermid(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.parentPermId)
}

// int32 usePriceMgmtAlgo = 122;
inline bool Order::_internal_has_usepricemgmtalgo() const {
  bool value = (_has_bits_[3] & 0x01000000u) != 0;
  return value;
}
inline bool Order::has_usepricemgmtalgo() const {
  return _internal_has_usepricemgmtalgo();
}
inline void Order::clear_usepricemgmtalgo() {
  usepricemgmtalgo_ = 0;
  _has_bits_[3] &= ~0x01000000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::_internal_usepricemgmtalgo() const {
  return usepricemgmtalgo_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::usepricemgmtalgo() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.usePriceMgmtAlgo)
  return _internal_usepricemgmtalgo();
}
inline void Order::_internal_set_usepricemgmtalgo(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[3] |= 0x01000000u;
  usepricemgmtalgo_ = value;
}
inline void Order::set_usepricemgmtalgo(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_usepricemgmtalgo(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.usePriceMgmtAlgo)
}

// int32 duration = 123;
inline bool Order::_internal_has_duration() const {
  bool value = (_has_bits_[3] & 0x02000000u) != 0;
  return value;
}
inline bool Order::has_duration() const {
  return _internal_has_duration();
}
inline void Order::clear_duration() {
  duration_ = 0;
  _has_bits_[3] &= ~0x02000000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::_internal_duration() const {
  return duration_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::duration() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.duration)
  return _internal_duration();
}
inline void Order::_internal_set_duration(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[3] |= 0x02000000u;
  duration_ = value;
}
inline void Order::set_duration(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_duration(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.duration)
}

// int32 postToAts = 124;
inline bool Order::_internal_has_posttoats() const {
  bool value = (_has_bits_[3] & 0x04000000u) != 0;
  return value;
}
inline bool Order::has_posttoats() const {
  return _internal_has_posttoats();
}
inline void Order::clear_posttoats() {
  posttoats_ = 0;
  _has_bits_[3] &= ~0x04000000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::_internal_posttoats() const {
  return posttoats_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::posttoats() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.postToAts)
  return _internal_posttoats();
}
inline void Order::_internal_set_posttoats(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[3] |= 0x04000000u;
  posttoats_ = value;
}
inline void Order::set_posttoats(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_posttoats(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.postToAts)
}

// string advancedErrorOverride = 125;
inline bool Order::_internal_has_advancederroroverride() const {
  bool value = (_has_bits_[1] & 0x00000400u) != 0;
  return value;
}
inline bool Order::has_advancederroroverride() const {
  return _internal_has_advancederroroverride();
}
inline void Order::clear_advancederroroverride() {
  advancederroroverride_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[1] &= ~0x00000400u;
}
inline const std::string& Order::advancederroroverride() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.advancedErrorOverride)
  return _internal_advancederroroverride();
}
inline void Order::set_advancederroroverride(const std::string& value) {
  _internal_set_advancederroroverride(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.advancedErrorOverride)
}
inline std::string* Order::mutable_advancederroroverride() {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.advancedErrorOverride)
  return _internal_mutable_advancederroroverride();
}
inline const std::string& Order::_internal_advancederroroverride() const {
  return advancederroroverride_.Get();
}
inline void Order::_internal_set_advancederroroverride(const std::string& value) {
  _has_bits_[1] |= 0x00000400u;
  advancederroroverride_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Order::set_advancederroroverride(std::string&& value) {
  _has_bits_[1] |= 0x00000400u;
  advancederroroverride_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Order.advancedErrorOverride)
}
inline void Order::set_advancederroroverride(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[1] |= 0x00000400u;
  advancederroroverride_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Order.advancedErrorOverride)
}
inline void Order::set_advancederroroverride(const char* value,
    size_t size) {
  _has_bits_[1] |= 0x00000400u;
  advancederroroverride_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Order.advancedErrorOverride)
}
inline std::string* Order::_internal_mutable_advancederroroverride() {
  _has_bits_[1] |= 0x00000400u;
  return advancederroroverride_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Order::release_advancederroroverride() {
  // @@protoc_insertion_point(field_release:protobuf.Order.advancedErrorOverride)
  if (!_internal_has_advancederroroverride()) {
    return nullptr;
  }
  _has_bits_[1] &= ~0x00000400u;
  return advancederroroverride_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Order::set_allocated_advancederroroverride(std::string* advancederroroverride) {
  if (advancederroroverride != nullptr) {
    _has_bits_[1] |= 0x00000400u;
  } else {
    _has_bits_[1] &= ~0x00000400u;
  }
  advancederroroverride_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), advancederroroverride,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Order.advancedErrorOverride)
}
inline std::string* Order::unsafe_arena_release_advancederroroverride() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Order.advancedErrorOverride)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[1] &= ~0x00000400u;
  return advancederroroverride_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Order::unsafe_arena_set_allocated_advancederroroverride(
    std::string* advancederroroverride) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (advancederroroverride != nullptr) {
    _has_bits_[1] |= 0x00000400u;
  } else {
    _has_bits_[1] &= ~0x00000400u;
  }
  advancederroroverride_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      advancederroroverride, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Order.advancedErrorOverride)
}

// string manualOrderTime = 126;
inline bool Order::_internal_has_manualordertime() const {
  bool value = (_has_bits_[1] & 0x00000800u) != 0;
  return value;
}
inline bool Order::has_manualordertime() const {
  return _internal_has_manualordertime();
}
inline void Order::clear_manualordertime() {
  manualordertime_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[1] &= ~0x00000800u;
}
inline const std::string& Order::manualordertime() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.manualOrderTime)
  return _internal_manualordertime();
}
inline void Order::set_manualordertime(const std::string& value) {
  _internal_set_manualordertime(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.manualOrderTime)
}
inline std::string* Order::mutable_manualordertime() {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.manualOrderTime)
  return _internal_mutable_manualordertime();
}
inline const std::string& Order::_internal_manualordertime() const {
  return manualordertime_.Get();
}
inline void Order::_internal_set_manualordertime(const std::string& value) {
  _has_bits_[1] |= 0x00000800u;
  manualordertime_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Order::set_manualordertime(std::string&& value) {
  _has_bits_[1] |= 0x00000800u;
  manualordertime_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Order.manualOrderTime)
}
inline void Order::set_manualordertime(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[1] |= 0x00000800u;
  manualordertime_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Order.manualOrderTime)
}
inline void Order::set_manualordertime(const char* value,
    size_t size) {
  _has_bits_[1] |= 0x00000800u;
  manualordertime_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Order.manualOrderTime)
}
inline std::string* Order::_internal_mutable_manualordertime() {
  _has_bits_[1] |= 0x00000800u;
  return manualordertime_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Order::release_manualordertime() {
  // @@protoc_insertion_point(field_release:protobuf.Order.manualOrderTime)
  if (!_internal_has_manualordertime()) {
    return nullptr;
  }
  _has_bits_[1] &= ~0x00000800u;
  return manualordertime_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Order::set_allocated_manualordertime(std::string* manualordertime) {
  if (manualordertime != nullptr) {
    _has_bits_[1] |= 0x00000800u;
  } else {
    _has_bits_[1] &= ~0x00000800u;
  }
  manualordertime_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), manualordertime,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Order.manualOrderTime)
}
inline std::string* Order::unsafe_arena_release_manualordertime() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Order.manualOrderTime)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[1] &= ~0x00000800u;
  return manualordertime_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Order::unsafe_arena_set_allocated_manualordertime(
    std::string* manualordertime) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (manualordertime != nullptr) {
    _has_bits_[1] |= 0x00000800u;
  } else {
    _has_bits_[1] &= ~0x00000800u;
  }
  manualordertime_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      manualordertime, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Order.manualOrderTime)
}

// int32 minTradeQty = 127;
inline bool Order::_internal_has_mintradeqty() const {
  bool value = (_has_bits_[3] & 0x80000000u) != 0;
  return value;
}
inline bool Order::has_mintradeqty() const {
  return _internal_has_mintradeqty();
}
inline void Order::clear_mintradeqty() {
  mintradeqty_ = 0;
  _has_bits_[3] &= ~0x80000000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::_internal_mintradeqty() const {
  return mintradeqty_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::mintradeqty() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.minTradeQty)
  return _internal_mintradeqty();
}
inline void Order::_internal_set_mintradeqty(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[3] |= 0x80000000u;
  mintradeqty_ = value;
}
inline void Order::set_mintradeqty(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_mintradeqty(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.minTradeQty)
}

// int32 minCompeteSize = 128;
inline bool Order::_internal_has_mincompetesize() const {
  bool value = (_has_bits_[4] & 0x00000001u) != 0;
  return value;
}
inline bool Order::has_mincompetesize() const {
  return _internal_has_mincompetesize();
}
inline void Order::clear_mincompetesize() {
  mincompetesize_ = 0;
  _has_bits_[4] &= ~0x00000001u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::_internal_mincompetesize() const {
  return mincompetesize_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::mincompetesize() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.minCompeteSize)
  return _internal_mincompetesize();
}
inline void Order::_internal_set_mincompetesize(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[4] |= 0x00000001u;
  mincompetesize_ = value;
}
inline void Order::set_mincompetesize(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_mincompetesize(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.minCompeteSize)
}

// double competeAgainstBestOffset = 129;
inline bool Order::_internal_has_competeagainstbestoffset() const {
  bool value = (_has_bits_[4] & 0x00000002u) != 0;
  return value;
}
inline bool Order::has_competeagainstbestoffset() const {
  return _internal_has_competeagainstbestoffset();
}
inline void Order::clear_competeagainstbestoffset() {
  competeagainstbestoffset_ = 0;
  _has_bits_[4] &= ~0x00000002u;
}
inline double Order::_internal_competeagainstbestoffset() const {
  return competeagainstbestoffset_;
}
inline double Order::competeagainstbestoffset() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.competeAgainstBestOffset)
  return _internal_competeagainstbestoffset();
}
inline void Order::_internal_set_competeagainstbestoffset(double value) {
  _has_bits_[4] |= 0x00000002u;
  competeagainstbestoffset_ = value;
}
inline void Order::set_competeagainstbestoffset(double value) {
  _internal_set_competeagainstbestoffset(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.competeAgainstBestOffset)
}

// double midOffsetAtWhole = 130;
inline bool Order::_internal_has_midoffsetatwhole() const {
  bool value = (_has_bits_[4] & 0x00000004u) != 0;
  return value;
}
inline bool Order::has_midoffsetatwhole() const {
  return _internal_has_midoffsetatwhole();
}
inline void Order::clear_midoffsetatwhole() {
  midoffsetatwhole_ = 0;
  _has_bits_[4] &= ~0x00000004u;
}
inline double Order::_internal_midoffsetatwhole() const {
  return midoffsetatwhole_;
}
inline double Order::midoffsetatwhole() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.midOffsetAtWhole)
  return _internal_midoffsetatwhole();
}
inline void Order::_internal_set_midoffsetatwhole(double value) {
  _has_bits_[4] |= 0x00000004u;
  midoffsetatwhole_ = value;
}
inline void Order::set_midoffsetatwhole(double value) {
  _internal_set_midoffsetatwhole(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.midOffsetAtWhole)
}

// double midOffsetAtHalf = 131;
inline bool Order::_internal_has_midoffsetathalf() const {
  bool value = (_has_bits_[4] & 0x00000008u) != 0;
  return value;
}
inline bool Order::has_midoffsetathalf() const {
  return _internal_has_midoffsetathalf();
}
inline void Order::clear_midoffsetathalf() {
  midoffsetathalf_ = 0;
  _has_bits_[4] &= ~0x00000008u;
}
inline double Order::_internal_midoffsetathalf() const {
  return midoffsetathalf_;
}
inline double Order::midoffsetathalf() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.midOffsetAtHalf)
  return _internal_midoffsetathalf();
}
inline void Order::_internal_set_midoffsetathalf(double value) {
  _has_bits_[4] |= 0x00000008u;
  midoffsetathalf_ = value;
}
inline void Order::set_midoffsetathalf(double value) {
  _internal_set_midoffsetathalf(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.midOffsetAtHalf)
}

// string customerAccount = 132;
inline bool Order::_internal_has_customeraccount() const {
  bool value = (_has_bits_[1] & 0x00001000u) != 0;
  return value;
}
inline bool Order::has_customeraccount() const {
  return _internal_has_customeraccount();
}
inline void Order::clear_customeraccount() {
  customeraccount_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[1] &= ~0x00001000u;
}
inline const std::string& Order::customeraccount() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.customerAccount)
  return _internal_customeraccount();
}
inline void Order::set_customeraccount(const std::string& value) {
  _internal_set_customeraccount(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.customerAccount)
}
inline std::string* Order::mutable_customeraccount() {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.customerAccount)
  return _internal_mutable_customeraccount();
}
inline const std::string& Order::_internal_customeraccount() const {
  return customeraccount_.Get();
}
inline void Order::_internal_set_customeraccount(const std::string& value) {
  _has_bits_[1] |= 0x00001000u;
  customeraccount_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Order::set_customeraccount(std::string&& value) {
  _has_bits_[1] |= 0x00001000u;
  customeraccount_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Order.customerAccount)
}
inline void Order::set_customeraccount(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[1] |= 0x00001000u;
  customeraccount_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Order.customerAccount)
}
inline void Order::set_customeraccount(const char* value,
    size_t size) {
  _has_bits_[1] |= 0x00001000u;
  customeraccount_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Order.customerAccount)
}
inline std::string* Order::_internal_mutable_customeraccount() {
  _has_bits_[1] |= 0x00001000u;
  return customeraccount_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Order::release_customeraccount() {
  // @@protoc_insertion_point(field_release:protobuf.Order.customerAccount)
  if (!_internal_has_customeraccount()) {
    return nullptr;
  }
  _has_bits_[1] &= ~0x00001000u;
  return customeraccount_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Order::set_allocated_customeraccount(std::string* customeraccount) {
  if (customeraccount != nullptr) {
    _has_bits_[1] |= 0x00001000u;
  } else {
    _has_bits_[1] &= ~0x00001000u;
  }
  customeraccount_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), customeraccount,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Order.customerAccount)
}
inline std::string* Order::unsafe_arena_release_customeraccount() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Order.customerAccount)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[1] &= ~0x00001000u;
  return customeraccount_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Order::unsafe_arena_set_allocated_customeraccount(
    std::string* customeraccount) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (customeraccount != nullptr) {
    _has_bits_[1] |= 0x00001000u;
  } else {
    _has_bits_[1] &= ~0x00001000u;
  }
  customeraccount_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      customeraccount, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Order.customerAccount)
}

// bool professionalCustomer = 133;
inline bool Order::_internal_has_professionalcustomer() const {
  bool value = (_has_bits_[3] & 0x20000000u) != 0;
  return value;
}
inline bool Order::has_professionalcustomer() const {
  return _internal_has_professionalcustomer();
}
inline void Order::clear_professionalcustomer() {
  professionalcustomer_ = false;
  _has_bits_[3] &= ~0x20000000u;
}
inline bool Order::_internal_professionalcustomer() const {
  return professionalcustomer_;
}
inline bool Order::professionalcustomer() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.professionalCustomer)
  return _internal_professionalcustomer();
}
inline void Order::_internal_set_professionalcustomer(bool value) {
  _has_bits_[3] |= 0x20000000u;
  professionalcustomer_ = value;
}
inline void Order::set_professionalcustomer(bool value) {
  _internal_set_professionalcustomer(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.professionalCustomer)
}

// string bondAccruedInterest = 134;
inline bool Order::_internal_has_bondaccruedinterest() const {
  bool value = (_has_bits_[1] & 0x00002000u) != 0;
  return value;
}
inline bool Order::has_bondaccruedinterest() const {
  return _internal_has_bondaccruedinterest();
}
inline void Order::clear_bondaccruedinterest() {
  bondaccruedinterest_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[1] &= ~0x00002000u;
}
inline const std::string& Order::bondaccruedinterest() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.bondAccruedInterest)
  return _internal_bondaccruedinterest();
}
inline void Order::set_bondaccruedinterest(const std::string& value) {
  _internal_set_bondaccruedinterest(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.bondAccruedInterest)
}
inline std::string* Order::mutable_bondaccruedinterest() {
  // @@protoc_insertion_point(field_mutable:protobuf.Order.bondAccruedInterest)
  return _internal_mutable_bondaccruedinterest();
}
inline const std::string& Order::_internal_bondaccruedinterest() const {
  return bondaccruedinterest_.Get();
}
inline void Order::_internal_set_bondaccruedinterest(const std::string& value) {
  _has_bits_[1] |= 0x00002000u;
  bondaccruedinterest_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Order::set_bondaccruedinterest(std::string&& value) {
  _has_bits_[1] |= 0x00002000u;
  bondaccruedinterest_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Order.bondAccruedInterest)
}
inline void Order::set_bondaccruedinterest(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[1] |= 0x00002000u;
  bondaccruedinterest_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Order.bondAccruedInterest)
}
inline void Order::set_bondaccruedinterest(const char* value,
    size_t size) {
  _has_bits_[1] |= 0x00002000u;
  bondaccruedinterest_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Order.bondAccruedInterest)
}
inline std::string* Order::_internal_mutable_bondaccruedinterest() {
  _has_bits_[1] |= 0x00002000u;
  return bondaccruedinterest_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Order::release_bondaccruedinterest() {
  // @@protoc_insertion_point(field_release:protobuf.Order.bondAccruedInterest)
  if (!_internal_has_bondaccruedinterest()) {
    return nullptr;
  }
  _has_bits_[1] &= ~0x00002000u;
  return bondaccruedinterest_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Order::set_allocated_bondaccruedinterest(std::string* bondaccruedinterest) {
  if (bondaccruedinterest != nullptr) {
    _has_bits_[1] |= 0x00002000u;
  } else {
    _has_bits_[1] &= ~0x00002000u;
  }
  bondaccruedinterest_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), bondaccruedinterest,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Order.bondAccruedInterest)
}
inline std::string* Order::unsafe_arena_release_bondaccruedinterest() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Order.bondAccruedInterest)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[1] &= ~0x00002000u;
  return bondaccruedinterest_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Order::unsafe_arena_set_allocated_bondaccruedinterest(
    std::string* bondaccruedinterest) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (bondaccruedinterest != nullptr) {
    _has_bits_[1] |= 0x00002000u;
  } else {
    _has_bits_[1] &= ~0x00002000u;
  }
  bondaccruedinterest_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      bondaccruedinterest, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Order.bondAccruedInterest)
}

// bool includeOvernight = 135;
inline bool Order::_internal_has_includeovernight() const {
  bool value = (_has_bits_[3] & 0x40000000u) != 0;
  return value;
}
inline bool Order::has_includeovernight() const {
  return _internal_has_includeovernight();
}
inline void Order::clear_includeovernight() {
  includeovernight_ = false;
  _has_bits_[3] &= ~0x40000000u;
}
inline bool Order::_internal_includeovernight() const {
  return includeovernight_;
}
inline bool Order::includeovernight() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.includeOvernight)
  return _internal_includeovernight();
}
inline void Order::_internal_set_includeovernight(bool value) {
  _has_bits_[3] |= 0x40000000u;
  includeovernight_ = value;
}
inline void Order::set_includeovernight(bool value) {
  _internal_set_includeovernight(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.includeOvernight)
}

// int32 manualOrderIndicator = 136;
inline bool Order::_internal_has_manualorderindicator() const {
  bool value = (_has_bits_[4] & 0x00000010u) != 0;
  return value;
}
inline bool Order::has_manualorderindicator() const {
  return _internal_has_manualorderindicator();
}
inline void Order::clear_manualorderindicator() {
  manualorderindicator_ = 0;
  _has_bits_[4] &= ~0x00000010u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::_internal_manualorderindicator() const {
  return manualorderindicator_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Order::manualorderindicator() const {
  // @@protoc_insertion_point(field_get:protobuf.Order.manualOrderIndicator)
  return _internal_manualorderindicator();
}
inline void Order::_internal_set_manualorderindicator(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[4] |= 0x00000010u;
  manualorderindicator_ = value;
}
inline void Order::set_manualorderindicator(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_manualorderindicator(value);
  // @@protoc_insertion_point(field_set:protobuf.Order.manualOrderIndicator)
}

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

#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_Order_2eproto
