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

#ifndef PROTOBUF_mysql_5flogger_2eproto__INCLUDED
#define PROTOBUF_mysql_5flogger_2eproto__INCLUDED

#include <string>

#include <google/protobuf/stubs/common.h>

#if GOOGLE_PROTOBUF_VERSION < 2006000
#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 2006001 < GOOGLE_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/generated_message_util.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)

namespace mysql_logger {

// Internal implementation detail -- do not call these.
void  protobuf_AddDesc_mysql_5flogger_2eproto();
void protobuf_AssignDesc_mysql_5flogger_2eproto();
void protobuf_ShutdownFile_mysql_5flogger_2eproto();

class event;

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

class event : public ::google::protobuf::Message {
 public:
  event();
  virtual ~event();

  event(const event& from);

  inline event& operator=(const event& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const event& default_instance();

  void Swap(event* other);

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

  event* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const event& from);
  void MergeFrom(const event& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // required uint32 thread_id = 1;
  inline bool has_thread_id() const;
  inline void clear_thread_id();
  static const int kThreadIdFieldNumber = 1;
  inline ::google::protobuf::uint32 thread_id() const;
  inline void set_thread_id(::google::protobuf::uint32 value);

  // required string username = 2;
  inline bool has_username() const;
  inline void clear_username();
  static const int kUsernameFieldNumber = 2;
  inline const ::std::string& username() const;
  inline void set_username(const ::std::string& value);
  inline void set_username(const char* value);
  inline void set_username(const char* value, size_t size);
  inline ::std::string* mutable_username();
  inline ::std::string* release_username();
  inline void set_allocated_username(::std::string* username);

  // required string schemaname = 3;
  inline bool has_schemaname() const;
  inline void clear_schemaname();
  static const int kSchemanameFieldNumber = 3;
  inline const ::std::string& schemaname() const;
  inline void set_schemaname(const ::std::string& value);
  inline void set_schemaname(const char* value);
  inline void set_schemaname(const char* value, size_t size);
  inline ::std::string* mutable_schemaname();
  inline ::std::string* release_schemaname();
  inline void set_allocated_schemaname(::std::string* schemaname);

  // required uint64 start_time = 4;
  inline bool has_start_time() const;
  inline void clear_start_time();
  static const int kStartTimeFieldNumber = 4;
  inline ::google::protobuf::uint64 start_time() const;
  inline void set_start_time(::google::protobuf::uint64 value);

  // required uint64 end_time = 5;
  inline bool has_end_time() const;
  inline void clear_end_time();
  static const int kEndTimeFieldNumber = 5;
  inline ::google::protobuf::uint64 end_time() const;
  inline void set_end_time(::google::protobuf::uint64 value);

  // optional uint64 query_digest = 6;
  inline bool has_query_digest() const;
  inline void clear_query_digest();
  static const int kQueryDigestFieldNumber = 6;
  inline ::google::protobuf::uint64 query_digest() const;
  inline void set_query_digest(::google::protobuf::uint64 value);

  // required string query = 7;
  inline bool has_query() const;
  inline void clear_query();
  static const int kQueryFieldNumber = 7;
  inline const ::std::string& query() const;
  inline void set_query(const ::std::string& value);
  inline void set_query(const char* value);
  inline void set_query(const char* value, size_t size);
  inline ::std::string* mutable_query();
  inline ::std::string* release_query();
  inline void set_allocated_query(::std::string* query);

  // optional string server = 8;
  inline bool has_server() const;
  inline void clear_server();
  static const int kServerFieldNumber = 8;
  inline const ::std::string& server() const;
  inline void set_server(const ::std::string& value);
  inline void set_server(const char* value);
  inline void set_server(const char* value, size_t size);
  inline ::std::string* mutable_server();
  inline ::std::string* release_server();
  inline void set_allocated_server(::std::string* server);

  // optional string client = 9;
  inline bool has_client() const;
  inline void clear_client();
  static const int kClientFieldNumber = 9;
  inline const ::std::string& client() const;
  inline void set_client(const ::std::string& value);
  inline void set_client(const char* value);
  inline void set_client(const char* value, size_t size);
  inline ::std::string* mutable_client();
  inline ::std::string* release_client();
  inline void set_allocated_client(::std::string* client);

  // @@protoc_insertion_point(class_scope:mysql_logger.event)
 private:
  inline void set_has_thread_id();
  inline void clear_has_thread_id();
  inline void set_has_username();
  inline void clear_has_username();
  inline void set_has_schemaname();
  inline void clear_has_schemaname();
  inline void set_has_start_time();
  inline void clear_has_start_time();
  inline void set_has_end_time();
  inline void clear_has_end_time();
  inline void set_has_query_digest();
  inline void clear_has_query_digest();
  inline void set_has_query();
  inline void clear_has_query();
  inline void set_has_server();
  inline void clear_has_server();
  inline void set_has_client();
  inline void clear_has_client();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::std::string* username_;
  ::std::string* schemaname_;
  ::google::protobuf::uint64 start_time_;
  ::google::protobuf::uint64 end_time_;
  ::google::protobuf::uint64 query_digest_;
  ::std::string* query_;
  ::std::string* server_;
  ::std::string* client_;
  ::google::protobuf::uint32 thread_id_;
  friend void  protobuf_AddDesc_mysql_5flogger_2eproto();
  friend void protobuf_AssignDesc_mysql_5flogger_2eproto();
  friend void protobuf_ShutdownFile_mysql_5flogger_2eproto();

  void InitAsDefaultInstance();
  static event* default_instance_;
};
// ===================================================================


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

// event

// required uint32 thread_id = 1;
inline bool event::has_thread_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void event::set_has_thread_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void event::clear_has_thread_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void event::clear_thread_id() {
  thread_id_ = 0u;
  clear_has_thread_id();
}
inline ::google::protobuf::uint32 event::thread_id() const {
  // @@protoc_insertion_point(field_get:mysql_logger.event.thread_id)
  return thread_id_;
}
inline void event::set_thread_id(::google::protobuf::uint32 value) {
  set_has_thread_id();
  thread_id_ = value;
  // @@protoc_insertion_point(field_set:mysql_logger.event.thread_id)
}

// required string username = 2;
inline bool event::has_username() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void event::set_has_username() {
  _has_bits_[0] |= 0x00000002u;
}
inline void event::clear_has_username() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void event::clear_username() {
  if (username_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    username_->clear();
  }
  clear_has_username();
}
inline const ::std::string& event::username() const {
  // @@protoc_insertion_point(field_get:mysql_logger.event.username)
  return *username_;
}
inline void event::set_username(const ::std::string& value) {
  set_has_username();
  if (username_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    username_ = new ::std::string;
  }
  username_->assign(value);
  // @@protoc_insertion_point(field_set:mysql_logger.event.username)
}
inline void event::set_username(const char* value) {
  set_has_username();
  if (username_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    username_ = new ::std::string;
  }
  username_->assign(value);
  // @@protoc_insertion_point(field_set_char:mysql_logger.event.username)
}
inline void event::set_username(const char* value, size_t size) {
  set_has_username();
  if (username_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    username_ = new ::std::string;
  }
  username_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:mysql_logger.event.username)
}
inline ::std::string* event::mutable_username() {
  set_has_username();
  if (username_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    username_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:mysql_logger.event.username)
  return username_;
}
inline ::std::string* event::release_username() {
  clear_has_username();
  if (username_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = username_;
    username_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void event::set_allocated_username(::std::string* username) {
  if (username_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete username_;
  }
  if (username) {
    set_has_username();
    username_ = username;
  } else {
    clear_has_username();
    username_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:mysql_logger.event.username)
}

// required string schemaname = 3;
inline bool event::has_schemaname() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void event::set_has_schemaname() {
  _has_bits_[0] |= 0x00000004u;
}
inline void event::clear_has_schemaname() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void event::clear_schemaname() {
  if (schemaname_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    schemaname_->clear();
  }
  clear_has_schemaname();
}
inline const ::std::string& event::schemaname() const {
  // @@protoc_insertion_point(field_get:mysql_logger.event.schemaname)
  return *schemaname_;
}
inline void event::set_schemaname(const ::std::string& value) {
  set_has_schemaname();
  if (schemaname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    schemaname_ = new ::std::string;
  }
  schemaname_->assign(value);
  // @@protoc_insertion_point(field_set:mysql_logger.event.schemaname)
}
inline void event::set_schemaname(const char* value) {
  set_has_schemaname();
  if (schemaname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    schemaname_ = new ::std::string;
  }
  schemaname_->assign(value);
  // @@protoc_insertion_point(field_set_char:mysql_logger.event.schemaname)
}
inline void event::set_schemaname(const char* value, size_t size) {
  set_has_schemaname();
  if (schemaname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    schemaname_ = new ::std::string;
  }
  schemaname_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:mysql_logger.event.schemaname)
}
inline ::std::string* event::mutable_schemaname() {
  set_has_schemaname();
  if (schemaname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    schemaname_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:mysql_logger.event.schemaname)
  return schemaname_;
}
inline ::std::string* event::release_schemaname() {
  clear_has_schemaname();
  if (schemaname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = schemaname_;
    schemaname_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void event::set_allocated_schemaname(::std::string* schemaname) {
  if (schemaname_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete schemaname_;
  }
  if (schemaname) {
    set_has_schemaname();
    schemaname_ = schemaname;
  } else {
    clear_has_schemaname();
    schemaname_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:mysql_logger.event.schemaname)
}

// required uint64 start_time = 4;
inline bool event::has_start_time() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void event::set_has_start_time() {
  _has_bits_[0] |= 0x00000008u;
}
inline void event::clear_has_start_time() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void event::clear_start_time() {
  start_time_ = GOOGLE_ULONGLONG(0);
  clear_has_start_time();
}
inline ::google::protobuf::uint64 event::start_time() const {
  // @@protoc_insertion_point(field_get:mysql_logger.event.start_time)
  return start_time_;
}
inline void event::set_start_time(::google::protobuf::uint64 value) {
  set_has_start_time();
  start_time_ = value;
  // @@protoc_insertion_point(field_set:mysql_logger.event.start_time)
}

// required uint64 end_time = 5;
inline bool event::has_end_time() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void event::set_has_end_time() {
  _has_bits_[0] |= 0x00000010u;
}
inline void event::clear_has_end_time() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void event::clear_end_time() {
  end_time_ = GOOGLE_ULONGLONG(0);
  clear_has_end_time();
}
inline ::google::protobuf::uint64 event::end_time() const {
  // @@protoc_insertion_point(field_get:mysql_logger.event.end_time)
  return end_time_;
}
inline void event::set_end_time(::google::protobuf::uint64 value) {
  set_has_end_time();
  end_time_ = value;
  // @@protoc_insertion_point(field_set:mysql_logger.event.end_time)
}

// optional uint64 query_digest = 6;
inline bool event::has_query_digest() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void event::set_has_query_digest() {
  _has_bits_[0] |= 0x00000020u;
}
inline void event::clear_has_query_digest() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void event::clear_query_digest() {
  query_digest_ = GOOGLE_ULONGLONG(0);
  clear_has_query_digest();
}
inline ::google::protobuf::uint64 event::query_digest() const {
  // @@protoc_insertion_point(field_get:mysql_logger.event.query_digest)
  return query_digest_;
}
inline void event::set_query_digest(::google::protobuf::uint64 value) {
  set_has_query_digest();
  query_digest_ = value;
  // @@protoc_insertion_point(field_set:mysql_logger.event.query_digest)
}

// required string query = 7;
inline bool event::has_query() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void event::set_has_query() {
  _has_bits_[0] |= 0x00000040u;
}
inline void event::clear_has_query() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void event::clear_query() {
  if (query_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    query_->clear();
  }
  clear_has_query();
}
inline const ::std::string& event::query() const {
  // @@protoc_insertion_point(field_get:mysql_logger.event.query)
  return *query_;
}
inline void event::set_query(const ::std::string& value) {
  set_has_query();
  if (query_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    query_ = new ::std::string;
  }
  query_->assign(value);
  // @@protoc_insertion_point(field_set:mysql_logger.event.query)
}
inline void event::set_query(const char* value) {
  set_has_query();
  if (query_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    query_ = new ::std::string;
  }
  query_->assign(value);
  // @@protoc_insertion_point(field_set_char:mysql_logger.event.query)
}
inline void event::set_query(const char* value, size_t size) {
  set_has_query();
  if (query_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    query_ = new ::std::string;
  }
  query_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:mysql_logger.event.query)
}
inline ::std::string* event::mutable_query() {
  set_has_query();
  if (query_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    query_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:mysql_logger.event.query)
  return query_;
}
inline ::std::string* event::release_query() {
  clear_has_query();
  if (query_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = query_;
    query_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void event::set_allocated_query(::std::string* query) {
  if (query_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete query_;
  }
  if (query) {
    set_has_query();
    query_ = query;
  } else {
    clear_has_query();
    query_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:mysql_logger.event.query)
}

// optional string server = 8;
inline bool event::has_server() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void event::set_has_server() {
  _has_bits_[0] |= 0x00000080u;
}
inline void event::clear_has_server() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void event::clear_server() {
  if (server_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    server_->clear();
  }
  clear_has_server();
}
inline const ::std::string& event::server() const {
  // @@protoc_insertion_point(field_get:mysql_logger.event.server)
  return *server_;
}
inline void event::set_server(const ::std::string& value) {
  set_has_server();
  if (server_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    server_ = new ::std::string;
  }
  server_->assign(value);
  // @@protoc_insertion_point(field_set:mysql_logger.event.server)
}
inline void event::set_server(const char* value) {
  set_has_server();
  if (server_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    server_ = new ::std::string;
  }
  server_->assign(value);
  // @@protoc_insertion_point(field_set_char:mysql_logger.event.server)
}
inline void event::set_server(const char* value, size_t size) {
  set_has_server();
  if (server_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    server_ = new ::std::string;
  }
  server_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:mysql_logger.event.server)
}
inline ::std::string* event::mutable_server() {
  set_has_server();
  if (server_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    server_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:mysql_logger.event.server)
  return server_;
}
inline ::std::string* event::release_server() {
  clear_has_server();
  if (server_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = server_;
    server_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void event::set_allocated_server(::std::string* server) {
  if (server_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete server_;
  }
  if (server) {
    set_has_server();
    server_ = server;
  } else {
    clear_has_server();
    server_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:mysql_logger.event.server)
}

// optional string client = 9;
inline bool event::has_client() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void event::set_has_client() {
  _has_bits_[0] |= 0x00000100u;
}
inline void event::clear_has_client() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void event::clear_client() {
  if (client_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    client_->clear();
  }
  clear_has_client();
}
inline const ::std::string& event::client() const {
  // @@protoc_insertion_point(field_get:mysql_logger.event.client)
  return *client_;
}
inline void event::set_client(const ::std::string& value) {
  set_has_client();
  if (client_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    client_ = new ::std::string;
  }
  client_->assign(value);
  // @@protoc_insertion_point(field_set:mysql_logger.event.client)
}
inline void event::set_client(const char* value) {
  set_has_client();
  if (client_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    client_ = new ::std::string;
  }
  client_->assign(value);
  // @@protoc_insertion_point(field_set_char:mysql_logger.event.client)
}
inline void event::set_client(const char* value, size_t size) {
  set_has_client();
  if (client_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    client_ = new ::std::string;
  }
  client_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:mysql_logger.event.client)
}
inline ::std::string* event::mutable_client() {
  set_has_client();
  if (client_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    client_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:mysql_logger.event.client)
  return client_;
}
inline ::std::string* event::release_client() {
  clear_has_client();
  if (client_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = client_;
    client_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void event::set_allocated_client(::std::string* client) {
  if (client_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete client_;
  }
  if (client) {
    set_has_client();
    client_ = client;
  } else {
    clear_has_client();
    client_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:mysql_logger.event.client)
}


// @@protoc_insertion_point(namespace_scope)

}  // namespace mysql_logger

#ifndef SWIG
namespace google {
namespace protobuf {


}  // namespace google
}  // namespace protobuf
#endif  // SWIG

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_mysql_5flogger_2eproto__INCLUDED
