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

#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
#include "drules_struct.pb.h"

#include <algorithm>

#include <google/protobuf/stubs/common.h>
#include <google/protobuf/stubs/once.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/wire_format_lite_inl.h>
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
// @@protoc_insertion_point(includes)

void protobuf_ShutdownFile_drules_5fstruct_2eproto() {
  delete DashDotProto::default_instance_;
  delete PathSymProto::default_instance_;
  delete LineRuleProto::default_instance_;
  delete LineDefProto::default_instance_;
  delete AreaRuleProto::default_instance_;
  delete SymbolRuleProto::default_instance_;
  delete CaptionDefProto::default_instance_;
  delete CaptionRuleProto::default_instance_;
  delete CircleRuleProto::default_instance_;
  delete PathTextRuleProto::default_instance_;
  delete ShieldRuleProto::default_instance_;
  delete DrawElementProto::default_instance_;
  delete ClassifElementProto::default_instance_;
  delete ColorElementProto::default_instance_;
  delete ColorsElementProto::default_instance_;
  delete ContainerProto::default_instance_;
}

#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
void protobuf_AddDesc_drules_5fstruct_2eproto_impl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#else
void protobuf_AddDesc_drules_5fstruct_2eproto() {
  static bool already_here = false;
  if (already_here) return;
  already_here = true;
  GOOGLE_PROTOBUF_VERIFY_VERSION;

#endif
  DashDotProto::default_instance_ = new DashDotProto();
  PathSymProto::default_instance_ = new PathSymProto();
  LineRuleProto::default_instance_ = new LineRuleProto();
  LineDefProto::default_instance_ = new LineDefProto();
  AreaRuleProto::default_instance_ = new AreaRuleProto();
  SymbolRuleProto::default_instance_ = new SymbolRuleProto();
  CaptionDefProto::default_instance_ = new CaptionDefProto();
  CaptionRuleProto::default_instance_ = new CaptionRuleProto();
  CircleRuleProto::default_instance_ = new CircleRuleProto();
  PathTextRuleProto::default_instance_ = new PathTextRuleProto();
  ShieldRuleProto::default_instance_ = new ShieldRuleProto();
  DrawElementProto::default_instance_ = new DrawElementProto();
  ClassifElementProto::default_instance_ = new ClassifElementProto();
  ColorElementProto::default_instance_ = new ColorElementProto();
  ColorsElementProto::default_instance_ = new ColorsElementProto();
  ContainerProto::default_instance_ = new ContainerProto();
  DashDotProto::default_instance_->InitAsDefaultInstance();
  PathSymProto::default_instance_->InitAsDefaultInstance();
  LineRuleProto::default_instance_->InitAsDefaultInstance();
  LineDefProto::default_instance_->InitAsDefaultInstance();
  AreaRuleProto::default_instance_->InitAsDefaultInstance();
  SymbolRuleProto::default_instance_->InitAsDefaultInstance();
  CaptionDefProto::default_instance_->InitAsDefaultInstance();
  CaptionRuleProto::default_instance_->InitAsDefaultInstance();
  CircleRuleProto::default_instance_->InitAsDefaultInstance();
  PathTextRuleProto::default_instance_->InitAsDefaultInstance();
  ShieldRuleProto::default_instance_->InitAsDefaultInstance();
  DrawElementProto::default_instance_->InitAsDefaultInstance();
  ClassifElementProto::default_instance_->InitAsDefaultInstance();
  ColorElementProto::default_instance_->InitAsDefaultInstance();
  ColorsElementProto::default_instance_->InitAsDefaultInstance();
  ContainerProto::default_instance_->InitAsDefaultInstance();
  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_drules_5fstruct_2eproto);
}

#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AddDesc_drules_5fstruct_2eproto_once_);
void protobuf_AddDesc_drules_5fstruct_2eproto() {
  ::google::protobuf::GoogleOnceInit(&protobuf_AddDesc_drules_5fstruct_2eproto_once_,
                 &protobuf_AddDesc_drules_5fstruct_2eproto_impl);
}
#else
// Force AddDescriptors() to be called at static initialization time.
struct StaticDescriptorInitializer_drules_5fstruct_2eproto {
  StaticDescriptorInitializer_drules_5fstruct_2eproto() {
    protobuf_AddDesc_drules_5fstruct_2eproto();
  }
} static_descriptor_initializer_drules_5fstruct_2eproto_;
#endif
bool LineJoin_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}

bool LineCap_IsValid(int value) {
  switch(value) {
    case 0:
    case 1:
    case 2:
      return true;
    default:
      return false;
  }
}


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

#ifndef _MSC_VER
const int DashDotProto::kDdFieldNumber;
const int DashDotProto::kOffsetFieldNumber;
#endif  // !_MSC_VER

DashDotProto::DashDotProto()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:DashDotProto)
}

void DashDotProto::InitAsDefaultInstance() {
}

DashDotProto::DashDotProto(const DashDotProto& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:DashDotProto)
}

void DashDotProto::SharedCtor() {
  _cached_size_ = 0;
  offset_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

DashDotProto::~DashDotProto() {
  // @@protoc_insertion_point(destructor:DashDotProto)
  SharedDtor();
}

void DashDotProto::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void DashDotProto::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const DashDotProto& DashDotProto::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_drules_5fstruct_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto();
#endif
  return *default_instance_;
}

DashDotProto* DashDotProto::default_instance_ = NULL;

DashDotProto* DashDotProto::New() const {
  return new DashDotProto;
}

void DashDotProto::Clear() {
  offset_ = 0;
  dd_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool DashDotProto::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:DashDotProto)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated double dd = 1;
      case 1: {
        if (tag == 9) {
         parse_dd:
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 1, 9, input, this->mutable_dd())));
        } else if (tag == 10) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, this->mutable_dd())));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(9)) goto parse_dd;
        if (input->ExpectTag(17)) goto parse_offset;
        break;
      }

      // optional double offset = 2;
      case 2: {
        if (tag == 17) {
         parse_offset:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &offset_)));
          set_has_offset();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:DashDotProto)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:DashDotProto)
  return false;
#undef DO_
}

void DashDotProto::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:DashDotProto)
  // repeated double dd = 1;
  for (int i = 0; i < this->dd_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(
      1, this->dd(i), output);
  }

  // optional double offset = 2;
  if (has_offset()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(2, this->offset(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:DashDotProto)
}

int DashDotProto::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
    // optional double offset = 2;
    if (has_offset()) {
      total_size += 1 + 8;
    }

  }
  // repeated double dd = 1;
  {
    int data_size = 0;
    data_size = 8 * this->dd_size();
    total_size += 1 * this->dd_size() + data_size;
  }

  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void DashDotProto::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const DashDotProto*>(&from));
}

void DashDotProto::MergeFrom(const DashDotProto& from) {
  GOOGLE_CHECK_NE(&from, this);
  dd_.MergeFrom(from.dd_);
  if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
    if (from.has_offset()) {
      set_offset(from.offset());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void DashDotProto::CopyFrom(const DashDotProto& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DashDotProto::IsInitialized() const {

  return true;
}

void DashDotProto::Swap(DashDotProto* other) {
  if (other != this) {
    dd_.Swap(&other->dd_);
    std::swap(offset_, other->offset_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string DashDotProto::GetTypeName() const {
  return "DashDotProto";
}


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

#ifndef _MSC_VER
const int PathSymProto::kNameFieldNumber;
const int PathSymProto::kStepFieldNumber;
const int PathSymProto::kOffsetFieldNumber;
#endif  // !_MSC_VER

PathSymProto::PathSymProto()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:PathSymProto)
}

void PathSymProto::InitAsDefaultInstance() {
}

PathSymProto::PathSymProto(const PathSymProto& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:PathSymProto)
}

void PathSymProto::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  step_ = 0;
  offset_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

PathSymProto::~PathSymProto() {
  // @@protoc_insertion_point(destructor:PathSymProto)
  SharedDtor();
}

void PathSymProto::SharedDtor() {
  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete name_;
  }
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void PathSymProto::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const PathSymProto& PathSymProto::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_drules_5fstruct_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto();
#endif
  return *default_instance_;
}

PathSymProto* PathSymProto::default_instance_ = NULL;

PathSymProto* PathSymProto::New() const {
  return new PathSymProto;
}

void PathSymProto::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<PathSymProto*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 7) {
    ZR_(step_, offset_);
    if (has_name()) {
      if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        name_->clear();
      }
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool PathSymProto::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:PathSymProto)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required string name = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(17)) goto parse_step;
        break;
      }

      // required double step = 2;
      case 2: {
        if (tag == 17) {
         parse_step:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &step_)));
          set_has_step();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(25)) goto parse_offset;
        break;
      }

      // optional double offset = 3;
      case 3: {
        if (tag == 25) {
         parse_offset:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &offset_)));
          set_has_offset();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:PathSymProto)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:PathSymProto)
  return false;
#undef DO_
}

void PathSymProto::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:PathSymProto)
  // required string name = 1;
  if (has_name()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->name(), output);
  }

  // required double step = 2;
  if (has_step()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(2, this->step(), output);
  }

  // optional double offset = 3;
  if (has_offset()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(3, this->offset(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:PathSymProto)
}

int PathSymProto::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required string name = 1;
    if (has_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->name());
    }

    // required double step = 2;
    if (has_step()) {
      total_size += 1 + 8;
    }

    // optional double offset = 3;
    if (has_offset()) {
      total_size += 1 + 8;
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void PathSymProto::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const PathSymProto*>(&from));
}

void PathSymProto::MergeFrom(const PathSymProto& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_name()) {
      set_name(from.name());
    }
    if (from.has_step()) {
      set_step(from.step());
    }
    if (from.has_offset()) {
      set_offset(from.offset());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void PathSymProto::CopyFrom(const PathSymProto& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PathSymProto::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void PathSymProto::Swap(PathSymProto* other) {
  if (other != this) {
    std::swap(name_, other->name_);
    std::swap(step_, other->step_);
    std::swap(offset_, other->offset_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string PathSymProto::GetTypeName() const {
  return "PathSymProto";
}


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

#ifndef _MSC_VER
const int LineRuleProto::kWidthFieldNumber;
const int LineRuleProto::kColorFieldNumber;
const int LineRuleProto::kDashdotFieldNumber;
const int LineRuleProto::kPriorityFieldNumber;
const int LineRuleProto::kPathsymFieldNumber;
const int LineRuleProto::kJoinFieldNumber;
const int LineRuleProto::kCapFieldNumber;
#endif  // !_MSC_VER

LineRuleProto::LineRuleProto()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:LineRuleProto)
}

void LineRuleProto::InitAsDefaultInstance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  dashdot_ = const_cast< ::DashDotProto*>(
      ::DashDotProto::internal_default_instance());
#else
  dashdot_ = const_cast< ::DashDotProto*>(&::DashDotProto::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  pathsym_ = const_cast< ::PathSymProto*>(
      ::PathSymProto::internal_default_instance());
#else
  pathsym_ = const_cast< ::PathSymProto*>(&::PathSymProto::default_instance());
#endif
}

LineRuleProto::LineRuleProto(const LineRuleProto& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:LineRuleProto)
}

void LineRuleProto::SharedCtor() {
  _cached_size_ = 0;
  width_ = 0;
  color_ = 0u;
  dashdot_ = NULL;
  priority_ = 0;
  pathsym_ = NULL;
  join_ = 0;
  cap_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

LineRuleProto::~LineRuleProto() {
  // @@protoc_insertion_point(destructor:LineRuleProto)
  SharedDtor();
}

void LineRuleProto::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
    delete dashdot_;
    delete pathsym_;
  }
}

void LineRuleProto::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const LineRuleProto& LineRuleProto::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_drules_5fstruct_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto();
#endif
  return *default_instance_;
}

LineRuleProto* LineRuleProto::default_instance_ = NULL;

LineRuleProto* LineRuleProto::New() const {
  return new LineRuleProto;
}

void LineRuleProto::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<LineRuleProto*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 127) {
    ZR_(color_, priority_);
    ZR_(join_, cap_);
    width_ = 0;
    if (has_dashdot()) {
      if (dashdot_ != NULL) dashdot_->::DashDotProto::Clear();
    }
    if (has_pathsym()) {
      if (pathsym_ != NULL) pathsym_->::PathSymProto::Clear();
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool LineRuleProto::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:LineRuleProto)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required double width = 1;
      case 1: {
        if (tag == 9) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &width_)));
          set_has_width();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_color;
        break;
      }

      // required uint32 color = 2;
      case 2: {
        if (tag == 16) {
         parse_color:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &color_)));
          set_has_color();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_dashdot;
        break;
      }

      // optional .DashDotProto dashdot = 3;
      case 3: {
        if (tag == 26) {
         parse_dashdot:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_dashdot()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_priority;
        break;
      }

      // required int32 priority = 4;
      case 4: {
        if (tag == 32) {
         parse_priority:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &priority_)));
          set_has_priority();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(42)) goto parse_pathsym;
        break;
      }

      // optional .PathSymProto pathsym = 5;
      case 5: {
        if (tag == 42) {
         parse_pathsym:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_pathsym()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(48)) goto parse_join;
        break;
      }

      // optional .LineJoin join = 6;
      case 6: {
        if (tag == 48) {
         parse_join:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::LineJoin_IsValid(value)) {
            set_join(static_cast< ::LineJoin >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(56)) goto parse_cap;
        break;
      }

      // optional .LineCap cap = 7;
      case 7: {
        if (tag == 56) {
         parse_cap:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::LineCap_IsValid(value)) {
            set_cap(static_cast< ::LineCap >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:LineRuleProto)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:LineRuleProto)
  return false;
#undef DO_
}

void LineRuleProto::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:LineRuleProto)
  // required double width = 1;
  if (has_width()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(1, this->width(), output);
  }

  // required uint32 color = 2;
  if (has_color()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->color(), output);
  }

  // optional .DashDotProto dashdot = 3;
  if (has_dashdot()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      3, this->dashdot(), output);
  }

  // required int32 priority = 4;
  if (has_priority()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->priority(), output);
  }

  // optional .PathSymProto pathsym = 5;
  if (has_pathsym()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      5, this->pathsym(), output);
  }

  // optional .LineJoin join = 6;
  if (has_join()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      6, this->join(), output);
  }

  // optional .LineCap cap = 7;
  if (has_cap()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      7, this->cap(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:LineRuleProto)
}

int LineRuleProto::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required double width = 1;
    if (has_width()) {
      total_size += 1 + 8;
    }

    // required uint32 color = 2;
    if (has_color()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->color());
    }

    // optional .DashDotProto dashdot = 3;
    if (has_dashdot()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->dashdot());
    }

    // required int32 priority = 4;
    if (has_priority()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->priority());
    }

    // optional .PathSymProto pathsym = 5;
    if (has_pathsym()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->pathsym());
    }

    // optional .LineJoin join = 6;
    if (has_join()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->join());
    }

    // optional .LineCap cap = 7;
    if (has_cap()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->cap());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void LineRuleProto::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const LineRuleProto*>(&from));
}

void LineRuleProto::MergeFrom(const LineRuleProto& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_width()) {
      set_width(from.width());
    }
    if (from.has_color()) {
      set_color(from.color());
    }
    if (from.has_dashdot()) {
      mutable_dashdot()->::DashDotProto::MergeFrom(from.dashdot());
    }
    if (from.has_priority()) {
      set_priority(from.priority());
    }
    if (from.has_pathsym()) {
      mutable_pathsym()->::PathSymProto::MergeFrom(from.pathsym());
    }
    if (from.has_join()) {
      set_join(from.join());
    }
    if (from.has_cap()) {
      set_cap(from.cap());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void LineRuleProto::CopyFrom(const LineRuleProto& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool LineRuleProto::IsInitialized() const {
  if ((_has_bits_[0] & 0x0000000b) != 0x0000000b) return false;

  if (has_pathsym()) {
    if (!this->pathsym().IsInitialized()) return false;
  }
  return true;
}

void LineRuleProto::Swap(LineRuleProto* other) {
  if (other != this) {
    std::swap(width_, other->width_);
    std::swap(color_, other->color_);
    std::swap(dashdot_, other->dashdot_);
    std::swap(priority_, other->priority_);
    std::swap(pathsym_, other->pathsym_);
    std::swap(join_, other->join_);
    std::swap(cap_, other->cap_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string LineRuleProto::GetTypeName() const {
  return "LineRuleProto";
}


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

#ifndef _MSC_VER
const int LineDefProto::kWidthFieldNumber;
const int LineDefProto::kColorFieldNumber;
const int LineDefProto::kDashdotFieldNumber;
const int LineDefProto::kPathsymFieldNumber;
const int LineDefProto::kJoinFieldNumber;
const int LineDefProto::kCapFieldNumber;
#endif  // !_MSC_VER

LineDefProto::LineDefProto()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:LineDefProto)
}

void LineDefProto::InitAsDefaultInstance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  dashdot_ = const_cast< ::DashDotProto*>(
      ::DashDotProto::internal_default_instance());
#else
  dashdot_ = const_cast< ::DashDotProto*>(&::DashDotProto::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  pathsym_ = const_cast< ::PathSymProto*>(
      ::PathSymProto::internal_default_instance());
#else
  pathsym_ = const_cast< ::PathSymProto*>(&::PathSymProto::default_instance());
#endif
}

LineDefProto::LineDefProto(const LineDefProto& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:LineDefProto)
}

void LineDefProto::SharedCtor() {
  _cached_size_ = 0;
  width_ = 0;
  color_ = 0u;
  dashdot_ = NULL;
  pathsym_ = NULL;
  join_ = 0;
  cap_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

LineDefProto::~LineDefProto() {
  // @@protoc_insertion_point(destructor:LineDefProto)
  SharedDtor();
}

void LineDefProto::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
    delete dashdot_;
    delete pathsym_;
  }
}

void LineDefProto::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const LineDefProto& LineDefProto::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_drules_5fstruct_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto();
#endif
  return *default_instance_;
}

LineDefProto* LineDefProto::default_instance_ = NULL;

LineDefProto* LineDefProto::New() const {
  return new LineDefProto;
}

void LineDefProto::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<LineDefProto*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 63) {
    ZR_(color_, join_);
    width_ = 0;
    if (has_dashdot()) {
      if (dashdot_ != NULL) dashdot_->::DashDotProto::Clear();
    }
    if (has_pathsym()) {
      if (pathsym_ != NULL) pathsym_->::PathSymProto::Clear();
    }
    cap_ = 0;
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool LineDefProto::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:LineDefProto)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required double width = 1;
      case 1: {
        if (tag == 9) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &width_)));
          set_has_width();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_color;
        break;
      }

      // required uint32 color = 2;
      case 2: {
        if (tag == 16) {
         parse_color:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &color_)));
          set_has_color();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_dashdot;
        break;
      }

      // optional .DashDotProto dashdot = 3;
      case 3: {
        if (tag == 26) {
         parse_dashdot:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_dashdot()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(34)) goto parse_pathsym;
        break;
      }

      // optional .PathSymProto pathsym = 4;
      case 4: {
        if (tag == 34) {
         parse_pathsym:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_pathsym()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(48)) goto parse_join;
        break;
      }

      // optional .LineJoin join = 6;
      case 6: {
        if (tag == 48) {
         parse_join:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::LineJoin_IsValid(value)) {
            set_join(static_cast< ::LineJoin >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(56)) goto parse_cap;
        break;
      }

      // optional .LineCap cap = 7;
      case 7: {
        if (tag == 56) {
         parse_cap:
          int value;
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
                 input, &value)));
          if (::LineCap_IsValid(value)) {
            set_cap(static_cast< ::LineCap >(value));
          } else {
            unknown_fields_stream.WriteVarint32(tag);
            unknown_fields_stream.WriteVarint32(value);
          }
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:LineDefProto)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:LineDefProto)
  return false;
#undef DO_
}

void LineDefProto::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:LineDefProto)
  // required double width = 1;
  if (has_width()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(1, this->width(), output);
  }

  // required uint32 color = 2;
  if (has_color()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->color(), output);
  }

  // optional .DashDotProto dashdot = 3;
  if (has_dashdot()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      3, this->dashdot(), output);
  }

  // optional .PathSymProto pathsym = 4;
  if (has_pathsym()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      4, this->pathsym(), output);
  }

  // optional .LineJoin join = 6;
  if (has_join()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      6, this->join(), output);
  }

  // optional .LineCap cap = 7;
  if (has_cap()) {
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
      7, this->cap(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:LineDefProto)
}

int LineDefProto::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required double width = 1;
    if (has_width()) {
      total_size += 1 + 8;
    }

    // required uint32 color = 2;
    if (has_color()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->color());
    }

    // optional .DashDotProto dashdot = 3;
    if (has_dashdot()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->dashdot());
    }

    // optional .PathSymProto pathsym = 4;
    if (has_pathsym()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->pathsym());
    }

    // optional .LineJoin join = 6;
    if (has_join()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->join());
    }

    // optional .LineCap cap = 7;
    if (has_cap()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->cap());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void LineDefProto::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const LineDefProto*>(&from));
}

void LineDefProto::MergeFrom(const LineDefProto& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_width()) {
      set_width(from.width());
    }
    if (from.has_color()) {
      set_color(from.color());
    }
    if (from.has_dashdot()) {
      mutable_dashdot()->::DashDotProto::MergeFrom(from.dashdot());
    }
    if (from.has_pathsym()) {
      mutable_pathsym()->::PathSymProto::MergeFrom(from.pathsym());
    }
    if (from.has_join()) {
      set_join(from.join());
    }
    if (from.has_cap()) {
      set_cap(from.cap());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void LineDefProto::CopyFrom(const LineDefProto& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool LineDefProto::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  if (has_pathsym()) {
    if (!this->pathsym().IsInitialized()) return false;
  }
  return true;
}

void LineDefProto::Swap(LineDefProto* other) {
  if (other != this) {
    std::swap(width_, other->width_);
    std::swap(color_, other->color_);
    std::swap(dashdot_, other->dashdot_);
    std::swap(pathsym_, other->pathsym_);
    std::swap(join_, other->join_);
    std::swap(cap_, other->cap_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string LineDefProto::GetTypeName() const {
  return "LineDefProto";
}


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

#ifndef _MSC_VER
const int AreaRuleProto::kColorFieldNumber;
const int AreaRuleProto::kBorderFieldNumber;
const int AreaRuleProto::kPriorityFieldNumber;
#endif  // !_MSC_VER

AreaRuleProto::AreaRuleProto()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:AreaRuleProto)
}

void AreaRuleProto::InitAsDefaultInstance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  border_ = const_cast< ::LineDefProto*>(
      ::LineDefProto::internal_default_instance());
#else
  border_ = const_cast< ::LineDefProto*>(&::LineDefProto::default_instance());
#endif
}

AreaRuleProto::AreaRuleProto(const AreaRuleProto& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:AreaRuleProto)
}

void AreaRuleProto::SharedCtor() {
  _cached_size_ = 0;
  color_ = 0u;
  border_ = NULL;
  priority_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

AreaRuleProto::~AreaRuleProto() {
  // @@protoc_insertion_point(destructor:AreaRuleProto)
  SharedDtor();
}

void AreaRuleProto::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
    delete border_;
  }
}

void AreaRuleProto::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const AreaRuleProto& AreaRuleProto::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_drules_5fstruct_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto();
#endif
  return *default_instance_;
}

AreaRuleProto* AreaRuleProto::default_instance_ = NULL;

AreaRuleProto* AreaRuleProto::New() const {
  return new AreaRuleProto;
}

void AreaRuleProto::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<AreaRuleProto*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 7) {
    ZR_(color_, priority_);
    if (has_border()) {
      if (border_ != NULL) border_->::LineDefProto::Clear();
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool AreaRuleProto::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:AreaRuleProto)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 color = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &color_)));
          set_has_color();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_border;
        break;
      }

      // optional .LineDefProto border = 2;
      case 2: {
        if (tag == 18) {
         parse_border:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_border()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_priority;
        break;
      }

      // required int32 priority = 3;
      case 3: {
        if (tag == 24) {
         parse_priority:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &priority_)));
          set_has_priority();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:AreaRuleProto)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:AreaRuleProto)
  return false;
#undef DO_
}

void AreaRuleProto::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:AreaRuleProto)
  // required uint32 color = 1;
  if (has_color()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->color(), output);
  }

  // optional .LineDefProto border = 2;
  if (has_border()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      2, this->border(), output);
  }

  // required int32 priority = 3;
  if (has_priority()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->priority(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:AreaRuleProto)
}

int AreaRuleProto::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required uint32 color = 1;
    if (has_color()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->color());
    }

    // optional .LineDefProto border = 2;
    if (has_border()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->border());
    }

    // required int32 priority = 3;
    if (has_priority()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->priority());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void AreaRuleProto::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const AreaRuleProto*>(&from));
}

void AreaRuleProto::MergeFrom(const AreaRuleProto& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_color()) {
      set_color(from.color());
    }
    if (from.has_border()) {
      mutable_border()->::LineDefProto::MergeFrom(from.border());
    }
    if (from.has_priority()) {
      set_priority(from.priority());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void AreaRuleProto::CopyFrom(const AreaRuleProto& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool AreaRuleProto::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000005) != 0x00000005) return false;

  if (has_border()) {
    if (!this->border().IsInitialized()) return false;
  }
  return true;
}

void AreaRuleProto::Swap(AreaRuleProto* other) {
  if (other != this) {
    std::swap(color_, other->color_);
    std::swap(border_, other->border_);
    std::swap(priority_, other->priority_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string AreaRuleProto::GetTypeName() const {
  return "AreaRuleProto";
}


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

#ifndef _MSC_VER
const int SymbolRuleProto::kNameFieldNumber;
const int SymbolRuleProto::kApplyForTypeFieldNumber;
const int SymbolRuleProto::kPriorityFieldNumber;
const int SymbolRuleProto::kMinDistanceFieldNumber;
#endif  // !_MSC_VER

SymbolRuleProto::SymbolRuleProto()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:SymbolRuleProto)
}

void SymbolRuleProto::InitAsDefaultInstance() {
}

SymbolRuleProto::SymbolRuleProto(const SymbolRuleProto& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:SymbolRuleProto)
}

void SymbolRuleProto::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  apply_for_type_ = 0;
  priority_ = 0;
  min_distance_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

SymbolRuleProto::~SymbolRuleProto() {
  // @@protoc_insertion_point(destructor:SymbolRuleProto)
  SharedDtor();
}

void SymbolRuleProto::SharedDtor() {
  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete name_;
  }
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void SymbolRuleProto::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const SymbolRuleProto& SymbolRuleProto::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_drules_5fstruct_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto();
#endif
  return *default_instance_;
}

SymbolRuleProto* SymbolRuleProto::default_instance_ = NULL;

SymbolRuleProto* SymbolRuleProto::New() const {
  return new SymbolRuleProto;
}

void SymbolRuleProto::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<SymbolRuleProto*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 15) {
    ZR_(apply_for_type_, min_distance_);
    if (has_name()) {
      if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        name_->clear();
      }
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool SymbolRuleProto::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:SymbolRuleProto)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required string name = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_apply_for_type;
        break;
      }

      // optional int32 apply_for_type = 2;
      case 2: {
        if (tag == 16) {
         parse_apply_for_type:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &apply_for_type_)));
          set_has_apply_for_type();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_priority;
        break;
      }

      // required int32 priority = 3;
      case 3: {
        if (tag == 24) {
         parse_priority:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &priority_)));
          set_has_priority();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_min_distance;
        break;
      }

      // optional int32 min_distance = 4;
      case 4: {
        if (tag == 32) {
         parse_min_distance:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &min_distance_)));
          set_has_min_distance();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:SymbolRuleProto)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:SymbolRuleProto)
  return false;
#undef DO_
}

void SymbolRuleProto::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:SymbolRuleProto)
  // required string name = 1;
  if (has_name()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->name(), output);
  }

  // optional int32 apply_for_type = 2;
  if (has_apply_for_type()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->apply_for_type(), output);
  }

  // required int32 priority = 3;
  if (has_priority()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->priority(), output);
  }

  // optional int32 min_distance = 4;
  if (has_min_distance()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->min_distance(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:SymbolRuleProto)
}

int SymbolRuleProto::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required string name = 1;
    if (has_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->name());
    }

    // optional int32 apply_for_type = 2;
    if (has_apply_for_type()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->apply_for_type());
    }

    // required int32 priority = 3;
    if (has_priority()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->priority());
    }

    // optional int32 min_distance = 4;
    if (has_min_distance()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->min_distance());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void SymbolRuleProto::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const SymbolRuleProto*>(&from));
}

void SymbolRuleProto::MergeFrom(const SymbolRuleProto& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_name()) {
      set_name(from.name());
    }
    if (from.has_apply_for_type()) {
      set_apply_for_type(from.apply_for_type());
    }
    if (from.has_priority()) {
      set_priority(from.priority());
    }
    if (from.has_min_distance()) {
      set_min_distance(from.min_distance());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void SymbolRuleProto::CopyFrom(const SymbolRuleProto& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool SymbolRuleProto::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000005) != 0x00000005) return false;

  return true;
}

void SymbolRuleProto::Swap(SymbolRuleProto* other) {
  if (other != this) {
    std::swap(name_, other->name_);
    std::swap(apply_for_type_, other->apply_for_type_);
    std::swap(priority_, other->priority_);
    std::swap(min_distance_, other->min_distance_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string SymbolRuleProto::GetTypeName() const {
  return "SymbolRuleProto";
}


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

#ifndef _MSC_VER
const int CaptionDefProto::kHeightFieldNumber;
const int CaptionDefProto::kColorFieldNumber;
const int CaptionDefProto::kStrokeColorFieldNumber;
const int CaptionDefProto::kOffsetXFieldNumber;
const int CaptionDefProto::kOffsetYFieldNumber;
const int CaptionDefProto::kTextFieldNumber;
const int CaptionDefProto::kIsOptionalFieldNumber;
#endif  // !_MSC_VER

CaptionDefProto::CaptionDefProto()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CaptionDefProto)
}

void CaptionDefProto::InitAsDefaultInstance() {
}

CaptionDefProto::CaptionDefProto(const CaptionDefProto& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CaptionDefProto)
}

void CaptionDefProto::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  height_ = 0;
  color_ = 0u;
  stroke_color_ = 0u;
  offset_x_ = 0;
  offset_y_ = 0;
  text_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  is_optional_ = false;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CaptionDefProto::~CaptionDefProto() {
  // @@protoc_insertion_point(destructor:CaptionDefProto)
  SharedDtor();
}

void CaptionDefProto::SharedDtor() {
  if (text_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete text_;
  }
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void CaptionDefProto::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const CaptionDefProto& CaptionDefProto::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_drules_5fstruct_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto();
#endif
  return *default_instance_;
}

CaptionDefProto* CaptionDefProto::default_instance_ = NULL;

CaptionDefProto* CaptionDefProto::New() const {
  return new CaptionDefProto;
}

void CaptionDefProto::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<CaptionDefProto*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 127) {
    ZR_(height_, offset_x_);
    ZR_(offset_y_, is_optional_);
    if (has_text()) {
      if (text_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        text_->clear();
      }
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool CaptionDefProto::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:CaptionDefProto)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required int32 height = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &height_)));
          set_has_height();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_color;
        break;
      }

      // required uint32 color = 2;
      case 2: {
        if (tag == 16) {
         parse_color:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &color_)));
          set_has_color();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_stroke_color;
        break;
      }

      // optional uint32 stroke_color = 3;
      case 3: {
        if (tag == 24) {
         parse_stroke_color:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &stroke_color_)));
          set_has_stroke_color();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_offset_x;
        break;
      }

      // optional int32 offset_x = 4;
      case 4: {
        if (tag == 32) {
         parse_offset_x:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &offset_x_)));
          set_has_offset_x();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(40)) goto parse_offset_y;
        break;
      }

      // optional int32 offset_y = 5;
      case 5: {
        if (tag == 40) {
         parse_offset_y:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &offset_y_)));
          set_has_offset_y();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(50)) goto parse_text;
        break;
      }

      // optional string text = 6;
      case 6: {
        if (tag == 50) {
         parse_text:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_text()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(56)) goto parse_is_optional;
        break;
      }

      // optional bool is_optional = 7;
      case 7: {
        if (tag == 56) {
         parse_is_optional:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &is_optional_)));
          set_has_is_optional();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:CaptionDefProto)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:CaptionDefProto)
  return false;
#undef DO_
}

void CaptionDefProto::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CaptionDefProto)
  // required int32 height = 1;
  if (has_height()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->height(), output);
  }

  // required uint32 color = 2;
  if (has_color()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->color(), output);
  }

  // optional uint32 stroke_color = 3;
  if (has_stroke_color()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->stroke_color(), output);
  }

  // optional int32 offset_x = 4;
  if (has_offset_x()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->offset_x(), output);
  }

  // optional int32 offset_y = 5;
  if (has_offset_y()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->offset_y(), output);
  }

  // optional string text = 6;
  if (has_text()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      6, this->text(), output);
  }

  // optional bool is_optional = 7;
  if (has_is_optional()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(7, this->is_optional(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:CaptionDefProto)
}

int CaptionDefProto::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required int32 height = 1;
    if (has_height()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->height());
    }

    // required uint32 color = 2;
    if (has_color()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->color());
    }

    // optional uint32 stroke_color = 3;
    if (has_stroke_color()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->stroke_color());
    }

    // optional int32 offset_x = 4;
    if (has_offset_x()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->offset_x());
    }

    // optional int32 offset_y = 5;
    if (has_offset_y()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->offset_y());
    }

    // optional string text = 6;
    if (has_text()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->text());
    }

    // optional bool is_optional = 7;
    if (has_is_optional()) {
      total_size += 1 + 1;
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void CaptionDefProto::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const CaptionDefProto*>(&from));
}

void CaptionDefProto::MergeFrom(const CaptionDefProto& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_height()) {
      set_height(from.height());
    }
    if (from.has_color()) {
      set_color(from.color());
    }
    if (from.has_stroke_color()) {
      set_stroke_color(from.stroke_color());
    }
    if (from.has_offset_x()) {
      set_offset_x(from.offset_x());
    }
    if (from.has_offset_y()) {
      set_offset_y(from.offset_y());
    }
    if (from.has_text()) {
      set_text(from.text());
    }
    if (from.has_is_optional()) {
      set_is_optional(from.is_optional());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void CaptionDefProto::CopyFrom(const CaptionDefProto& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CaptionDefProto::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void CaptionDefProto::Swap(CaptionDefProto* other) {
  if (other != this) {
    std::swap(height_, other->height_);
    std::swap(color_, other->color_);
    std::swap(stroke_color_, other->stroke_color_);
    std::swap(offset_x_, other->offset_x_);
    std::swap(offset_y_, other->offset_y_);
    std::swap(text_, other->text_);
    std::swap(is_optional_, other->is_optional_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string CaptionDefProto::GetTypeName() const {
  return "CaptionDefProto";
}


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

#ifndef _MSC_VER
const int CaptionRuleProto::kPrimaryFieldNumber;
const int CaptionRuleProto::kSecondaryFieldNumber;
const int CaptionRuleProto::kPriorityFieldNumber;
#endif  // !_MSC_VER

CaptionRuleProto::CaptionRuleProto()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CaptionRuleProto)
}

void CaptionRuleProto::InitAsDefaultInstance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  primary_ = const_cast< ::CaptionDefProto*>(
      ::CaptionDefProto::internal_default_instance());
#else
  primary_ = const_cast< ::CaptionDefProto*>(&::CaptionDefProto::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  secondary_ = const_cast< ::CaptionDefProto*>(
      ::CaptionDefProto::internal_default_instance());
#else
  secondary_ = const_cast< ::CaptionDefProto*>(&::CaptionDefProto::default_instance());
#endif
}

CaptionRuleProto::CaptionRuleProto(const CaptionRuleProto& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CaptionRuleProto)
}

void CaptionRuleProto::SharedCtor() {
  _cached_size_ = 0;
  primary_ = NULL;
  secondary_ = NULL;
  priority_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CaptionRuleProto::~CaptionRuleProto() {
  // @@protoc_insertion_point(destructor:CaptionRuleProto)
  SharedDtor();
}

void CaptionRuleProto::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
    delete primary_;
    delete secondary_;
  }
}

void CaptionRuleProto::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const CaptionRuleProto& CaptionRuleProto::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_drules_5fstruct_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto();
#endif
  return *default_instance_;
}

CaptionRuleProto* CaptionRuleProto::default_instance_ = NULL;

CaptionRuleProto* CaptionRuleProto::New() const {
  return new CaptionRuleProto;
}

void CaptionRuleProto::Clear() {
  if (_has_bits_[0 / 32] & 7) {
    if (has_primary()) {
      if (primary_ != NULL) primary_->::CaptionDefProto::Clear();
    }
    if (has_secondary()) {
      if (secondary_ != NULL) secondary_->::CaptionDefProto::Clear();
    }
    priority_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool CaptionRuleProto::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:CaptionRuleProto)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .CaptionDefProto primary = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_primary()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_secondary;
        break;
      }

      // optional .CaptionDefProto secondary = 2;
      case 2: {
        if (tag == 18) {
         parse_secondary:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_secondary()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_priority;
        break;
      }

      // required int32 priority = 3;
      case 3: {
        if (tag == 24) {
         parse_priority:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &priority_)));
          set_has_priority();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:CaptionRuleProto)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:CaptionRuleProto)
  return false;
#undef DO_
}

void CaptionRuleProto::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CaptionRuleProto)
  // required .CaptionDefProto primary = 1;
  if (has_primary()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      1, this->primary(), output);
  }

  // optional .CaptionDefProto secondary = 2;
  if (has_secondary()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      2, this->secondary(), output);
  }

  // required int32 priority = 3;
  if (has_priority()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->priority(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:CaptionRuleProto)
}

int CaptionRuleProto::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .CaptionDefProto primary = 1;
    if (has_primary()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->primary());
    }

    // optional .CaptionDefProto secondary = 2;
    if (has_secondary()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->secondary());
    }

    // required int32 priority = 3;
    if (has_priority()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->priority());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void CaptionRuleProto::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const CaptionRuleProto*>(&from));
}

void CaptionRuleProto::MergeFrom(const CaptionRuleProto& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_primary()) {
      mutable_primary()->::CaptionDefProto::MergeFrom(from.primary());
    }
    if (from.has_secondary()) {
      mutable_secondary()->::CaptionDefProto::MergeFrom(from.secondary());
    }
    if (from.has_priority()) {
      set_priority(from.priority());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void CaptionRuleProto::CopyFrom(const CaptionRuleProto& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CaptionRuleProto::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000005) != 0x00000005) return false;

  if (has_primary()) {
    if (!this->primary().IsInitialized()) return false;
  }
  if (has_secondary()) {
    if (!this->secondary().IsInitialized()) return false;
  }
  return true;
}

void CaptionRuleProto::Swap(CaptionRuleProto* other) {
  if (other != this) {
    std::swap(primary_, other->primary_);
    std::swap(secondary_, other->secondary_);
    std::swap(priority_, other->priority_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string CaptionRuleProto::GetTypeName() const {
  return "CaptionRuleProto";
}


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

#ifndef _MSC_VER
const int CircleRuleProto::kRadiusFieldNumber;
const int CircleRuleProto::kColorFieldNumber;
const int CircleRuleProto::kBorderFieldNumber;
const int CircleRuleProto::kPriorityFieldNumber;
#endif  // !_MSC_VER

CircleRuleProto::CircleRuleProto()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:CircleRuleProto)
}

void CircleRuleProto::InitAsDefaultInstance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  border_ = const_cast< ::LineDefProto*>(
      ::LineDefProto::internal_default_instance());
#else
  border_ = const_cast< ::LineDefProto*>(&::LineDefProto::default_instance());
#endif
}

CircleRuleProto::CircleRuleProto(const CircleRuleProto& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:CircleRuleProto)
}

void CircleRuleProto::SharedCtor() {
  _cached_size_ = 0;
  radius_ = 0;
  color_ = 0u;
  border_ = NULL;
  priority_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

CircleRuleProto::~CircleRuleProto() {
  // @@protoc_insertion_point(destructor:CircleRuleProto)
  SharedDtor();
}

void CircleRuleProto::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
    delete border_;
  }
}

void CircleRuleProto::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const CircleRuleProto& CircleRuleProto::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_drules_5fstruct_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto();
#endif
  return *default_instance_;
}

CircleRuleProto* CircleRuleProto::default_instance_ = NULL;

CircleRuleProto* CircleRuleProto::New() const {
  return new CircleRuleProto;
}

void CircleRuleProto::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<CircleRuleProto*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 15) {
    ZR_(color_, priority_);
    radius_ = 0;
    if (has_border()) {
      if (border_ != NULL) border_->::LineDefProto::Clear();
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool CircleRuleProto::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:CircleRuleProto)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required double radius = 1;
      case 1: {
        if (tag == 9) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
                 input, &radius_)));
          set_has_radius();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_color;
        break;
      }

      // required uint32 color = 2;
      case 2: {
        if (tag == 16) {
         parse_color:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &color_)));
          set_has_color();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(26)) goto parse_border;
        break;
      }

      // optional .LineDefProto border = 3;
      case 3: {
        if (tag == 26) {
         parse_border:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_border()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_priority;
        break;
      }

      // required int32 priority = 4;
      case 4: {
        if (tag == 32) {
         parse_priority:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &priority_)));
          set_has_priority();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:CircleRuleProto)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:CircleRuleProto)
  return false;
#undef DO_
}

void CircleRuleProto::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:CircleRuleProto)
  // required double radius = 1;
  if (has_radius()) {
    ::google::protobuf::internal::WireFormatLite::WriteDouble(1, this->radius(), output);
  }

  // required uint32 color = 2;
  if (has_color()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->color(), output);
  }

  // optional .LineDefProto border = 3;
  if (has_border()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      3, this->border(), output);
  }

  // required int32 priority = 4;
  if (has_priority()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->priority(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:CircleRuleProto)
}

int CircleRuleProto::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required double radius = 1;
    if (has_radius()) {
      total_size += 1 + 8;
    }

    // required uint32 color = 2;
    if (has_color()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->color());
    }

    // optional .LineDefProto border = 3;
    if (has_border()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->border());
    }

    // required int32 priority = 4;
    if (has_priority()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->priority());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void CircleRuleProto::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const CircleRuleProto*>(&from));
}

void CircleRuleProto::MergeFrom(const CircleRuleProto& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_radius()) {
      set_radius(from.radius());
    }
    if (from.has_color()) {
      set_color(from.color());
    }
    if (from.has_border()) {
      mutable_border()->::LineDefProto::MergeFrom(from.border());
    }
    if (from.has_priority()) {
      set_priority(from.priority());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void CircleRuleProto::CopyFrom(const CircleRuleProto& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool CircleRuleProto::IsInitialized() const {
  if ((_has_bits_[0] & 0x0000000b) != 0x0000000b) return false;

  if (has_border()) {
    if (!this->border().IsInitialized()) return false;
  }
  return true;
}

void CircleRuleProto::Swap(CircleRuleProto* other) {
  if (other != this) {
    std::swap(radius_, other->radius_);
    std::swap(color_, other->color_);
    std::swap(border_, other->border_);
    std::swap(priority_, other->priority_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string CircleRuleProto::GetTypeName() const {
  return "CircleRuleProto";
}


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

#ifndef _MSC_VER
const int PathTextRuleProto::kPrimaryFieldNumber;
const int PathTextRuleProto::kSecondaryFieldNumber;
const int PathTextRuleProto::kPriorityFieldNumber;
#endif  // !_MSC_VER

PathTextRuleProto::PathTextRuleProto()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:PathTextRuleProto)
}

void PathTextRuleProto::InitAsDefaultInstance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  primary_ = const_cast< ::CaptionDefProto*>(
      ::CaptionDefProto::internal_default_instance());
#else
  primary_ = const_cast< ::CaptionDefProto*>(&::CaptionDefProto::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  secondary_ = const_cast< ::CaptionDefProto*>(
      ::CaptionDefProto::internal_default_instance());
#else
  secondary_ = const_cast< ::CaptionDefProto*>(&::CaptionDefProto::default_instance());
#endif
}

PathTextRuleProto::PathTextRuleProto(const PathTextRuleProto& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:PathTextRuleProto)
}

void PathTextRuleProto::SharedCtor() {
  _cached_size_ = 0;
  primary_ = NULL;
  secondary_ = NULL;
  priority_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

PathTextRuleProto::~PathTextRuleProto() {
  // @@protoc_insertion_point(destructor:PathTextRuleProto)
  SharedDtor();
}

void PathTextRuleProto::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
    delete primary_;
    delete secondary_;
  }
}

void PathTextRuleProto::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const PathTextRuleProto& PathTextRuleProto::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_drules_5fstruct_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto();
#endif
  return *default_instance_;
}

PathTextRuleProto* PathTextRuleProto::default_instance_ = NULL;

PathTextRuleProto* PathTextRuleProto::New() const {
  return new PathTextRuleProto;
}

void PathTextRuleProto::Clear() {
  if (_has_bits_[0 / 32] & 7) {
    if (has_primary()) {
      if (primary_ != NULL) primary_->::CaptionDefProto::Clear();
    }
    if (has_secondary()) {
      if (secondary_ != NULL) secondary_->::CaptionDefProto::Clear();
    }
    priority_ = 0;
  }
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool PathTextRuleProto::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:PathTextRuleProto)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required .CaptionDefProto primary = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_primary()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_secondary;
        break;
      }

      // optional .CaptionDefProto secondary = 2;
      case 2: {
        if (tag == 18) {
         parse_secondary:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_secondary()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_priority;
        break;
      }

      // required int32 priority = 3;
      case 3: {
        if (tag == 24) {
         parse_priority:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &priority_)));
          set_has_priority();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:PathTextRuleProto)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:PathTextRuleProto)
  return false;
#undef DO_
}

void PathTextRuleProto::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:PathTextRuleProto)
  // required .CaptionDefProto primary = 1;
  if (has_primary()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      1, this->primary(), output);
  }

  // optional .CaptionDefProto secondary = 2;
  if (has_secondary()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      2, this->secondary(), output);
  }

  // required int32 priority = 3;
  if (has_priority()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->priority(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:PathTextRuleProto)
}

int PathTextRuleProto::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required .CaptionDefProto primary = 1;
    if (has_primary()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->primary());
    }

    // optional .CaptionDefProto secondary = 2;
    if (has_secondary()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->secondary());
    }

    // required int32 priority = 3;
    if (has_priority()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->priority());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void PathTextRuleProto::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const PathTextRuleProto*>(&from));
}

void PathTextRuleProto::MergeFrom(const PathTextRuleProto& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_primary()) {
      mutable_primary()->::CaptionDefProto::MergeFrom(from.primary());
    }
    if (from.has_secondary()) {
      mutable_secondary()->::CaptionDefProto::MergeFrom(from.secondary());
    }
    if (from.has_priority()) {
      set_priority(from.priority());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void PathTextRuleProto::CopyFrom(const PathTextRuleProto& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PathTextRuleProto::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000005) != 0x00000005) return false;

  if (has_primary()) {
    if (!this->primary().IsInitialized()) return false;
  }
  if (has_secondary()) {
    if (!this->secondary().IsInitialized()) return false;
  }
  return true;
}

void PathTextRuleProto::Swap(PathTextRuleProto* other) {
  if (other != this) {
    std::swap(primary_, other->primary_);
    std::swap(secondary_, other->secondary_);
    std::swap(priority_, other->priority_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string PathTextRuleProto::GetTypeName() const {
  return "PathTextRuleProto";
}


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

#ifndef _MSC_VER
const int ShieldRuleProto::kHeightFieldNumber;
const int ShieldRuleProto::kColorFieldNumber;
const int ShieldRuleProto::kStrokeColorFieldNumber;
const int ShieldRuleProto::kPriorityFieldNumber;
const int ShieldRuleProto::kMinDistanceFieldNumber;
const int ShieldRuleProto::kTextColorFieldNumber;
const int ShieldRuleProto::kTextStrokeColorFieldNumber;
#endif  // !_MSC_VER

ShieldRuleProto::ShieldRuleProto()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:ShieldRuleProto)
}

void ShieldRuleProto::InitAsDefaultInstance() {
}

ShieldRuleProto::ShieldRuleProto(const ShieldRuleProto& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:ShieldRuleProto)
}

void ShieldRuleProto::SharedCtor() {
  _cached_size_ = 0;
  height_ = 0;
  color_ = 0u;
  stroke_color_ = 0u;
  priority_ = 0;
  min_distance_ = 0;
  text_color_ = 0u;
  text_stroke_color_ = 0u;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ShieldRuleProto::~ShieldRuleProto() {
  // @@protoc_insertion_point(destructor:ShieldRuleProto)
  SharedDtor();
}

void ShieldRuleProto::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void ShieldRuleProto::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ShieldRuleProto& ShieldRuleProto::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_drules_5fstruct_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto();
#endif
  return *default_instance_;
}

ShieldRuleProto* ShieldRuleProto::default_instance_ = NULL;

ShieldRuleProto* ShieldRuleProto::New() const {
  return new ShieldRuleProto;
}

void ShieldRuleProto::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<ShieldRuleProto*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 127) {
    ZR_(height_, text_stroke_color_);
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool ShieldRuleProto::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:ShieldRuleProto)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required int32 height = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &height_)));
          set_has_height();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_color;
        break;
      }

      // required uint32 color = 2;
      case 2: {
        if (tag == 16) {
         parse_color:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &color_)));
          set_has_color();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(24)) goto parse_stroke_color;
        break;
      }

      // optional uint32 stroke_color = 3;
      case 3: {
        if (tag == 24) {
         parse_stroke_color:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &stroke_color_)));
          set_has_stroke_color();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(32)) goto parse_priority;
        break;
      }

      // required int32 priority = 4;
      case 4: {
        if (tag == 32) {
         parse_priority:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &priority_)));
          set_has_priority();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(40)) goto parse_min_distance;
        break;
      }

      // optional int32 min_distance = 5;
      case 5: {
        if (tag == 40) {
         parse_min_distance:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &min_distance_)));
          set_has_min_distance();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(48)) goto parse_text_color;
        break;
      }

      // required uint32 text_color = 6;
      case 6: {
        if (tag == 48) {
         parse_text_color:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &text_color_)));
          set_has_text_color();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(56)) goto parse_text_stroke_color;
        break;
      }

      // optional uint32 text_stroke_color = 7;
      case 7: {
        if (tag == 56) {
         parse_text_stroke_color:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &text_stroke_color_)));
          set_has_text_stroke_color();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:ShieldRuleProto)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:ShieldRuleProto)
  return false;
#undef DO_
}

void ShieldRuleProto::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:ShieldRuleProto)
  // required int32 height = 1;
  if (has_height()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->height(), output);
  }

  // required uint32 color = 2;
  if (has_color()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->color(), output);
  }

  // optional uint32 stroke_color = 3;
  if (has_stroke_color()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->stroke_color(), output);
  }

  // required int32 priority = 4;
  if (has_priority()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->priority(), output);
  }

  // optional int32 min_distance = 5;
  if (has_min_distance()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->min_distance(), output);
  }

  // required uint32 text_color = 6;
  if (has_text_color()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(6, this->text_color(), output);
  }

  // optional uint32 text_stroke_color = 7;
  if (has_text_stroke_color()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(7, this->text_stroke_color(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:ShieldRuleProto)
}

int ShieldRuleProto::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required int32 height = 1;
    if (has_height()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->height());
    }

    // required uint32 color = 2;
    if (has_color()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->color());
    }

    // optional uint32 stroke_color = 3;
    if (has_stroke_color()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->stroke_color());
    }

    // required int32 priority = 4;
    if (has_priority()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->priority());
    }

    // optional int32 min_distance = 5;
    if (has_min_distance()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->min_distance());
    }

    // required uint32 text_color = 6;
    if (has_text_color()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->text_color());
    }

    // optional uint32 text_stroke_color = 7;
    if (has_text_stroke_color()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->text_stroke_color());
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ShieldRuleProto::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const ShieldRuleProto*>(&from));
}

void ShieldRuleProto::MergeFrom(const ShieldRuleProto& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_height()) {
      set_height(from.height());
    }
    if (from.has_color()) {
      set_color(from.color());
    }
    if (from.has_stroke_color()) {
      set_stroke_color(from.stroke_color());
    }
    if (from.has_priority()) {
      set_priority(from.priority());
    }
    if (from.has_min_distance()) {
      set_min_distance(from.min_distance());
    }
    if (from.has_text_color()) {
      set_text_color(from.text_color());
    }
    if (from.has_text_stroke_color()) {
      set_text_stroke_color(from.text_stroke_color());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void ShieldRuleProto::CopyFrom(const ShieldRuleProto& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ShieldRuleProto::IsInitialized() const {
  if ((_has_bits_[0] & 0x0000002b) != 0x0000002b) return false;

  return true;
}

void ShieldRuleProto::Swap(ShieldRuleProto* other) {
  if (other != this) {
    std::swap(height_, other->height_);
    std::swap(color_, other->color_);
    std::swap(stroke_color_, other->stroke_color_);
    std::swap(priority_, other->priority_);
    std::swap(min_distance_, other->min_distance_);
    std::swap(text_color_, other->text_color_);
    std::swap(text_stroke_color_, other->text_stroke_color_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string ShieldRuleProto::GetTypeName() const {
  return "ShieldRuleProto";
}


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

#ifndef _MSC_VER
const int DrawElementProto::kScaleFieldNumber;
const int DrawElementProto::kLinesFieldNumber;
const int DrawElementProto::kAreaFieldNumber;
const int DrawElementProto::kSymbolFieldNumber;
const int DrawElementProto::kCaptionFieldNumber;
const int DrawElementProto::kCircleFieldNumber;
const int DrawElementProto::kPathTextFieldNumber;
const int DrawElementProto::kShieldFieldNumber;
const int DrawElementProto::kApplyIfFieldNumber;
#endif  // !_MSC_VER

DrawElementProto::DrawElementProto()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:DrawElementProto)
}

void DrawElementProto::InitAsDefaultInstance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  area_ = const_cast< ::AreaRuleProto*>(
      ::AreaRuleProto::internal_default_instance());
#else
  area_ = const_cast< ::AreaRuleProto*>(&::AreaRuleProto::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  symbol_ = const_cast< ::SymbolRuleProto*>(
      ::SymbolRuleProto::internal_default_instance());
#else
  symbol_ = const_cast< ::SymbolRuleProto*>(&::SymbolRuleProto::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  caption_ = const_cast< ::CaptionRuleProto*>(
      ::CaptionRuleProto::internal_default_instance());
#else
  caption_ = const_cast< ::CaptionRuleProto*>(&::CaptionRuleProto::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  circle_ = const_cast< ::CircleRuleProto*>(
      ::CircleRuleProto::internal_default_instance());
#else
  circle_ = const_cast< ::CircleRuleProto*>(&::CircleRuleProto::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  path_text_ = const_cast< ::PathTextRuleProto*>(
      ::PathTextRuleProto::internal_default_instance());
#else
  path_text_ = const_cast< ::PathTextRuleProto*>(&::PathTextRuleProto::default_instance());
#endif
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  shield_ = const_cast< ::ShieldRuleProto*>(
      ::ShieldRuleProto::internal_default_instance());
#else
  shield_ = const_cast< ::ShieldRuleProto*>(&::ShieldRuleProto::default_instance());
#endif
}

DrawElementProto::DrawElementProto(const DrawElementProto& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:DrawElementProto)
}

void DrawElementProto::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  scale_ = 0;
  area_ = NULL;
  symbol_ = NULL;
  caption_ = NULL;
  circle_ = NULL;
  path_text_ = NULL;
  shield_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

DrawElementProto::~DrawElementProto() {
  // @@protoc_insertion_point(destructor:DrawElementProto)
  SharedDtor();
}

void DrawElementProto::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
    delete area_;
    delete symbol_;
    delete caption_;
    delete circle_;
    delete path_text_;
    delete shield_;
  }
}

void DrawElementProto::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const DrawElementProto& DrawElementProto::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_drules_5fstruct_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto();
#endif
  return *default_instance_;
}

DrawElementProto* DrawElementProto::default_instance_ = NULL;

DrawElementProto* DrawElementProto::New() const {
  return new DrawElementProto;
}

void DrawElementProto::Clear() {
  if (_has_bits_[0 / 32] & 253) {
    scale_ = 0;
    if (has_area()) {
      if (area_ != NULL) area_->::AreaRuleProto::Clear();
    }
    if (has_symbol()) {
      if (symbol_ != NULL) symbol_->::SymbolRuleProto::Clear();
    }
    if (has_caption()) {
      if (caption_ != NULL) caption_->::CaptionRuleProto::Clear();
    }
    if (has_circle()) {
      if (circle_ != NULL) circle_->::CircleRuleProto::Clear();
    }
    if (has_path_text()) {
      if (path_text_ != NULL) path_text_->::PathTextRuleProto::Clear();
    }
    if (has_shield()) {
      if (shield_ != NULL) shield_->::ShieldRuleProto::Clear();
    }
  }
  lines_.Clear();
  apply_if_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool DrawElementProto::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:DrawElementProto)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required int32 scale = 1;
      case 1: {
        if (tag == 8) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &scale_)));
          set_has_scale();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_lines;
        break;
      }

      // repeated .LineRuleProto lines = 2;
      case 2: {
        if (tag == 18) {
         parse_lines:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_lines()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_lines;
        if (input->ExpectTag(26)) goto parse_area;
        break;
      }

      // optional .AreaRuleProto area = 3;
      case 3: {
        if (tag == 26) {
         parse_area:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_area()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(34)) goto parse_symbol;
        break;
      }

      // optional .SymbolRuleProto symbol = 4;
      case 4: {
        if (tag == 34) {
         parse_symbol:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_symbol()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(42)) goto parse_caption;
        break;
      }

      // optional .CaptionRuleProto caption = 5;
      case 5: {
        if (tag == 42) {
         parse_caption:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_caption()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(50)) goto parse_circle;
        break;
      }

      // optional .CircleRuleProto circle = 6;
      case 6: {
        if (tag == 50) {
         parse_circle:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_circle()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(58)) goto parse_path_text;
        break;
      }

      // optional .PathTextRuleProto path_text = 7;
      case 7: {
        if (tag == 58) {
         parse_path_text:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_path_text()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(66)) goto parse_shield;
        break;
      }

      // optional .ShieldRuleProto shield = 8;
      case 8: {
        if (tag == 66) {
         parse_shield:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_shield()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(74)) goto parse_apply_if;
        break;
      }

      // repeated string apply_if = 9;
      case 9: {
        if (tag == 74) {
         parse_apply_if:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->add_apply_if()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(74)) goto parse_apply_if;
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:DrawElementProto)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:DrawElementProto)
  return false;
#undef DO_
}

void DrawElementProto::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:DrawElementProto)
  // required int32 scale = 1;
  if (has_scale()) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->scale(), output);
  }

  // repeated .LineRuleProto lines = 2;
  for (int i = 0; i < this->lines_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      2, this->lines(i), output);
  }

  // optional .AreaRuleProto area = 3;
  if (has_area()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      3, this->area(), output);
  }

  // optional .SymbolRuleProto symbol = 4;
  if (has_symbol()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      4, this->symbol(), output);
  }

  // optional .CaptionRuleProto caption = 5;
  if (has_caption()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      5, this->caption(), output);
  }

  // optional .CircleRuleProto circle = 6;
  if (has_circle()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      6, this->circle(), output);
  }

  // optional .PathTextRuleProto path_text = 7;
  if (has_path_text()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      7, this->path_text(), output);
  }

  // optional .ShieldRuleProto shield = 8;
  if (has_shield()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      8, this->shield(), output);
  }

  // repeated string apply_if = 9;
  for (int i = 0; i < this->apply_if_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteString(
      9, this->apply_if(i), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:DrawElementProto)
}

int DrawElementProto::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required int32 scale = 1;
    if (has_scale()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->scale());
    }

    // optional .AreaRuleProto area = 3;
    if (has_area()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->area());
    }

    // optional .SymbolRuleProto symbol = 4;
    if (has_symbol()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->symbol());
    }

    // optional .CaptionRuleProto caption = 5;
    if (has_caption()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->caption());
    }

    // optional .CircleRuleProto circle = 6;
    if (has_circle()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->circle());
    }

    // optional .PathTextRuleProto path_text = 7;
    if (has_path_text()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->path_text());
    }

    // optional .ShieldRuleProto shield = 8;
    if (has_shield()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->shield());
    }

  }
  // repeated .LineRuleProto lines = 2;
  total_size += 1 * this->lines_size();
  for (int i = 0; i < this->lines_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->lines(i));
  }

  // repeated string apply_if = 9;
  total_size += 1 * this->apply_if_size();
  for (int i = 0; i < this->apply_if_size(); i++) {
    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
      this->apply_if(i));
  }

  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void DrawElementProto::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const DrawElementProto*>(&from));
}

void DrawElementProto::MergeFrom(const DrawElementProto& from) {
  GOOGLE_CHECK_NE(&from, this);
  lines_.MergeFrom(from.lines_);
  apply_if_.MergeFrom(from.apply_if_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_scale()) {
      set_scale(from.scale());
    }
    if (from.has_area()) {
      mutable_area()->::AreaRuleProto::MergeFrom(from.area());
    }
    if (from.has_symbol()) {
      mutable_symbol()->::SymbolRuleProto::MergeFrom(from.symbol());
    }
    if (from.has_caption()) {
      mutable_caption()->::CaptionRuleProto::MergeFrom(from.caption());
    }
    if (from.has_circle()) {
      mutable_circle()->::CircleRuleProto::MergeFrom(from.circle());
    }
    if (from.has_path_text()) {
      mutable_path_text()->::PathTextRuleProto::MergeFrom(from.path_text());
    }
    if (from.has_shield()) {
      mutable_shield()->::ShieldRuleProto::MergeFrom(from.shield());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void DrawElementProto::CopyFrom(const DrawElementProto& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DrawElementProto::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  if (!::google::protobuf::internal::AllAreInitialized(this->lines())) return false;
  if (has_area()) {
    if (!this->area().IsInitialized()) return false;
  }
  if (has_symbol()) {
    if (!this->symbol().IsInitialized()) return false;
  }
  if (has_caption()) {
    if (!this->caption().IsInitialized()) return false;
  }
  if (has_circle()) {
    if (!this->circle().IsInitialized()) return false;
  }
  if (has_path_text()) {
    if (!this->path_text().IsInitialized()) return false;
  }
  if (has_shield()) {
    if (!this->shield().IsInitialized()) return false;
  }
  return true;
}

void DrawElementProto::Swap(DrawElementProto* other) {
  if (other != this) {
    std::swap(scale_, other->scale_);
    lines_.Swap(&other->lines_);
    std::swap(area_, other->area_);
    std::swap(symbol_, other->symbol_);
    std::swap(caption_, other->caption_);
    std::swap(circle_, other->circle_);
    std::swap(path_text_, other->path_text_);
    std::swap(shield_, other->shield_);
    apply_if_.Swap(&other->apply_if_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string DrawElementProto::GetTypeName() const {
  return "DrawElementProto";
}


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

#ifndef _MSC_VER
const int ClassifElementProto::kNameFieldNumber;
const int ClassifElementProto::kElementFieldNumber;
#endif  // !_MSC_VER

ClassifElementProto::ClassifElementProto()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:ClassifElementProto)
}

void ClassifElementProto::InitAsDefaultInstance() {
}

ClassifElementProto::ClassifElementProto(const ClassifElementProto& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:ClassifElementProto)
}

void ClassifElementProto::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ClassifElementProto::~ClassifElementProto() {
  // @@protoc_insertion_point(destructor:ClassifElementProto)
  SharedDtor();
}

void ClassifElementProto::SharedDtor() {
  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete name_;
  }
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void ClassifElementProto::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ClassifElementProto& ClassifElementProto::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_drules_5fstruct_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto();
#endif
  return *default_instance_;
}

ClassifElementProto* ClassifElementProto::default_instance_ = NULL;

ClassifElementProto* ClassifElementProto::New() const {
  return new ClassifElementProto;
}

void ClassifElementProto::Clear() {
  if (has_name()) {
    if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
      name_->clear();
    }
  }
  element_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool ClassifElementProto::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:ClassifElementProto)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required string name = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_element;
        break;
      }

      // repeated .DrawElementProto element = 2;
      case 2: {
        if (tag == 18) {
         parse_element:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_element()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_element;
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:ClassifElementProto)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:ClassifElementProto)
  return false;
#undef DO_
}

void ClassifElementProto::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:ClassifElementProto)
  // required string name = 1;
  if (has_name()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->name(), output);
  }

  // repeated .DrawElementProto element = 2;
  for (int i = 0; i < this->element_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      2, this->element(i), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:ClassifElementProto)
}

int ClassifElementProto::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required string name = 1;
    if (has_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->name());
    }

  }
  // repeated .DrawElementProto element = 2;
  total_size += 1 * this->element_size();
  for (int i = 0; i < this->element_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->element(i));
  }

  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ClassifElementProto::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const ClassifElementProto*>(&from));
}

void ClassifElementProto::MergeFrom(const ClassifElementProto& from) {
  GOOGLE_CHECK_NE(&from, this);
  element_.MergeFrom(from.element_);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_name()) {
      set_name(from.name());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void ClassifElementProto::CopyFrom(const ClassifElementProto& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ClassifElementProto::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;

  if (!::google::protobuf::internal::AllAreInitialized(this->element())) return false;
  return true;
}

void ClassifElementProto::Swap(ClassifElementProto* other) {
  if (other != this) {
    std::swap(name_, other->name_);
    element_.Swap(&other->element_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string ClassifElementProto::GetTypeName() const {
  return "ClassifElementProto";
}


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

#ifndef _MSC_VER
const int ColorElementProto::kNameFieldNumber;
const int ColorElementProto::kColorFieldNumber;
const int ColorElementProto::kXFieldNumber;
const int ColorElementProto::kYFieldNumber;
#endif  // !_MSC_VER

ColorElementProto::ColorElementProto()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:ColorElementProto)
}

void ColorElementProto::InitAsDefaultInstance() {
}

ColorElementProto::ColorElementProto(const ColorElementProto& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:ColorElementProto)
}

void ColorElementProto::SharedCtor() {
  ::google::protobuf::internal::GetEmptyString();
  _cached_size_ = 0;
  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  color_ = 0u;
  x_ = 0;
  y_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ColorElementProto::~ColorElementProto() {
  // @@protoc_insertion_point(destructor:ColorElementProto)
  SharedDtor();
}

void ColorElementProto::SharedDtor() {
  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete name_;
  }
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void ColorElementProto::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ColorElementProto& ColorElementProto::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_drules_5fstruct_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto();
#endif
  return *default_instance_;
}

ColorElementProto* ColorElementProto::default_instance_ = NULL;

ColorElementProto* ColorElementProto::New() const {
  return new ColorElementProto;
}

void ColorElementProto::Clear() {
#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
  &reinterpret_cast<ColorElementProto*>(16)->f) - \
   reinterpret_cast<char*>(16))

#define ZR_(first, last) do {                              \
    size_t f = OFFSET_OF_FIELD_(first);                    \
    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
    ::memset(&first, 0, n);                                \
  } while (0)

  if (_has_bits_[0 / 32] & 15) {
    ZR_(color_, y_);
    if (has_name()) {
      if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
        name_->clear();
      }
    }
  }

#undef OFFSET_OF_FIELD_
#undef ZR_

  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool ColorElementProto::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:ColorElementProto)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required string name = 1;
      case 1: {
        if (tag == 10) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_name()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(16)) goto parse_color;
        break;
      }

      // required uint32 color = 2;
      case 2: {
        if (tag == 16) {
         parse_color:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &color_)));
          set_has_color();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(29)) goto parse_x;
        break;
      }

      // optional float x = 3;
      case 3: {
        if (tag == 29) {
         parse_x:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &x_)));
          set_has_x();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(37)) goto parse_y;
        break;
      }

      // optional float y = 4;
      case 4: {
        if (tag == 37) {
         parse_y:
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
                 input, &y_)));
          set_has_y();
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:ColorElementProto)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:ColorElementProto)
  return false;
#undef DO_
}

void ColorElementProto::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:ColorElementProto)
  // required string name = 1;
  if (has_name()) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      1, this->name(), output);
  }

  // required uint32 color = 2;
  if (has_color()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->color(), output);
  }

  // optional float x = 3;
  if (has_x()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(3, this->x(), output);
  }

  // optional float y = 4;
  if (has_y()) {
    ::google::protobuf::internal::WireFormatLite::WriteFloat(4, this->y(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:ColorElementProto)
}

int ColorElementProto::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    // required string name = 1;
    if (has_name()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->name());
    }

    // required uint32 color = 2;
    if (has_color()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
          this->color());
    }

    // optional float x = 3;
    if (has_x()) {
      total_size += 1 + 4;
    }

    // optional float y = 4;
    if (has_y()) {
      total_size += 1 + 4;
    }

  }
  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ColorElementProto::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const ColorElementProto*>(&from));
}

void ColorElementProto::MergeFrom(const ColorElementProto& from) {
  GOOGLE_CHECK_NE(&from, this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_name()) {
      set_name(from.name());
    }
    if (from.has_color()) {
      set_color(from.color());
    }
    if (from.has_x()) {
      set_x(from.x());
    }
    if (from.has_y()) {
      set_y(from.y());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void ColorElementProto::CopyFrom(const ColorElementProto& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ColorElementProto::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void ColorElementProto::Swap(ColorElementProto* other) {
  if (other != this) {
    std::swap(name_, other->name_);
    std::swap(color_, other->color_);
    std::swap(x_, other->x_);
    std::swap(y_, other->y_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string ColorElementProto::GetTypeName() const {
  return "ColorElementProto";
}


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

#ifndef _MSC_VER
const int ColorsElementProto::kValueFieldNumber;
#endif  // !_MSC_VER

ColorsElementProto::ColorsElementProto()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:ColorsElementProto)
}

void ColorsElementProto::InitAsDefaultInstance() {
}

ColorsElementProto::ColorsElementProto(const ColorsElementProto& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:ColorsElementProto)
}

void ColorsElementProto::SharedCtor() {
  _cached_size_ = 0;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ColorsElementProto::~ColorsElementProto() {
  // @@protoc_insertion_point(destructor:ColorsElementProto)
  SharedDtor();
}

void ColorsElementProto::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
  }
}

void ColorsElementProto::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ColorsElementProto& ColorsElementProto::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_drules_5fstruct_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto();
#endif
  return *default_instance_;
}

ColorsElementProto* ColorsElementProto::default_instance_ = NULL;

ColorsElementProto* ColorsElementProto::New() const {
  return new ColorsElementProto;
}

void ColorsElementProto::Clear() {
  value_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool ColorsElementProto::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:ColorsElementProto)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated .ColorElementProto value = 1;
      case 1: {
        if (tag == 10) {
         parse_value:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_value()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(10)) goto parse_value;
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:ColorsElementProto)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:ColorsElementProto)
  return false;
#undef DO_
}

void ColorsElementProto::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:ColorsElementProto)
  // repeated .ColorElementProto value = 1;
  for (int i = 0; i < this->value_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      1, this->value(i), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:ColorsElementProto)
}

int ColorsElementProto::ByteSize() const {
  int total_size = 0;

  // repeated .ColorElementProto value = 1;
  total_size += 1 * this->value_size();
  for (int i = 0; i < this->value_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->value(i));
  }

  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ColorsElementProto::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const ColorsElementProto*>(&from));
}

void ColorsElementProto::MergeFrom(const ColorsElementProto& from) {
  GOOGLE_CHECK_NE(&from, this);
  value_.MergeFrom(from.value_);
  mutable_unknown_fields()->append(from.unknown_fields());
}

void ColorsElementProto::CopyFrom(const ColorsElementProto& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ColorsElementProto::IsInitialized() const {

  if (!::google::protobuf::internal::AllAreInitialized(this->value())) return false;
  return true;
}

void ColorsElementProto::Swap(ColorsElementProto* other) {
  if (other != this) {
    value_.Swap(&other->value_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string ColorsElementProto::GetTypeName() const {
  return "ColorsElementProto";
}


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

#ifndef _MSC_VER
const int ContainerProto::kContFieldNumber;
const int ContainerProto::kColorsFieldNumber;
#endif  // !_MSC_VER

ContainerProto::ContainerProto()
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  // @@protoc_insertion_point(constructor:ContainerProto)
}

void ContainerProto::InitAsDefaultInstance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  colors_ = const_cast< ::ColorsElementProto*>(
      ::ColorsElementProto::internal_default_instance());
#else
  colors_ = const_cast< ::ColorsElementProto*>(&::ColorsElementProto::default_instance());
#endif
}

ContainerProto::ContainerProto(const ContainerProto& from)
  : ::google::protobuf::MessageLite() {
  SharedCtor();
  MergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:ContainerProto)
}

void ContainerProto::SharedCtor() {
  _cached_size_ = 0;
  colors_ = NULL;
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
}

ContainerProto::~ContainerProto() {
  // @@protoc_insertion_point(destructor:ContainerProto)
  SharedDtor();
}

void ContainerProto::SharedDtor() {
  #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  if (this != &default_instance()) {
  #else
  if (this != default_instance_) {
  #endif
    delete colors_;
  }
}

void ContainerProto::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ContainerProto& ContainerProto::default_instance() {
#ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
  protobuf_AddDesc_drules_5fstruct_2eproto();
#else
  if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto();
#endif
  return *default_instance_;
}

ContainerProto* ContainerProto::default_instance_ = NULL;

ContainerProto* ContainerProto::New() const {
  return new ContainerProto;
}

void ContainerProto::Clear() {
  if (has_colors()) {
    if (colors_ != NULL) colors_->::ColorsElementProto::Clear();
  }
  cont_.Clear();
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
  mutable_unknown_fields()->clear();
}

bool ContainerProto::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::StringOutputStream unknown_fields_string(
      mutable_unknown_fields());
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string);
  // @@protoc_insertion_point(parse_start:ContainerProto)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated .ClassifElementProto cont = 1;
      case 1: {
        if (tag == 10) {
         parse_cont:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                input, add_cont()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(10)) goto parse_cont;
        if (input->ExpectTag(18)) goto parse_colors;
        break;
      }

      // optional .ColorsElementProto colors = 2;
      case 2: {
        if (tag == 18) {
         parse_colors:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_colors()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:ContainerProto)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:ContainerProto)
  return false;
#undef DO_
}

void ContainerProto::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:ContainerProto)
  // repeated .ClassifElementProto cont = 1;
  for (int i = 0; i < this->cont_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      1, this->cont(i), output);
  }

  // optional .ColorsElementProto colors = 2;
  if (has_colors()) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      2, this->colors(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   unknown_fields().size());
  // @@protoc_insertion_point(serialize_end:ContainerProto)
}

int ContainerProto::ByteSize() const {
  int total_size = 0;

  if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
    // optional .ColorsElementProto colors = 2;
    if (has_colors()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->colors());
    }

  }
  // repeated .ClassifElementProto cont = 1;
  total_size += 1 * this->cont_size();
  for (int i = 0; i < this->cont_size(); i++) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        this->cont(i));
  }

  total_size += unknown_fields().size();

  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = total_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ContainerProto::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const ContainerProto*>(&from));
}

void ContainerProto::MergeFrom(const ContainerProto& from) {
  GOOGLE_CHECK_NE(&from, this);
  cont_.MergeFrom(from.cont_);
  if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
    if (from.has_colors()) {
      mutable_colors()->::ColorsElementProto::MergeFrom(from.colors());
    }
  }
  mutable_unknown_fields()->append(from.unknown_fields());
}

void ContainerProto::CopyFrom(const ContainerProto& from) {
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ContainerProto::IsInitialized() const {

  if (!::google::protobuf::internal::AllAreInitialized(this->cont())) return false;
  if (has_colors()) {
    if (!this->colors().IsInitialized()) return false;
  }
  return true;
}

void ContainerProto::Swap(ContainerProto* other) {
  if (other != this) {
    cont_.Swap(&other->cont_);
    std::swap(colors_, other->colors_);
    std::swap(_has_bits_[0], other->_has_bits_[0]);
    _unknown_fields_.swap(other->_unknown_fields_);
    std::swap(_cached_size_, other->_cached_size_);
  }
}

::std::string ContainerProto::GetTypeName() const {
  return "ContainerProto";
}


// @@protoc_insertion_point(namespace_scope)

// @@protoc_insertion_point(global_scope)