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

#ifndef GOOGLE_PROTOBUF_INCLUDED_Contract_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_Contract_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3012000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3012004 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/inlined_string_field.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/unknown_field_set.h>
#include "ComboLeg.pb.h"
#include "DeltaNeutralContract.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_Contract_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

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

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

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

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

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

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

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

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

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

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

  public:

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

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

  enum : int {
    kComboLegsFieldNumber = 20,
    kSymbolFieldNumber = 2,
    kSecTypeFieldNumber = 3,
    kLastTradeDateOrContractMonthFieldNumber = 4,
    kRightFieldNumber = 6,
    kExchangeFieldNumber = 8,
    kPrimaryExchFieldNumber = 9,
    kCurrencyFieldNumber = 10,
    kLocalSymbolFieldNumber = 11,
    kTradingClassFieldNumber = 12,
    kSecIdTypeFieldNumber = 13,
    kSecIdFieldNumber = 14,
    kDescriptionFieldNumber = 15,
    kIssuerIdFieldNumber = 16,
    kComboLegsDescripFieldNumber = 19,
    kDeltaNeutralContractFieldNumber = 17,
    kStrikeFieldNumber = 5,
    kMultiplierFieldNumber = 7,
    kConIdFieldNumber = 1,
    kIncludeExpiredFieldNumber = 18,
  };
  // repeated .protobuf.ComboLeg comboLegs = 20;
  int combolegs_size() const;
  private:
  int _internal_combolegs_size() const;
  public:
  void clear_combolegs();
  ::protobuf::ComboLeg* mutable_combolegs(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::protobuf::ComboLeg >*
      mutable_combolegs();
  private:
  const ::protobuf::ComboLeg& _internal_combolegs(int index) const;
  ::protobuf::ComboLeg* _internal_add_combolegs();
  public:
  const ::protobuf::ComboLeg& combolegs(int index) const;
  ::protobuf::ComboLeg* add_combolegs();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::protobuf::ComboLeg >&
      combolegs() const;

  // string symbol = 2;
  bool has_symbol() const;
  private:
  bool _internal_has_symbol() const;
  public:
  void clear_symbol();
  const std::string& symbol() const;
  void set_symbol(const std::string& value);
  void set_symbol(std::string&& value);
  void set_symbol(const char* value);
  void set_symbol(const char* value, size_t size);
  std::string* mutable_symbol();
  std::string* release_symbol();
  void set_allocated_symbol(std::string* symbol);
  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_symbol();
  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_symbol(
      std::string* symbol);
  private:
  const std::string& _internal_symbol() const;
  void _internal_set_symbol(const std::string& value);
  std::string* _internal_mutable_symbol();
  public:

  // string secType = 3;
  bool has_sectype() const;
  private:
  bool _internal_has_sectype() const;
  public:
  void clear_sectype();
  const std::string& sectype() const;
  void set_sectype(const std::string& value);
  void set_sectype(std::string&& value);
  void set_sectype(const char* value);
  void set_sectype(const char* value, size_t size);
  std::string* mutable_sectype();
  std::string* release_sectype();
  void set_allocated_sectype(std::string* sectype);
  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_sectype();
  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_sectype(
      std::string* sectype);
  private:
  const std::string& _internal_sectype() const;
  void _internal_set_sectype(const std::string& value);
  std::string* _internal_mutable_sectype();
  public:

  // string lastTradeDateOrContractMonth = 4;
  bool has_lasttradedateorcontractmonth() const;
  private:
  bool _internal_has_lasttradedateorcontractmonth() const;
  public:
  void clear_lasttradedateorcontractmonth();
  const std::string& lasttradedateorcontractmonth() const;
  void set_lasttradedateorcontractmonth(const std::string& value);
  void set_lasttradedateorcontractmonth(std::string&& value);
  void set_lasttradedateorcontractmonth(const char* value);
  void set_lasttradedateorcontractmonth(const char* value, size_t size);
  std::string* mutable_lasttradedateorcontractmonth();
  std::string* release_lasttradedateorcontractmonth();
  void set_allocated_lasttradedateorcontractmonth(std::string* lasttradedateorcontractmonth);
  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_lasttradedateorcontractmonth();
  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_lasttradedateorcontractmonth(
      std::string* lasttradedateorcontractmonth);
  private:
  const std::string& _internal_lasttradedateorcontractmonth() const;
  void _internal_set_lasttradedateorcontractmonth(const std::string& value);
  std::string* _internal_mutable_lasttradedateorcontractmonth();
  public:

  // string right = 6;
  bool has_right() const;
  private:
  bool _internal_has_right() const;
  public:
  void clear_right();
  const std::string& right() const;
  void set_right(const std::string& value);
  void set_right(std::string&& value);
  void set_right(const char* value);
  void set_right(const char* value, size_t size);
  std::string* mutable_right();
  std::string* release_right();
  void set_allocated_right(std::string* right);
  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_right();
  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_right(
      std::string* right);
  private:
  const std::string& _internal_right() const;
  void _internal_set_right(const std::string& value);
  std::string* _internal_mutable_right();
  public:

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

  // string primaryExch = 9;
  bool has_primaryexch() const;
  private:
  bool _internal_has_primaryexch() const;
  public:
  void clear_primaryexch();
  const std::string& primaryexch() const;
  void set_primaryexch(const std::string& value);
  void set_primaryexch(std::string&& value);
  void set_primaryexch(const char* value);
  void set_primaryexch(const char* value, size_t size);
  std::string* mutable_primaryexch();
  std::string* release_primaryexch();
  void set_allocated_primaryexch(std::string* primaryexch);
  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_primaryexch();
  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_primaryexch(
      std::string* primaryexch);
  private:
  const std::string& _internal_primaryexch() const;
  void _internal_set_primaryexch(const std::string& value);
  std::string* _internal_mutable_primaryexch();
  public:

  // string currency = 10;
  bool has_currency() const;
  private:
  bool _internal_has_currency() const;
  public:
  void clear_currency();
  const std::string& currency() const;
  void set_currency(const std::string& value);
  void set_currency(std::string&& value);
  void set_currency(const char* value);
  void set_currency(const char* value, size_t size);
  std::string* mutable_currency();
  std::string* release_currency();
  void set_allocated_currency(std::string* currency);
  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_currency();
  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_currency(
      std::string* currency);
  private:
  const std::string& _internal_currency() const;
  void _internal_set_currency(const std::string& value);
  std::string* _internal_mutable_currency();
  public:

  // string localSymbol = 11;
  bool has_localsymbol() const;
  private:
  bool _internal_has_localsymbol() const;
  public:
  void clear_localsymbol();
  const std::string& localsymbol() const;
  void set_localsymbol(const std::string& value);
  void set_localsymbol(std::string&& value);
  void set_localsymbol(const char* value);
  void set_localsymbol(const char* value, size_t size);
  std::string* mutable_localsymbol();
  std::string* release_localsymbol();
  void set_allocated_localsymbol(std::string* localsymbol);
  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_localsymbol();
  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_localsymbol(
      std::string* localsymbol);
  private:
  const std::string& _internal_localsymbol() const;
  void _internal_set_localsymbol(const std::string& value);
  std::string* _internal_mutable_localsymbol();
  public:

  // string tradingClass = 12;
  bool has_tradingclass() const;
  private:
  bool _internal_has_tradingclass() const;
  public:
  void clear_tradingclass();
  const std::string& tradingclass() const;
  void set_tradingclass(const std::string& value);
  void set_tradingclass(std::string&& value);
  void set_tradingclass(const char* value);
  void set_tradingclass(const char* value, size_t size);
  std::string* mutable_tradingclass();
  std::string* release_tradingclass();
  void set_allocated_tradingclass(std::string* tradingclass);
  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_tradingclass();
  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_tradingclass(
      std::string* tradingclass);
  private:
  const std::string& _internal_tradingclass() const;
  void _internal_set_tradingclass(const std::string& value);
  std::string* _internal_mutable_tradingclass();
  public:

  // string secIdType = 13;
  bool has_secidtype() const;
  private:
  bool _internal_has_secidtype() const;
  public:
  void clear_secidtype();
  const std::string& secidtype() const;
  void set_secidtype(const std::string& value);
  void set_secidtype(std::string&& value);
  void set_secidtype(const char* value);
  void set_secidtype(const char* value, size_t size);
  std::string* mutable_secidtype();
  std::string* release_secidtype();
  void set_allocated_secidtype(std::string* secidtype);
  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_secidtype();
  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_secidtype(
      std::string* secidtype);
  private:
  const std::string& _internal_secidtype() const;
  void _internal_set_secidtype(const std::string& value);
  std::string* _internal_mutable_secidtype();
  public:

  // string secId = 14;
  bool has_secid() const;
  private:
  bool _internal_has_secid() const;
  public:
  void clear_secid();
  const std::string& secid() const;
  void set_secid(const std::string& value);
  void set_secid(std::string&& value);
  void set_secid(const char* value);
  void set_secid(const char* value, size_t size);
  std::string* mutable_secid();
  std::string* release_secid();
  void set_allocated_secid(std::string* secid);
  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_secid();
  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_secid(
      std::string* secid);
  private:
  const std::string& _internal_secid() const;
  void _internal_set_secid(const std::string& value);
  std::string* _internal_mutable_secid();
  public:

  // string description = 15;
  bool has_description() const;
  private:
  bool _internal_has_description() const;
  public:
  void clear_description();
  const std::string& description() const;
  void set_description(const std::string& value);
  void set_description(std::string&& value);
  void set_description(const char* value);
  void set_description(const char* value, size_t size);
  std::string* mutable_description();
  std::string* release_description();
  void set_allocated_description(std::string* description);
  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_description();
  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_description(
      std::string* description);
  private:
  const std::string& _internal_description() const;
  void _internal_set_description(const std::string& value);
  std::string* _internal_mutable_description();
  public:

  // string issuerId = 16;
  bool has_issuerid() const;
  private:
  bool _internal_has_issuerid() const;
  public:
  void clear_issuerid();
  const std::string& issuerid() const;
  void set_issuerid(const std::string& value);
  void set_issuerid(std::string&& value);
  void set_issuerid(const char* value);
  void set_issuerid(const char* value, size_t size);
  std::string* mutable_issuerid();
  std::string* release_issuerid();
  void set_allocated_issuerid(std::string* issuerid);
  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_issuerid();
  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_issuerid(
      std::string* issuerid);
  private:
  const std::string& _internal_issuerid() const;
  void _internal_set_issuerid(const std::string& value);
  std::string* _internal_mutable_issuerid();
  public:

  // string comboLegsDescrip = 19;
  bool has_combolegsdescrip() const;
  private:
  bool _internal_has_combolegsdescrip() const;
  public:
  void clear_combolegsdescrip();
  const std::string& combolegsdescrip() const;
  void set_combolegsdescrip(const std::string& value);
  void set_combolegsdescrip(std::string&& value);
  void set_combolegsdescrip(const char* value);
  void set_combolegsdescrip(const char* value, size_t size);
  std::string* mutable_combolegsdescrip();
  std::string* release_combolegsdescrip();
  void set_allocated_combolegsdescrip(std::string* combolegsdescrip);
  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_combolegsdescrip();
  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_combolegsdescrip(
      std::string* combolegsdescrip);
  private:
  const std::string& _internal_combolegsdescrip() const;
  void _internal_set_combolegsdescrip(const std::string& value);
  std::string* _internal_mutable_combolegsdescrip();
  public:

  // .protobuf.DeltaNeutralContract deltaNeutralContract = 17;
  bool has_deltaneutralcontract() const;
  private:
  bool _internal_has_deltaneutralcontract() const;
  public:
  void clear_deltaneutralcontract();
  const ::protobuf::DeltaNeutralContract& deltaneutralcontract() const;
  ::protobuf::DeltaNeutralContract* release_deltaneutralcontract();
  ::protobuf::DeltaNeutralContract* mutable_deltaneutralcontract();
  void set_allocated_deltaneutralcontract(::protobuf::DeltaNeutralContract* deltaneutralcontract);
  private:
  const ::protobuf::DeltaNeutralContract& _internal_deltaneutralcontract() const;
  ::protobuf::DeltaNeutralContract* _internal_mutable_deltaneutralcontract();
  public:
  void unsafe_arena_set_allocated_deltaneutralcontract(
      ::protobuf::DeltaNeutralContract* deltaneutralcontract);
  ::protobuf::DeltaNeutralContract* unsafe_arena_release_deltaneutralcontract();

  // double strike = 5;
  bool has_strike() const;
  private:
  bool _internal_has_strike() const;
  public:
  void clear_strike();
  double strike() const;
  void set_strike(double value);
  private:
  double _internal_strike() const;
  void _internal_set_strike(double value);
  public:

  // double multiplier = 7;
  bool has_multiplier() const;
  private:
  bool _internal_has_multiplier() const;
  public:
  void clear_multiplier();
  double multiplier() const;
  void set_multiplier(double value);
  private:
  double _internal_multiplier() const;
  void _internal_set_multiplier(double value);
  public:

  // int32 conId = 1;
  bool has_conid() const;
  private:
  bool _internal_has_conid() const;
  public:
  void clear_conid();
  ::PROTOBUF_NAMESPACE_ID::int32 conid() const;
  void set_conid(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_conid() const;
  void _internal_set_conid(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // bool includeExpired = 18;
  bool has_includeexpired() const;
  private:
  bool _internal_has_includeexpired() const;
  public:
  void clear_includeexpired();
  bool includeexpired() const;
  void set_includeexpired(bool value);
  private:
  bool _internal_includeexpired() const;
  void _internal_set_includeexpired(bool value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::protobuf::ComboLeg > combolegs_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr symbol_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sectype_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr lasttradedateorcontractmonth_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr right_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr exchange_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr primaryexch_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr currency_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr localsymbol_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tradingclass_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr secidtype_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr secid_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr issuerid_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr combolegsdescrip_;
  ::protobuf::DeltaNeutralContract* deltaneutralcontract_;
  double strike_;
  double multiplier_;
  ::PROTOBUF_NAMESPACE_ID::int32 conid_;
  bool includeexpired_;
  friend struct ::TableStruct_Contract_2eproto;
};
// ===================================================================


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

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

// int32 conId = 1;
inline bool Contract::_internal_has_conid() const {
  bool value = (_has_bits_[0] & 0x00020000u) != 0;
  return value;
}
inline bool Contract::has_conid() const {
  return _internal_has_conid();
}
inline void Contract::clear_conid() {
  conid_ = 0;
  _has_bits_[0] &= ~0x00020000u;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Contract::_internal_conid() const {
  return conid_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 Contract::conid() const {
  // @@protoc_insertion_point(field_get:protobuf.Contract.conId)
  return _internal_conid();
}
inline void Contract::_internal_set_conid(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _has_bits_[0] |= 0x00020000u;
  conid_ = value;
}
inline void Contract::set_conid(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_conid(value);
  // @@protoc_insertion_point(field_set:protobuf.Contract.conId)
}

// string symbol = 2;
inline bool Contract::_internal_has_symbol() const {
  bool value = (_has_bits_[0] & 0x00000001u) != 0;
  return value;
}
inline bool Contract::has_symbol() const {
  return _internal_has_symbol();
}
inline void Contract::clear_symbol() {
  symbol_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000001u;
}
inline const std::string& Contract::symbol() const {
  // @@protoc_insertion_point(field_get:protobuf.Contract.symbol)
  return _internal_symbol();
}
inline void Contract::set_symbol(const std::string& value) {
  _internal_set_symbol(value);
  // @@protoc_insertion_point(field_set:protobuf.Contract.symbol)
}
inline std::string* Contract::mutable_symbol() {
  // @@protoc_insertion_point(field_mutable:protobuf.Contract.symbol)
  return _internal_mutable_symbol();
}
inline const std::string& Contract::_internal_symbol() const {
  return symbol_.Get();
}
inline void Contract::_internal_set_symbol(const std::string& value) {
  _has_bits_[0] |= 0x00000001u;
  symbol_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Contract::set_symbol(std::string&& value) {
  _has_bits_[0] |= 0x00000001u;
  symbol_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Contract.symbol)
}
inline void Contract::set_symbol(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000001u;
  symbol_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Contract.symbol)
}
inline void Contract::set_symbol(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000001u;
  symbol_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Contract.symbol)
}
inline std::string* Contract::_internal_mutable_symbol() {
  _has_bits_[0] |= 0x00000001u;
  return symbol_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Contract::release_symbol() {
  // @@protoc_insertion_point(field_release:protobuf.Contract.symbol)
  if (!_internal_has_symbol()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000001u;
  return symbol_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Contract::set_allocated_symbol(std::string* symbol) {
  if (symbol != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  symbol_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), symbol,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Contract.symbol)
}
inline std::string* Contract::unsafe_arena_release_symbol() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Contract.symbol)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00000001u;
  return symbol_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Contract::unsafe_arena_set_allocated_symbol(
    std::string* symbol) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (symbol != nullptr) {
    _has_bits_[0] |= 0x00000001u;
  } else {
    _has_bits_[0] &= ~0x00000001u;
  }
  symbol_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      symbol, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Contract.symbol)
}

// string secType = 3;
inline bool Contract::_internal_has_sectype() const {
  bool value = (_has_bits_[0] & 0x00000002u) != 0;
  return value;
}
inline bool Contract::has_sectype() const {
  return _internal_has_sectype();
}
inline void Contract::clear_sectype() {
  sectype_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000002u;
}
inline const std::string& Contract::sectype() const {
  // @@protoc_insertion_point(field_get:protobuf.Contract.secType)
  return _internal_sectype();
}
inline void Contract::set_sectype(const std::string& value) {
  _internal_set_sectype(value);
  // @@protoc_insertion_point(field_set:protobuf.Contract.secType)
}
inline std::string* Contract::mutable_sectype() {
  // @@protoc_insertion_point(field_mutable:protobuf.Contract.secType)
  return _internal_mutable_sectype();
}
inline const std::string& Contract::_internal_sectype() const {
  return sectype_.Get();
}
inline void Contract::_internal_set_sectype(const std::string& value) {
  _has_bits_[0] |= 0x00000002u;
  sectype_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Contract::set_sectype(std::string&& value) {
  _has_bits_[0] |= 0x00000002u;
  sectype_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Contract.secType)
}
inline void Contract::set_sectype(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000002u;
  sectype_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Contract.secType)
}
inline void Contract::set_sectype(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000002u;
  sectype_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Contract.secType)
}
inline std::string* Contract::_internal_mutable_sectype() {
  _has_bits_[0] |= 0x00000002u;
  return sectype_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Contract::release_sectype() {
  // @@protoc_insertion_point(field_release:protobuf.Contract.secType)
  if (!_internal_has_sectype()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000002u;
  return sectype_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Contract::set_allocated_sectype(std::string* sectype) {
  if (sectype != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  sectype_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), sectype,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Contract.secType)
}
inline std::string* Contract::unsafe_arena_release_sectype() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Contract.secType)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00000002u;
  return sectype_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Contract::unsafe_arena_set_allocated_sectype(
    std::string* sectype) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (sectype != nullptr) {
    _has_bits_[0] |= 0x00000002u;
  } else {
    _has_bits_[0] &= ~0x00000002u;
  }
  sectype_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      sectype, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Contract.secType)
}

// string lastTradeDateOrContractMonth = 4;
inline bool Contract::_internal_has_lasttradedateorcontractmonth() const {
  bool value = (_has_bits_[0] & 0x00000004u) != 0;
  return value;
}
inline bool Contract::has_lasttradedateorcontractmonth() const {
  return _internal_has_lasttradedateorcontractmonth();
}
inline void Contract::clear_lasttradedateorcontractmonth() {
  lasttradedateorcontractmonth_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000004u;
}
inline const std::string& Contract::lasttradedateorcontractmonth() const {
  // @@protoc_insertion_point(field_get:protobuf.Contract.lastTradeDateOrContractMonth)
  return _internal_lasttradedateorcontractmonth();
}
inline void Contract::set_lasttradedateorcontractmonth(const std::string& value) {
  _internal_set_lasttradedateorcontractmonth(value);
  // @@protoc_insertion_point(field_set:protobuf.Contract.lastTradeDateOrContractMonth)
}
inline std::string* Contract::mutable_lasttradedateorcontractmonth() {
  // @@protoc_insertion_point(field_mutable:protobuf.Contract.lastTradeDateOrContractMonth)
  return _internal_mutable_lasttradedateorcontractmonth();
}
inline const std::string& Contract::_internal_lasttradedateorcontractmonth() const {
  return lasttradedateorcontractmonth_.Get();
}
inline void Contract::_internal_set_lasttradedateorcontractmonth(const std::string& value) {
  _has_bits_[0] |= 0x00000004u;
  lasttradedateorcontractmonth_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Contract::set_lasttradedateorcontractmonth(std::string&& value) {
  _has_bits_[0] |= 0x00000004u;
  lasttradedateorcontractmonth_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Contract.lastTradeDateOrContractMonth)
}
inline void Contract::set_lasttradedateorcontractmonth(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000004u;
  lasttradedateorcontractmonth_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Contract.lastTradeDateOrContractMonth)
}
inline void Contract::set_lasttradedateorcontractmonth(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000004u;
  lasttradedateorcontractmonth_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Contract.lastTradeDateOrContractMonth)
}
inline std::string* Contract::_internal_mutable_lasttradedateorcontractmonth() {
  _has_bits_[0] |= 0x00000004u;
  return lasttradedateorcontractmonth_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Contract::release_lasttradedateorcontractmonth() {
  // @@protoc_insertion_point(field_release:protobuf.Contract.lastTradeDateOrContractMonth)
  if (!_internal_has_lasttradedateorcontractmonth()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000004u;
  return lasttradedateorcontractmonth_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Contract::set_allocated_lasttradedateorcontractmonth(std::string* lasttradedateorcontractmonth) {
  if (lasttradedateorcontractmonth != nullptr) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  lasttradedateorcontractmonth_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), lasttradedateorcontractmonth,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Contract.lastTradeDateOrContractMonth)
}
inline std::string* Contract::unsafe_arena_release_lasttradedateorcontractmonth() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Contract.lastTradeDateOrContractMonth)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00000004u;
  return lasttradedateorcontractmonth_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Contract::unsafe_arena_set_allocated_lasttradedateorcontractmonth(
    std::string* lasttradedateorcontractmonth) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (lasttradedateorcontractmonth != nullptr) {
    _has_bits_[0] |= 0x00000004u;
  } else {
    _has_bits_[0] &= ~0x00000004u;
  }
  lasttradedateorcontractmonth_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      lasttradedateorcontractmonth, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Contract.lastTradeDateOrContractMonth)
}

// double strike = 5;
inline bool Contract::_internal_has_strike() const {
  bool value = (_has_bits_[0] & 0x00008000u) != 0;
  return value;
}
inline bool Contract::has_strike() const {
  return _internal_has_strike();
}
inline void Contract::clear_strike() {
  strike_ = 0;
  _has_bits_[0] &= ~0x00008000u;
}
inline double Contract::_internal_strike() const {
  return strike_;
}
inline double Contract::strike() const {
  // @@protoc_insertion_point(field_get:protobuf.Contract.strike)
  return _internal_strike();
}
inline void Contract::_internal_set_strike(double value) {
  _has_bits_[0] |= 0x00008000u;
  strike_ = value;
}
inline void Contract::set_strike(double value) {
  _internal_set_strike(value);
  // @@protoc_insertion_point(field_set:protobuf.Contract.strike)
}

// string right = 6;
inline bool Contract::_internal_has_right() const {
  bool value = (_has_bits_[0] & 0x00000008u) != 0;
  return value;
}
inline bool Contract::has_right() const {
  return _internal_has_right();
}
inline void Contract::clear_right() {
  right_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000008u;
}
inline const std::string& Contract::right() const {
  // @@protoc_insertion_point(field_get:protobuf.Contract.right)
  return _internal_right();
}
inline void Contract::set_right(const std::string& value) {
  _internal_set_right(value);
  // @@protoc_insertion_point(field_set:protobuf.Contract.right)
}
inline std::string* Contract::mutable_right() {
  // @@protoc_insertion_point(field_mutable:protobuf.Contract.right)
  return _internal_mutable_right();
}
inline const std::string& Contract::_internal_right() const {
  return right_.Get();
}
inline void Contract::_internal_set_right(const std::string& value) {
  _has_bits_[0] |= 0x00000008u;
  right_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Contract::set_right(std::string&& value) {
  _has_bits_[0] |= 0x00000008u;
  right_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Contract.right)
}
inline void Contract::set_right(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000008u;
  right_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Contract.right)
}
inline void Contract::set_right(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000008u;
  right_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Contract.right)
}
inline std::string* Contract::_internal_mutable_right() {
  _has_bits_[0] |= 0x00000008u;
  return right_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Contract::release_right() {
  // @@protoc_insertion_point(field_release:protobuf.Contract.right)
  if (!_internal_has_right()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000008u;
  return right_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Contract::set_allocated_right(std::string* right) {
  if (right != nullptr) {
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  right_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), right,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Contract.right)
}
inline std::string* Contract::unsafe_arena_release_right() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Contract.right)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00000008u;
  return right_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Contract::unsafe_arena_set_allocated_right(
    std::string* right) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (right != nullptr) {
    _has_bits_[0] |= 0x00000008u;
  } else {
    _has_bits_[0] &= ~0x00000008u;
  }
  right_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      right, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Contract.right)
}

// double multiplier = 7;
inline bool Contract::_internal_has_multiplier() const {
  bool value = (_has_bits_[0] & 0x00010000u) != 0;
  return value;
}
inline bool Contract::has_multiplier() const {
  return _internal_has_multiplier();
}
inline void Contract::clear_multiplier() {
  multiplier_ = 0;
  _has_bits_[0] &= ~0x00010000u;
}
inline double Contract::_internal_multiplier() const {
  return multiplier_;
}
inline double Contract::multiplier() const {
  // @@protoc_insertion_point(field_get:protobuf.Contract.multiplier)
  return _internal_multiplier();
}
inline void Contract::_internal_set_multiplier(double value) {
  _has_bits_[0] |= 0x00010000u;
  multiplier_ = value;
}
inline void Contract::set_multiplier(double value) {
  _internal_set_multiplier(value);
  // @@protoc_insertion_point(field_set:protobuf.Contract.multiplier)
}

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

// string primaryExch = 9;
inline bool Contract::_internal_has_primaryexch() const {
  bool value = (_has_bits_[0] & 0x00000020u) != 0;
  return value;
}
inline bool Contract::has_primaryexch() const {
  return _internal_has_primaryexch();
}
inline void Contract::clear_primaryexch() {
  primaryexch_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000020u;
}
inline const std::string& Contract::primaryexch() const {
  // @@protoc_insertion_point(field_get:protobuf.Contract.primaryExch)
  return _internal_primaryexch();
}
inline void Contract::set_primaryexch(const std::string& value) {
  _internal_set_primaryexch(value);
  // @@protoc_insertion_point(field_set:protobuf.Contract.primaryExch)
}
inline std::string* Contract::mutable_primaryexch() {
  // @@protoc_insertion_point(field_mutable:protobuf.Contract.primaryExch)
  return _internal_mutable_primaryexch();
}
inline const std::string& Contract::_internal_primaryexch() const {
  return primaryexch_.Get();
}
inline void Contract::_internal_set_primaryexch(const std::string& value) {
  _has_bits_[0] |= 0x00000020u;
  primaryexch_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Contract::set_primaryexch(std::string&& value) {
  _has_bits_[0] |= 0x00000020u;
  primaryexch_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Contract.primaryExch)
}
inline void Contract::set_primaryexch(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000020u;
  primaryexch_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Contract.primaryExch)
}
inline void Contract::set_primaryexch(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000020u;
  primaryexch_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Contract.primaryExch)
}
inline std::string* Contract::_internal_mutable_primaryexch() {
  _has_bits_[0] |= 0x00000020u;
  return primaryexch_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Contract::release_primaryexch() {
  // @@protoc_insertion_point(field_release:protobuf.Contract.primaryExch)
  if (!_internal_has_primaryexch()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000020u;
  return primaryexch_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Contract::set_allocated_primaryexch(std::string* primaryexch) {
  if (primaryexch != nullptr) {
    _has_bits_[0] |= 0x00000020u;
  } else {
    _has_bits_[0] &= ~0x00000020u;
  }
  primaryexch_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), primaryexch,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Contract.primaryExch)
}
inline std::string* Contract::unsafe_arena_release_primaryexch() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Contract.primaryExch)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00000020u;
  return primaryexch_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Contract::unsafe_arena_set_allocated_primaryexch(
    std::string* primaryexch) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (primaryexch != nullptr) {
    _has_bits_[0] |= 0x00000020u;
  } else {
    _has_bits_[0] &= ~0x00000020u;
  }
  primaryexch_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      primaryexch, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Contract.primaryExch)
}

// string currency = 10;
inline bool Contract::_internal_has_currency() const {
  bool value = (_has_bits_[0] & 0x00000040u) != 0;
  return value;
}
inline bool Contract::has_currency() const {
  return _internal_has_currency();
}
inline void Contract::clear_currency() {
  currency_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000040u;
}
inline const std::string& Contract::currency() const {
  // @@protoc_insertion_point(field_get:protobuf.Contract.currency)
  return _internal_currency();
}
inline void Contract::set_currency(const std::string& value) {
  _internal_set_currency(value);
  // @@protoc_insertion_point(field_set:protobuf.Contract.currency)
}
inline std::string* Contract::mutable_currency() {
  // @@protoc_insertion_point(field_mutable:protobuf.Contract.currency)
  return _internal_mutable_currency();
}
inline const std::string& Contract::_internal_currency() const {
  return currency_.Get();
}
inline void Contract::_internal_set_currency(const std::string& value) {
  _has_bits_[0] |= 0x00000040u;
  currency_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Contract::set_currency(std::string&& value) {
  _has_bits_[0] |= 0x00000040u;
  currency_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Contract.currency)
}
inline void Contract::set_currency(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000040u;
  currency_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Contract.currency)
}
inline void Contract::set_currency(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000040u;
  currency_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Contract.currency)
}
inline std::string* Contract::_internal_mutable_currency() {
  _has_bits_[0] |= 0x00000040u;
  return currency_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Contract::release_currency() {
  // @@protoc_insertion_point(field_release:protobuf.Contract.currency)
  if (!_internal_has_currency()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000040u;
  return currency_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Contract::set_allocated_currency(std::string* currency) {
  if (currency != nullptr) {
    _has_bits_[0] |= 0x00000040u;
  } else {
    _has_bits_[0] &= ~0x00000040u;
  }
  currency_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), currency,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Contract.currency)
}
inline std::string* Contract::unsafe_arena_release_currency() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Contract.currency)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00000040u;
  return currency_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Contract::unsafe_arena_set_allocated_currency(
    std::string* currency) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (currency != nullptr) {
    _has_bits_[0] |= 0x00000040u;
  } else {
    _has_bits_[0] &= ~0x00000040u;
  }
  currency_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      currency, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Contract.currency)
}

// string localSymbol = 11;
inline bool Contract::_internal_has_localsymbol() const {
  bool value = (_has_bits_[0] & 0x00000080u) != 0;
  return value;
}
inline bool Contract::has_localsymbol() const {
  return _internal_has_localsymbol();
}
inline void Contract::clear_localsymbol() {
  localsymbol_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000080u;
}
inline const std::string& Contract::localsymbol() const {
  // @@protoc_insertion_point(field_get:protobuf.Contract.localSymbol)
  return _internal_localsymbol();
}
inline void Contract::set_localsymbol(const std::string& value) {
  _internal_set_localsymbol(value);
  // @@protoc_insertion_point(field_set:protobuf.Contract.localSymbol)
}
inline std::string* Contract::mutable_localsymbol() {
  // @@protoc_insertion_point(field_mutable:protobuf.Contract.localSymbol)
  return _internal_mutable_localsymbol();
}
inline const std::string& Contract::_internal_localsymbol() const {
  return localsymbol_.Get();
}
inline void Contract::_internal_set_localsymbol(const std::string& value) {
  _has_bits_[0] |= 0x00000080u;
  localsymbol_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Contract::set_localsymbol(std::string&& value) {
  _has_bits_[0] |= 0x00000080u;
  localsymbol_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Contract.localSymbol)
}
inline void Contract::set_localsymbol(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000080u;
  localsymbol_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Contract.localSymbol)
}
inline void Contract::set_localsymbol(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000080u;
  localsymbol_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Contract.localSymbol)
}
inline std::string* Contract::_internal_mutable_localsymbol() {
  _has_bits_[0] |= 0x00000080u;
  return localsymbol_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Contract::release_localsymbol() {
  // @@protoc_insertion_point(field_release:protobuf.Contract.localSymbol)
  if (!_internal_has_localsymbol()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000080u;
  return localsymbol_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Contract::set_allocated_localsymbol(std::string* localsymbol) {
  if (localsymbol != nullptr) {
    _has_bits_[0] |= 0x00000080u;
  } else {
    _has_bits_[0] &= ~0x00000080u;
  }
  localsymbol_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), localsymbol,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Contract.localSymbol)
}
inline std::string* Contract::unsafe_arena_release_localsymbol() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Contract.localSymbol)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00000080u;
  return localsymbol_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Contract::unsafe_arena_set_allocated_localsymbol(
    std::string* localsymbol) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (localsymbol != nullptr) {
    _has_bits_[0] |= 0x00000080u;
  } else {
    _has_bits_[0] &= ~0x00000080u;
  }
  localsymbol_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      localsymbol, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Contract.localSymbol)
}

// string tradingClass = 12;
inline bool Contract::_internal_has_tradingclass() const {
  bool value = (_has_bits_[0] & 0x00000100u) != 0;
  return value;
}
inline bool Contract::has_tradingclass() const {
  return _internal_has_tradingclass();
}
inline void Contract::clear_tradingclass() {
  tradingclass_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000100u;
}
inline const std::string& Contract::tradingclass() const {
  // @@protoc_insertion_point(field_get:protobuf.Contract.tradingClass)
  return _internal_tradingclass();
}
inline void Contract::set_tradingclass(const std::string& value) {
  _internal_set_tradingclass(value);
  // @@protoc_insertion_point(field_set:protobuf.Contract.tradingClass)
}
inline std::string* Contract::mutable_tradingclass() {
  // @@protoc_insertion_point(field_mutable:protobuf.Contract.tradingClass)
  return _internal_mutable_tradingclass();
}
inline const std::string& Contract::_internal_tradingclass() const {
  return tradingclass_.Get();
}
inline void Contract::_internal_set_tradingclass(const std::string& value) {
  _has_bits_[0] |= 0x00000100u;
  tradingclass_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Contract::set_tradingclass(std::string&& value) {
  _has_bits_[0] |= 0x00000100u;
  tradingclass_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Contract.tradingClass)
}
inline void Contract::set_tradingclass(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000100u;
  tradingclass_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Contract.tradingClass)
}
inline void Contract::set_tradingclass(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000100u;
  tradingclass_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Contract.tradingClass)
}
inline std::string* Contract::_internal_mutable_tradingclass() {
  _has_bits_[0] |= 0x00000100u;
  return tradingclass_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Contract::release_tradingclass() {
  // @@protoc_insertion_point(field_release:protobuf.Contract.tradingClass)
  if (!_internal_has_tradingclass()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000100u;
  return tradingclass_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Contract::set_allocated_tradingclass(std::string* tradingclass) {
  if (tradingclass != nullptr) {
    _has_bits_[0] |= 0x00000100u;
  } else {
    _has_bits_[0] &= ~0x00000100u;
  }
  tradingclass_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), tradingclass,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Contract.tradingClass)
}
inline std::string* Contract::unsafe_arena_release_tradingclass() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Contract.tradingClass)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00000100u;
  return tradingclass_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Contract::unsafe_arena_set_allocated_tradingclass(
    std::string* tradingclass) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (tradingclass != nullptr) {
    _has_bits_[0] |= 0x00000100u;
  } else {
    _has_bits_[0] &= ~0x00000100u;
  }
  tradingclass_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      tradingclass, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Contract.tradingClass)
}

// string secIdType = 13;
inline bool Contract::_internal_has_secidtype() const {
  bool value = (_has_bits_[0] & 0x00000200u) != 0;
  return value;
}
inline bool Contract::has_secidtype() const {
  return _internal_has_secidtype();
}
inline void Contract::clear_secidtype() {
  secidtype_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000200u;
}
inline const std::string& Contract::secidtype() const {
  // @@protoc_insertion_point(field_get:protobuf.Contract.secIdType)
  return _internal_secidtype();
}
inline void Contract::set_secidtype(const std::string& value) {
  _internal_set_secidtype(value);
  // @@protoc_insertion_point(field_set:protobuf.Contract.secIdType)
}
inline std::string* Contract::mutable_secidtype() {
  // @@protoc_insertion_point(field_mutable:protobuf.Contract.secIdType)
  return _internal_mutable_secidtype();
}
inline const std::string& Contract::_internal_secidtype() const {
  return secidtype_.Get();
}
inline void Contract::_internal_set_secidtype(const std::string& value) {
  _has_bits_[0] |= 0x00000200u;
  secidtype_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Contract::set_secidtype(std::string&& value) {
  _has_bits_[0] |= 0x00000200u;
  secidtype_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Contract.secIdType)
}
inline void Contract::set_secidtype(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000200u;
  secidtype_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Contract.secIdType)
}
inline void Contract::set_secidtype(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000200u;
  secidtype_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Contract.secIdType)
}
inline std::string* Contract::_internal_mutable_secidtype() {
  _has_bits_[0] |= 0x00000200u;
  return secidtype_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Contract::release_secidtype() {
  // @@protoc_insertion_point(field_release:protobuf.Contract.secIdType)
  if (!_internal_has_secidtype()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000200u;
  return secidtype_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Contract::set_allocated_secidtype(std::string* secidtype) {
  if (secidtype != nullptr) {
    _has_bits_[0] |= 0x00000200u;
  } else {
    _has_bits_[0] &= ~0x00000200u;
  }
  secidtype_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), secidtype,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Contract.secIdType)
}
inline std::string* Contract::unsafe_arena_release_secidtype() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Contract.secIdType)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00000200u;
  return secidtype_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Contract::unsafe_arena_set_allocated_secidtype(
    std::string* secidtype) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (secidtype != nullptr) {
    _has_bits_[0] |= 0x00000200u;
  } else {
    _has_bits_[0] &= ~0x00000200u;
  }
  secidtype_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      secidtype, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Contract.secIdType)
}

// string secId = 14;
inline bool Contract::_internal_has_secid() const {
  bool value = (_has_bits_[0] & 0x00000400u) != 0;
  return value;
}
inline bool Contract::has_secid() const {
  return _internal_has_secid();
}
inline void Contract::clear_secid() {
  secid_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000400u;
}
inline const std::string& Contract::secid() const {
  // @@protoc_insertion_point(field_get:protobuf.Contract.secId)
  return _internal_secid();
}
inline void Contract::set_secid(const std::string& value) {
  _internal_set_secid(value);
  // @@protoc_insertion_point(field_set:protobuf.Contract.secId)
}
inline std::string* Contract::mutable_secid() {
  // @@protoc_insertion_point(field_mutable:protobuf.Contract.secId)
  return _internal_mutable_secid();
}
inline const std::string& Contract::_internal_secid() const {
  return secid_.Get();
}
inline void Contract::_internal_set_secid(const std::string& value) {
  _has_bits_[0] |= 0x00000400u;
  secid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Contract::set_secid(std::string&& value) {
  _has_bits_[0] |= 0x00000400u;
  secid_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Contract.secId)
}
inline void Contract::set_secid(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000400u;
  secid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Contract.secId)
}
inline void Contract::set_secid(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000400u;
  secid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Contract.secId)
}
inline std::string* Contract::_internal_mutable_secid() {
  _has_bits_[0] |= 0x00000400u;
  return secid_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Contract::release_secid() {
  // @@protoc_insertion_point(field_release:protobuf.Contract.secId)
  if (!_internal_has_secid()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000400u;
  return secid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Contract::set_allocated_secid(std::string* secid) {
  if (secid != nullptr) {
    _has_bits_[0] |= 0x00000400u;
  } else {
    _has_bits_[0] &= ~0x00000400u;
  }
  secid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), secid,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Contract.secId)
}
inline std::string* Contract::unsafe_arena_release_secid() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Contract.secId)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00000400u;
  return secid_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Contract::unsafe_arena_set_allocated_secid(
    std::string* secid) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (secid != nullptr) {
    _has_bits_[0] |= 0x00000400u;
  } else {
    _has_bits_[0] &= ~0x00000400u;
  }
  secid_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      secid, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Contract.secId)
}

// string description = 15;
inline bool Contract::_internal_has_description() const {
  bool value = (_has_bits_[0] & 0x00000800u) != 0;
  return value;
}
inline bool Contract::has_description() const {
  return _internal_has_description();
}
inline void Contract::clear_description() {
  description_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00000800u;
}
inline const std::string& Contract::description() const {
  // @@protoc_insertion_point(field_get:protobuf.Contract.description)
  return _internal_description();
}
inline void Contract::set_description(const std::string& value) {
  _internal_set_description(value);
  // @@protoc_insertion_point(field_set:protobuf.Contract.description)
}
inline std::string* Contract::mutable_description() {
  // @@protoc_insertion_point(field_mutable:protobuf.Contract.description)
  return _internal_mutable_description();
}
inline const std::string& Contract::_internal_description() const {
  return description_.Get();
}
inline void Contract::_internal_set_description(const std::string& value) {
  _has_bits_[0] |= 0x00000800u;
  description_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Contract::set_description(std::string&& value) {
  _has_bits_[0] |= 0x00000800u;
  description_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Contract.description)
}
inline void Contract::set_description(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00000800u;
  description_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Contract.description)
}
inline void Contract::set_description(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00000800u;
  description_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Contract.description)
}
inline std::string* Contract::_internal_mutable_description() {
  _has_bits_[0] |= 0x00000800u;
  return description_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Contract::release_description() {
  // @@protoc_insertion_point(field_release:protobuf.Contract.description)
  if (!_internal_has_description()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00000800u;
  return description_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Contract::set_allocated_description(std::string* description) {
  if (description != nullptr) {
    _has_bits_[0] |= 0x00000800u;
  } else {
    _has_bits_[0] &= ~0x00000800u;
  }
  description_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), description,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Contract.description)
}
inline std::string* Contract::unsafe_arena_release_description() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Contract.description)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00000800u;
  return description_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Contract::unsafe_arena_set_allocated_description(
    std::string* description) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (description != nullptr) {
    _has_bits_[0] |= 0x00000800u;
  } else {
    _has_bits_[0] &= ~0x00000800u;
  }
  description_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      description, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Contract.description)
}

// string issuerId = 16;
inline bool Contract::_internal_has_issuerid() const {
  bool value = (_has_bits_[0] & 0x00001000u) != 0;
  return value;
}
inline bool Contract::has_issuerid() const {
  return _internal_has_issuerid();
}
inline void Contract::clear_issuerid() {
  issuerid_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00001000u;
}
inline const std::string& Contract::issuerid() const {
  // @@protoc_insertion_point(field_get:protobuf.Contract.issuerId)
  return _internal_issuerid();
}
inline void Contract::set_issuerid(const std::string& value) {
  _internal_set_issuerid(value);
  // @@protoc_insertion_point(field_set:protobuf.Contract.issuerId)
}
inline std::string* Contract::mutable_issuerid() {
  // @@protoc_insertion_point(field_mutable:protobuf.Contract.issuerId)
  return _internal_mutable_issuerid();
}
inline const std::string& Contract::_internal_issuerid() const {
  return issuerid_.Get();
}
inline void Contract::_internal_set_issuerid(const std::string& value) {
  _has_bits_[0] |= 0x00001000u;
  issuerid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Contract::set_issuerid(std::string&& value) {
  _has_bits_[0] |= 0x00001000u;
  issuerid_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Contract.issuerId)
}
inline void Contract::set_issuerid(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00001000u;
  issuerid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Contract.issuerId)
}
inline void Contract::set_issuerid(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00001000u;
  issuerid_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Contract.issuerId)
}
inline std::string* Contract::_internal_mutable_issuerid() {
  _has_bits_[0] |= 0x00001000u;
  return issuerid_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Contract::release_issuerid() {
  // @@protoc_insertion_point(field_release:protobuf.Contract.issuerId)
  if (!_internal_has_issuerid()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00001000u;
  return issuerid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Contract::set_allocated_issuerid(std::string* issuerid) {
  if (issuerid != nullptr) {
    _has_bits_[0] |= 0x00001000u;
  } else {
    _has_bits_[0] &= ~0x00001000u;
  }
  issuerid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), issuerid,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Contract.issuerId)
}
inline std::string* Contract::unsafe_arena_release_issuerid() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Contract.issuerId)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00001000u;
  return issuerid_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Contract::unsafe_arena_set_allocated_issuerid(
    std::string* issuerid) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (issuerid != nullptr) {
    _has_bits_[0] |= 0x00001000u;
  } else {
    _has_bits_[0] &= ~0x00001000u;
  }
  issuerid_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      issuerid, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Contract.issuerId)
}

// .protobuf.DeltaNeutralContract deltaNeutralContract = 17;
inline bool Contract::_internal_has_deltaneutralcontract() const {
  bool value = (_has_bits_[0] & 0x00004000u) != 0;
  PROTOBUF_ASSUME(!value || deltaneutralcontract_ != nullptr);
  return value;
}
inline bool Contract::has_deltaneutralcontract() const {
  return _internal_has_deltaneutralcontract();
}
inline const ::protobuf::DeltaNeutralContract& Contract::_internal_deltaneutralcontract() const {
  const ::protobuf::DeltaNeutralContract* p = deltaneutralcontract_;
  return p != nullptr ? *p : *reinterpret_cast<const ::protobuf::DeltaNeutralContract*>(
      &::protobuf::_DeltaNeutralContract_default_instance_);
}
inline const ::protobuf::DeltaNeutralContract& Contract::deltaneutralcontract() const {
  // @@protoc_insertion_point(field_get:protobuf.Contract.deltaNeutralContract)
  return _internal_deltaneutralcontract();
}
inline void Contract::unsafe_arena_set_allocated_deltaneutralcontract(
    ::protobuf::DeltaNeutralContract* deltaneutralcontract) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(deltaneutralcontract_);
  }
  deltaneutralcontract_ = deltaneutralcontract;
  if (deltaneutralcontract) {
    _has_bits_[0] |= 0x00004000u;
  } else {
    _has_bits_[0] &= ~0x00004000u;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Contract.deltaNeutralContract)
}
inline ::protobuf::DeltaNeutralContract* Contract::release_deltaneutralcontract() {
  auto temp = unsafe_arena_release_deltaneutralcontract();
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::protobuf::DeltaNeutralContract* Contract::unsafe_arena_release_deltaneutralcontract() {
  // @@protoc_insertion_point(field_release:protobuf.Contract.deltaNeutralContract)
  _has_bits_[0] &= ~0x00004000u;
  ::protobuf::DeltaNeutralContract* temp = deltaneutralcontract_;
  deltaneutralcontract_ = nullptr;
  return temp;
}
inline ::protobuf::DeltaNeutralContract* Contract::_internal_mutable_deltaneutralcontract() {
  _has_bits_[0] |= 0x00004000u;
  if (deltaneutralcontract_ == nullptr) {
    auto* p = CreateMaybeMessage<::protobuf::DeltaNeutralContract>(GetArena());
    deltaneutralcontract_ = p;
  }
  return deltaneutralcontract_;
}
inline ::protobuf::DeltaNeutralContract* Contract::mutable_deltaneutralcontract() {
  // @@protoc_insertion_point(field_mutable:protobuf.Contract.deltaNeutralContract)
  return _internal_mutable_deltaneutralcontract();
}
inline void Contract::set_allocated_deltaneutralcontract(::protobuf::DeltaNeutralContract* deltaneutralcontract) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(deltaneutralcontract_);
  }
  if (deltaneutralcontract) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(deltaneutralcontract)->GetArena();
    if (message_arena != submessage_arena) {
      deltaneutralcontract = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, deltaneutralcontract, submessage_arena);
    }
    _has_bits_[0] |= 0x00004000u;
  } else {
    _has_bits_[0] &= ~0x00004000u;
  }
  deltaneutralcontract_ = deltaneutralcontract;
  // @@protoc_insertion_point(field_set_allocated:protobuf.Contract.deltaNeutralContract)
}

// bool includeExpired = 18;
inline bool Contract::_internal_has_includeexpired() const {
  bool value = (_has_bits_[0] & 0x00040000u) != 0;
  return value;
}
inline bool Contract::has_includeexpired() const {
  return _internal_has_includeexpired();
}
inline void Contract::clear_includeexpired() {
  includeexpired_ = false;
  _has_bits_[0] &= ~0x00040000u;
}
inline bool Contract::_internal_includeexpired() const {
  return includeexpired_;
}
inline bool Contract::includeexpired() const {
  // @@protoc_insertion_point(field_get:protobuf.Contract.includeExpired)
  return _internal_includeexpired();
}
inline void Contract::_internal_set_includeexpired(bool value) {
  _has_bits_[0] |= 0x00040000u;
  includeexpired_ = value;
}
inline void Contract::set_includeexpired(bool value) {
  _internal_set_includeexpired(value);
  // @@protoc_insertion_point(field_set:protobuf.Contract.includeExpired)
}

// string comboLegsDescrip = 19;
inline bool Contract::_internal_has_combolegsdescrip() const {
  bool value = (_has_bits_[0] & 0x00002000u) != 0;
  return value;
}
inline bool Contract::has_combolegsdescrip() const {
  return _internal_has_combolegsdescrip();
}
inline void Contract::clear_combolegsdescrip() {
  combolegsdescrip_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _has_bits_[0] &= ~0x00002000u;
}
inline const std::string& Contract::combolegsdescrip() const {
  // @@protoc_insertion_point(field_get:protobuf.Contract.comboLegsDescrip)
  return _internal_combolegsdescrip();
}
inline void Contract::set_combolegsdescrip(const std::string& value) {
  _internal_set_combolegsdescrip(value);
  // @@protoc_insertion_point(field_set:protobuf.Contract.comboLegsDescrip)
}
inline std::string* Contract::mutable_combolegsdescrip() {
  // @@protoc_insertion_point(field_mutable:protobuf.Contract.comboLegsDescrip)
  return _internal_mutable_combolegsdescrip();
}
inline const std::string& Contract::_internal_combolegsdescrip() const {
  return combolegsdescrip_.Get();
}
inline void Contract::_internal_set_combolegsdescrip(const std::string& value) {
  _has_bits_[0] |= 0x00002000u;
  combolegsdescrip_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void Contract::set_combolegsdescrip(std::string&& value) {
  _has_bits_[0] |= 0x00002000u;
  combolegsdescrip_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:protobuf.Contract.comboLegsDescrip)
}
inline void Contract::set_combolegsdescrip(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  _has_bits_[0] |= 0x00002000u;
  combolegsdescrip_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:protobuf.Contract.comboLegsDescrip)
}
inline void Contract::set_combolegsdescrip(const char* value,
    size_t size) {
  _has_bits_[0] |= 0x00002000u;
  combolegsdescrip_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:protobuf.Contract.comboLegsDescrip)
}
inline std::string* Contract::_internal_mutable_combolegsdescrip() {
  _has_bits_[0] |= 0x00002000u;
  return combolegsdescrip_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* Contract::release_combolegsdescrip() {
  // @@protoc_insertion_point(field_release:protobuf.Contract.comboLegsDescrip)
  if (!_internal_has_combolegsdescrip()) {
    return nullptr;
  }
  _has_bits_[0] &= ~0x00002000u;
  return combolegsdescrip_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Contract::set_allocated_combolegsdescrip(std::string* combolegsdescrip) {
  if (combolegsdescrip != nullptr) {
    _has_bits_[0] |= 0x00002000u;
  } else {
    _has_bits_[0] &= ~0x00002000u;
  }
  combolegsdescrip_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), combolegsdescrip,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:protobuf.Contract.comboLegsDescrip)
}
inline std::string* Contract::unsafe_arena_release_combolegsdescrip() {
  // @@protoc_insertion_point(field_unsafe_arena_release:protobuf.Contract.comboLegsDescrip)
  GOOGLE_DCHECK(GetArena() != nullptr);
  _has_bits_[0] &= ~0x00002000u;
  return combolegsdescrip_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void Contract::unsafe_arena_set_allocated_combolegsdescrip(
    std::string* combolegsdescrip) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (combolegsdescrip != nullptr) {
    _has_bits_[0] |= 0x00002000u;
  } else {
    _has_bits_[0] &= ~0x00002000u;
  }
  combolegsdescrip_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      combolegsdescrip, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:protobuf.Contract.comboLegsDescrip)
}

// repeated .protobuf.ComboLeg comboLegs = 20;
inline int Contract::_internal_combolegs_size() const {
  return combolegs_.size();
}
inline int Contract::combolegs_size() const {
  return _internal_combolegs_size();
}
inline ::protobuf::ComboLeg* Contract::mutable_combolegs(int index) {
  // @@protoc_insertion_point(field_mutable:protobuf.Contract.comboLegs)
  return combolegs_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::protobuf::ComboLeg >*
Contract::mutable_combolegs() {
  // @@protoc_insertion_point(field_mutable_list:protobuf.Contract.comboLegs)
  return &combolegs_;
}
inline const ::protobuf::ComboLeg& Contract::_internal_combolegs(int index) const {
  return combolegs_.Get(index);
}
inline const ::protobuf::ComboLeg& Contract::combolegs(int index) const {
  // @@protoc_insertion_point(field_get:protobuf.Contract.comboLegs)
  return _internal_combolegs(index);
}
inline ::protobuf::ComboLeg* Contract::_internal_add_combolegs() {
  return combolegs_.Add();
}
inline ::protobuf::ComboLeg* Contract::add_combolegs() {
  // @@protoc_insertion_point(field_add:protobuf.Contract.comboLegs)
  return _internal_add_combolegs();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::protobuf::ComboLeg >&
Contract::combolegs() const {
  // @@protoc_insertion_point(field_list:protobuf.Contract.comboLegs)
  return combolegs_;
}

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