added offset for labels and more linecaps/linejoins

5 files changed, 1986 insertions, 194 deletions

diff --git a/indexer/drules_struct.pb.cc b/indexer/drules_struct.pb.cc
index 3d68a88ccd..0d838d627e 100644
--- a/indexer/drules_struct.pb.cc
+++ b/indexer/drules_struct.pb.cc
@@ -175,10 +175,12 @@ void protobuf_AssignDesc_drules_5fstruct_2eproto() {
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(SymbolRuleProto));
   CaptionDefProto_descriptor_ = file->message_type(6);
-  static const int CaptionDefProto_offsets_[3] = {
+  static const int CaptionDefProto_offsets_[5] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CaptionDefProto, height_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CaptionDefProto, color_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CaptionDefProto, stroke_color_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CaptionDefProto, offset_x_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CaptionDefProto, offset_y_),
   };
   CaptionDefProto_reflection_ =
     new ::google::protobuf::internal::GeneratedMessageReflection(
@@ -390,28 +392,29 @@ void protobuf_AddDesc_drules_5fstruct_2eproto() {
     "\r\n\005color\030\001 \002(\r\022\035\n\006border\030\002 \001(\0132\r.LineDef"
     "Proto\022\020\n\010priority\030\003 \002(\005\"I\n\017SymbolRulePro"
     "to\022\014\n\004name\030\001 \002(\t\022\026\n\016apply_for_type\030\002 \001(\005"
-    "\022\020\n\010priority\030\003 \002(\005\"F\n\017CaptionDefProto\022\016\n"
+    "\022\020\n\010priority\030\003 \002(\005\"j\n\017CaptionDefProto\022\016\n"
     "\006height\030\001 \002(\005\022\r\n\005color\030\002 \002(\r\022\024\n\014stroke_c"
-    "olor\030\003 \001(\r\"l\n\020CaptionRuleProto\022!\n\007primar"
-    "y\030\001 \002(\0132\020.CaptionDefProto\022#\n\tsecondary\030\002"
-    " \001(\0132\020.CaptionDefProto\022\020\n\010priority\030\003 \002(\005"
-    "\"a\n\017CircleRuleProto\022\016\n\006radius\030\001 \002(\001\022\r\n\005c"
-    "olor\030\002 \002(\r\022\035\n\006border\030\003 \001(\0132\r.LineDefProt"
-    "o\022\020\n\010priority\030\004 \002(\005\"m\n\021PathTextRuleProto"
-    "\022!\n\007primary\030\001 \002(\0132\020.CaptionDefProto\022#\n\ts"
-    "econdary\030\002 \001(\0132\020.CaptionDefProto\022\020\n\010prio"
-    "rity\030\003 \002(\005\"\355\001\n\020DrawElementProto\022\r\n\005scale"
-    "\030\001 \002(\005\022\035\n\005lines\030\002 \003(\0132\016.LineRuleProto\022\034\n"
-    "\004area\030\003 \001(\0132\016.AreaRuleProto\022 \n\006symbol\030\004 "
-    "\001(\0132\020.SymbolRuleProto\022\"\n\007caption\030\005 \001(\0132\021"
-    ".CaptionRuleProto\022 \n\006circle\030\006 \001(\0132\020.Circ"
-    "leRuleProto\022%\n\tpath_text\030\007 \001(\0132\022.PathTex"
-    "tRuleProto\"G\n\023ClassifElementProto\022\014\n\004nam"
-    "e\030\001 \002(\t\022\"\n\007element\030\002 \003(\0132\021.DrawElementPr"
-    "oto\"4\n\016ContainerProto\022\"\n\004cont\030\001 \003(\0132\024.Cl"
-    "assifElementProto*(\n\010LineJoin\022\r\n\tROUNDJO"
-    "IN\020\000\022\r\n\tBEVELJOIN\020\001*$\n\007LineCap\022\014\n\010ROUNDC"
-    "AP\020\000\022\013\n\007BUTTCAP\020\001", 1457);
+    "olor\030\003 \001(\r\022\020\n\010offset_x\030\004 \001(\005\022\020\n\010offset_y"
+    "\030\005 \001(\005\"l\n\020CaptionRuleProto\022!\n\007primary\030\001 "
+    "\002(\0132\020.CaptionDefProto\022#\n\tsecondary\030\002 \001(\013"
+    "2\020.CaptionDefProto\022\020\n\010priority\030\003 \002(\005\"a\n\017"
+    "CircleRuleProto\022\016\n\006radius\030\001 \002(\001\022\r\n\005color"
+    "\030\002 \002(\r\022\035\n\006border\030\003 \001(\0132\r.LineDefProto\022\020\n"
+    "\010priority\030\004 \002(\005\"m\n\021PathTextRuleProto\022!\n\007"
+    "primary\030\001 \002(\0132\020.CaptionDefProto\022#\n\tsecon"
+    "dary\030\002 \001(\0132\020.CaptionDefProto\022\020\n\010priority"
+    "\030\003 \002(\005\"\355\001\n\020DrawElementProto\022\r\n\005scale\030\001 \002"
+    "(\005\022\035\n\005lines\030\002 \003(\0132\016.LineRuleProto\022\034\n\004are"
+    "a\030\003 \001(\0132\016.AreaRuleProto\022 \n\006symbol\030\004 \001(\0132"
+    "\020.SymbolRuleProto\022\"\n\007caption\030\005 \001(\0132\021.Cap"
+    "tionRuleProto\022 \n\006circle\030\006 \001(\0132\020.CircleRu"
+    "leProto\022%\n\tpath_text\030\007 \001(\0132\022.PathTextRul"
+    "eProto\"G\n\023ClassifElementProto\022\014\n\004name\030\001 "
+    "\002(\t\022\"\n\007element\030\002 \003(\0132\021.DrawElementProto\""
+    "4\n\016ContainerProto\022\"\n\004cont\030\001 \003(\0132\024.Classi"
+    "fElementProto*4\n\010LineJoin\022\r\n\tROUNDJOIN\020\000"
+    "\022\r\n\tBEVELJOIN\020\001\022\n\n\006NOJOIN\020\002*3\n\007LineCap\022\014"
+    "\n\010ROUNDCAP\020\000\022\013\n\007BUTTCAP\020\001\022\r\n\tSQUARECAP\020\002", 1520);
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
     "drules_struct.proto", &protobuf_RegisterTypes);
   DashDotProto::default_instance_ = new DashDotProto();
@@ -458,6 +461,7 @@ bool LineJoin_IsValid(int value) {
   switch(value) {
     case 0:
     case 1:
+    case 2:
       return true;
     default:
       return false;
@@ -472,6 +476,7 @@ bool LineCap_IsValid(int value) {
   switch(value) {
     case 0:
     case 1:
+    case 2:
       return true;
     default:
       return false;
@@ -2540,6 +2545,8 @@ void SymbolRuleProto::Swap(SymbolRuleProto* other) {
 const int CaptionDefProto::kHeightFieldNumber;
 const int CaptionDefProto::kColorFieldNumber;
 const int CaptionDefProto::kStrokeColorFieldNumber;
+const int CaptionDefProto::kOffsetXFieldNumber;
+const int CaptionDefProto::kOffsetYFieldNumber;
 #endif  // !_MSC_VER
 
 CaptionDefProto::CaptionDefProto()
@@ -2561,6 +2568,8 @@ void CaptionDefProto::SharedCtor() {
   height_ = 0;
   color_ = 0u;
   stroke_color_ = 0u;
+  offset_x_ = 0;
+  offset_y_ = 0;
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
 
@@ -2598,6 +2607,8 @@ void CaptionDefProto::Clear() {
     height_ = 0;
     color_ = 0u;
     stroke_color_ = 0u;
+    offset_x_ = 0;
+    offset_y_ = 0;
   }
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
   mutable_unknown_fields()->Clear();
@@ -2652,6 +2663,38 @@ bool CaptionDefProto::MergePartialFromCodedStream(
         } else {
           goto handle_uninterpreted;
         }
+        if (input->ExpectTag(32)) goto parse_offset_x;
+        break;
+      }
+      
+      // optional int32 offset_x = 4;
+      case 4: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         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_uninterpreted;
+        }
+        if (input->ExpectTag(40)) goto parse_offset_y;
+        break;
+      }
+      
+      // optional int32 offset_y = 5;
+      case 5: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         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_uninterpreted;
+        }
         if (input->ExpectAtEnd()) return true;
         break;
       }
@@ -2689,6 +2732,16 @@ void CaptionDefProto::SerializeWithCachedSizes(
     ::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);
+  }
+  
   if (!unknown_fields().empty()) {
     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
         unknown_fields(), output);
@@ -2712,6 +2765,16 @@ void CaptionDefProto::SerializeWithCachedSizes(
     target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->stroke_color(), target);
   }
   
+  // optional int32 offset_x = 4;
+  if (has_offset_x()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->offset_x(), target);
+  }
+  
+  // optional int32 offset_y = 5;
+  if (has_offset_y()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(5, this->offset_y(), target);
+  }
+  
   if (!unknown_fields().empty()) {
     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
         unknown_fields(), target);
@@ -2744,6 +2807,20 @@ int CaptionDefProto::ByteSize() const {
           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());
+    }
+    
   }
   if (!unknown_fields().empty()) {
     total_size +=
@@ -2780,6 +2857,12 @@ void CaptionDefProto::MergeFrom(const CaptionDefProto& from) {
     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());
+    }
   }
   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
 }
@@ -2807,6 +2890,8 @@ void CaptionDefProto::Swap(CaptionDefProto* other) {
     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(_has_bits_[0], other->_has_bits_[0]);
     _unknown_fields_.Swap(&other->_unknown_fields_);
     std::swap(_cached_size_, other->_cached_size_);
diff --git a/indexer/drules_struct.pb.h b/indexer/drules_struct.pb.h
index 4fed524db7..8e87a63e21 100644
--- a/indexer/drules_struct.pb.h
+++ b/indexer/drules_struct.pb.h
@@ -46,11 +46,12 @@ class ContainerProto;
 
 enum LineJoin {
   ROUNDJOIN = 0,
-  BEVELJOIN = 1
+  BEVELJOIN = 1,
+  NOJOIN = 2
 };
 bool LineJoin_IsValid(int value);
 const LineJoin LineJoin_MIN = ROUNDJOIN;
-const LineJoin LineJoin_MAX = BEVELJOIN;
+const LineJoin LineJoin_MAX = NOJOIN;
 const int LineJoin_ARRAYSIZE = LineJoin_MAX + 1;
 
 const ::google::protobuf::EnumDescriptor* LineJoin_descriptor();
@@ -65,11 +66,12 @@ inline bool LineJoin_Parse(
 }
 enum LineCap {
   ROUNDCAP = 0,
-  BUTTCAP = 1
+  BUTTCAP = 1,
+  SQUARECAP = 2
 };
 bool LineCap_IsValid(int value);
 const LineCap LineCap_MIN = ROUNDCAP;
-const LineCap LineCap_MAX = BUTTCAP;
+const LineCap LineCap_MAX = SQUARECAP;
 const int LineCap_ARRAYSIZE = LineCap_MAX + 1;
 
 const ::google::protobuf::EnumDescriptor* LineCap_descriptor();
@@ -847,6 +849,20 @@ class CaptionDefProto : public ::google::protobuf::Message {
   inline ::google::protobuf::uint32 stroke_color() const;
   inline void set_stroke_color(::google::protobuf::uint32 value);
   
+  // optional int32 offset_x = 4;
+  inline bool has_offset_x() const;
+  inline void clear_offset_x();
+  static const int kOffsetXFieldNumber = 4;
+  inline ::google::protobuf::int32 offset_x() const;
+  inline void set_offset_x(::google::protobuf::int32 value);
+  
+  // optional int32 offset_y = 5;
+  inline bool has_offset_y() const;
+  inline void clear_offset_y();
+  static const int kOffsetYFieldNumber = 5;
+  inline ::google::protobuf::int32 offset_y() const;
+  inline void set_offset_y(::google::protobuf::int32 value);
+  
   // @@protoc_insertion_point(class_scope:CaptionDefProto)
  private:
   inline void set_has_height();
@@ -855,15 +871,21 @@ class CaptionDefProto : public ::google::protobuf::Message {
   inline void clear_has_color();
   inline void set_has_stroke_color();
   inline void clear_has_stroke_color();
+  inline void set_has_offset_x();
+  inline void clear_has_offset_x();
+  inline void set_has_offset_y();
+  inline void clear_has_offset_y();
   
   ::google::protobuf::UnknownFieldSet _unknown_fields_;
   
   ::google::protobuf::int32 height_;
   ::google::protobuf::uint32 color_;
   ::google::protobuf::uint32 stroke_color_;
+  ::google::protobuf::int32 offset_x_;
+  ::google::protobuf::int32 offset_y_;
   
   mutable int _cached_size_;
-  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
+  ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32];
   
   friend void  protobuf_AddDesc_drules_5fstruct_2eproto();
   friend void protobuf_AssignDesc_drules_5fstruct_2eproto();
@@ -2266,6 +2288,50 @@ inline void CaptionDefProto::set_stroke_color(::google::protobuf::uint32 value)
   stroke_color_ = value;
 }
 
+// optional int32 offset_x = 4;
+inline bool CaptionDefProto::has_offset_x() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void CaptionDefProto::set_has_offset_x() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void CaptionDefProto::clear_has_offset_x() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void CaptionDefProto::clear_offset_x() {
+  offset_x_ = 0;
+  clear_has_offset_x();
+}
+inline ::google::protobuf::int32 CaptionDefProto::offset_x() const {
+  return offset_x_;
+}
+inline void CaptionDefProto::set_offset_x(::google::protobuf::int32 value) {
+  set_has_offset_x();
+  offset_x_ = value;
+}
+
+// optional int32 offset_y = 5;
+inline bool CaptionDefProto::has_offset_y() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void CaptionDefProto::set_has_offset_y() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void CaptionDefProto::clear_has_offset_y() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void CaptionDefProto::clear_offset_y() {
+  offset_y_ = 0;
+  clear_has_offset_y();
+}
+inline ::google::protobuf::int32 CaptionDefProto::offset_y() const {
+  return offset_y_;
+}
+inline void CaptionDefProto::set_offset_y(::google::protobuf::int32 value) {
+  set_has_offset_y();
+  offset_y_ = value;
+}
+
 // -------------------------------------------------------------------
 
 // CaptionRuleProto
diff --git a/indexer/drules_struct.proto b/indexer/drules_struct.proto
index 25a32fc767..6e7c33c55c 100644
--- a/indexer/drules_struct.proto
+++ b/indexer/drules_struct.proto
@@ -17,12 +17,14 @@ enum LineJoin
 {
   ROUNDJOIN = 0;
   BEVELJOIN = 1;
+  NOJOIN = 2;
 }
 
 enum LineCap
 {
   ROUNDCAP = 0;
   BUTTCAP = 1;
+  SQUARECAP = 2;
 }
 
 message LineRuleProto
@@ -65,6 +67,8 @@ message CaptionDefProto
   required int32 height = 1;
   required uint32 color = 2;
   optional uint32 stroke_color = 3;
+  optional int32 offset_x = 4;
+  optional int32 offset_y = 5;
 }
 
 message CaptionRuleProto
diff --git a/indexer/drules_struct_lite.pb.cc b/indexer/drules_struct_lite.pb.cc
index aa31b5fcc4..0d838d627e 100644
--- a/indexer/drules_struct_lite.pb.cc
+++ b/indexer/drules_struct_lite.pb.cc
@@ -1,29 +1,373 @@
 // Generated by the protocol buffer compiler.  DO NOT EDIT!
 
 #define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
-#include "drules_struct_lite.pb.h"
+#include "drules_struct.pb.h"
 
 #include <algorithm>
 
 #include <google/protobuf/stubs/once.h>
 #include <google/protobuf/io/coded_stream.h>
 #include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
 // @@protoc_insertion_point(includes)
 
+namespace {
+
+const ::google::protobuf::Descriptor* DashDotProto_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  DashDotProto_reflection_ = NULL;
+const ::google::protobuf::Descriptor* PathSymProto_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  PathSymProto_reflection_ = NULL;
+const ::google::protobuf::Descriptor* LineRuleProto_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  LineRuleProto_reflection_ = NULL;
+const ::google::protobuf::Descriptor* LineDefProto_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  LineDefProto_reflection_ = NULL;
+const ::google::protobuf::Descriptor* AreaRuleProto_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  AreaRuleProto_reflection_ = NULL;
+const ::google::protobuf::Descriptor* SymbolRuleProto_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SymbolRuleProto_reflection_ = NULL;
+const ::google::protobuf::Descriptor* CaptionDefProto_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  CaptionDefProto_reflection_ = NULL;
+const ::google::protobuf::Descriptor* CaptionRuleProto_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  CaptionRuleProto_reflection_ = NULL;
+const ::google::protobuf::Descriptor* CircleRuleProto_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  CircleRuleProto_reflection_ = NULL;
+const ::google::protobuf::Descriptor* PathTextRuleProto_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  PathTextRuleProto_reflection_ = NULL;
+const ::google::protobuf::Descriptor* DrawElementProto_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  DrawElementProto_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ClassifElementProto_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ClassifElementProto_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ContainerProto_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ContainerProto_reflection_ = NULL;
+const ::google::protobuf::EnumDescriptor* LineJoin_descriptor_ = NULL;
+const ::google::protobuf::EnumDescriptor* LineCap_descriptor_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_drules_5fstruct_2eproto() {
+  protobuf_AddDesc_drules_5fstruct_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "drules_struct.proto");
+  GOOGLE_CHECK(file != NULL);
+  DashDotProto_descriptor_ = file->message_type(0);
+  static const int DashDotProto_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DashDotProto, dd_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DashDotProto, offset_),
+  };
+  DashDotProto_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      DashDotProto_descriptor_,
+      DashDotProto::default_instance_,
+      DashDotProto_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DashDotProto, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DashDotProto, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(DashDotProto));
+  PathSymProto_descriptor_ = file->message_type(1);
+  static const int PathSymProto_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PathSymProto, name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PathSymProto, step_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PathSymProto, offset_),
+  };
+  PathSymProto_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      PathSymProto_descriptor_,
+      PathSymProto::default_instance_,
+      PathSymProto_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PathSymProto, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PathSymProto, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(PathSymProto));
+  LineRuleProto_descriptor_ = file->message_type(2);
+  static const int LineRuleProto_offsets_[7] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LineRuleProto, width_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LineRuleProto, color_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LineRuleProto, dashdot_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LineRuleProto, priority_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LineRuleProto, pathsym_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LineRuleProto, join_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LineRuleProto, cap_),
+  };
+  LineRuleProto_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      LineRuleProto_descriptor_,
+      LineRuleProto::default_instance_,
+      LineRuleProto_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LineRuleProto, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LineRuleProto, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(LineRuleProto));
+  LineDefProto_descriptor_ = file->message_type(3);
+  static const int LineDefProto_offsets_[6] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LineDefProto, width_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LineDefProto, color_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LineDefProto, dashdot_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LineDefProto, pathsym_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LineDefProto, join_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LineDefProto, cap_),
+  };
+  LineDefProto_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      LineDefProto_descriptor_,
+      LineDefProto::default_instance_,
+      LineDefProto_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LineDefProto, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LineDefProto, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(LineDefProto));
+  AreaRuleProto_descriptor_ = file->message_type(4);
+  static const int AreaRuleProto_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AreaRuleProto, color_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AreaRuleProto, border_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AreaRuleProto, priority_),
+  };
+  AreaRuleProto_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      AreaRuleProto_descriptor_,
+      AreaRuleProto::default_instance_,
+      AreaRuleProto_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AreaRuleProto, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AreaRuleProto, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(AreaRuleProto));
+  SymbolRuleProto_descriptor_ = file->message_type(5);
+  static const int SymbolRuleProto_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SymbolRuleProto, name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SymbolRuleProto, apply_for_type_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SymbolRuleProto, priority_),
+  };
+  SymbolRuleProto_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SymbolRuleProto_descriptor_,
+      SymbolRuleProto::default_instance_,
+      SymbolRuleProto_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SymbolRuleProto, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SymbolRuleProto, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SymbolRuleProto));
+  CaptionDefProto_descriptor_ = file->message_type(6);
+  static const int CaptionDefProto_offsets_[5] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CaptionDefProto, height_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CaptionDefProto, color_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CaptionDefProto, stroke_color_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CaptionDefProto, offset_x_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CaptionDefProto, offset_y_),
+  };
+  CaptionDefProto_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      CaptionDefProto_descriptor_,
+      CaptionDefProto::default_instance_,
+      CaptionDefProto_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CaptionDefProto, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CaptionDefProto, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(CaptionDefProto));
+  CaptionRuleProto_descriptor_ = file->message_type(7);
+  static const int CaptionRuleProto_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CaptionRuleProto, primary_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CaptionRuleProto, secondary_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CaptionRuleProto, priority_),
+  };
+  CaptionRuleProto_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      CaptionRuleProto_descriptor_,
+      CaptionRuleProto::default_instance_,
+      CaptionRuleProto_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CaptionRuleProto, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CaptionRuleProto, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(CaptionRuleProto));
+  CircleRuleProto_descriptor_ = file->message_type(8);
+  static const int CircleRuleProto_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CircleRuleProto, radius_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CircleRuleProto, color_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CircleRuleProto, border_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CircleRuleProto, priority_),
+  };
+  CircleRuleProto_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      CircleRuleProto_descriptor_,
+      CircleRuleProto::default_instance_,
+      CircleRuleProto_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CircleRuleProto, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CircleRuleProto, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(CircleRuleProto));
+  PathTextRuleProto_descriptor_ = file->message_type(9);
+  static const int PathTextRuleProto_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PathTextRuleProto, primary_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PathTextRuleProto, secondary_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PathTextRuleProto, priority_),
+  };
+  PathTextRuleProto_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      PathTextRuleProto_descriptor_,
+      PathTextRuleProto::default_instance_,
+      PathTextRuleProto_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PathTextRuleProto, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PathTextRuleProto, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(PathTextRuleProto));
+  DrawElementProto_descriptor_ = file->message_type(10);
+  static const int DrawElementProto_offsets_[7] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DrawElementProto, scale_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DrawElementProto, lines_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DrawElementProto, area_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DrawElementProto, symbol_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DrawElementProto, caption_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DrawElementProto, circle_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DrawElementProto, path_text_),
+  };
+  DrawElementProto_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      DrawElementProto_descriptor_,
+      DrawElementProto::default_instance_,
+      DrawElementProto_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DrawElementProto, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DrawElementProto, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(DrawElementProto));
+  ClassifElementProto_descriptor_ = file->message_type(11);
+  static const int ClassifElementProto_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClassifElementProto, name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClassifElementProto, element_),
+  };
+  ClassifElementProto_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ClassifElementProto_descriptor_,
+      ClassifElementProto::default_instance_,
+      ClassifElementProto_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClassifElementProto, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClassifElementProto, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ClassifElementProto));
+  ContainerProto_descriptor_ = file->message_type(12);
+  static const int ContainerProto_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ContainerProto, cont_),
+  };
+  ContainerProto_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ContainerProto_descriptor_,
+      ContainerProto::default_instance_,
+      ContainerProto_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ContainerProto, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ContainerProto, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ContainerProto));
+  LineJoin_descriptor_ = file->enum_type(0);
+  LineCap_descriptor_ = file->enum_type(1);
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_drules_5fstruct_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    DashDotProto_descriptor_, &DashDotProto::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    PathSymProto_descriptor_, &PathSymProto::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    LineRuleProto_descriptor_, &LineRuleProto::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    LineDefProto_descriptor_, &LineDefProto::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    AreaRuleProto_descriptor_, &AreaRuleProto::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SymbolRuleProto_descriptor_, &SymbolRuleProto::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    CaptionDefProto_descriptor_, &CaptionDefProto::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    CaptionRuleProto_descriptor_, &CaptionRuleProto::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    CircleRuleProto_descriptor_, &CircleRuleProto::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    PathTextRuleProto_descriptor_, &PathTextRuleProto::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    DrawElementProto_descriptor_, &DrawElementProto::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ClassifElementProto_descriptor_, &ClassifElementProto::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ContainerProto_descriptor_, &ContainerProto::default_instance());
+}
+
+}  // namespace
+
 void protobuf_ShutdownFile_drules_5fstruct_2eproto() {
   delete DashDotProto::default_instance_;
+  delete DashDotProto_reflection_;
   delete PathSymProto::default_instance_;
+  delete PathSymProto_reflection_;
   delete LineRuleProto::default_instance_;
+  delete LineRuleProto_reflection_;
   delete LineDefProto::default_instance_;
+  delete LineDefProto_reflection_;
   delete AreaRuleProto::default_instance_;
+  delete AreaRuleProto_reflection_;
   delete SymbolRuleProto::default_instance_;
+  delete SymbolRuleProto_reflection_;
   delete CaptionDefProto::default_instance_;
+  delete CaptionDefProto_reflection_;
   delete CaptionRuleProto::default_instance_;
+  delete CaptionRuleProto_reflection_;
   delete CircleRuleProto::default_instance_;
+  delete CircleRuleProto_reflection_;
   delete PathTextRuleProto::default_instance_;
+  delete PathTextRuleProto_reflection_;
   delete DrawElementProto::default_instance_;
+  delete DrawElementProto_reflection_;
   delete ClassifElementProto::default_instance_;
+  delete ClassifElementProto_reflection_;
   delete ContainerProto::default_instance_;
+  delete ContainerProto_reflection_;
 }
 
 void protobuf_AddDesc_drules_5fstruct_2eproto() {
@@ -32,6 +376,47 @@ void protobuf_AddDesc_drules_5fstruct_2eproto() {
   already_here = true;
   GOOGLE_PROTOBUF_VERIFY_VERSION;
 
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\023drules_struct.proto\"*\n\014DashDotProto\022\n\n"
+    "\002dd\030\001 \003(\001\022\016\n\006offset\030\002 \001(\001\":\n\014PathSymProt"
+    "o\022\014\n\004name\030\001 \002(\t\022\014\n\004step\030\002 \002(\001\022\016\n\006offset\030"
+    "\003 \001(\001\"\257\001\n\rLineRuleProto\022\r\n\005width\030\001 \002(\001\022\r"
+    "\n\005color\030\002 \002(\r\022\036\n\007dashdot\030\003 \001(\0132\r.DashDot"
+    "Proto\022\020\n\010priority\030\004 \002(\005\022\036\n\007pathsym\030\005 \001(\013"
+    "2\r.PathSymProto\022\027\n\004join\030\006 \001(\0162\t.LineJoin"
+    "\022\025\n\003cap\030\007 \001(\0162\010.LineCap\"\234\001\n\014LineDefProto"
+    "\022\r\n\005width\030\001 \002(\001\022\r\n\005color\030\002 \002(\r\022\036\n\007dashdo"
+    "t\030\003 \001(\0132\r.DashDotProto\022\036\n\007pathsym\030\004 \001(\0132"
+    "\r.PathSymProto\022\027\n\004join\030\006 \001(\0162\t.LineJoin\022"
+    "\025\n\003cap\030\007 \001(\0162\010.LineCap\"O\n\rAreaRuleProto\022"
+    "\r\n\005color\030\001 \002(\r\022\035\n\006border\030\002 \001(\0132\r.LineDef"
+    "Proto\022\020\n\010priority\030\003 \002(\005\"I\n\017SymbolRulePro"
+    "to\022\014\n\004name\030\001 \002(\t\022\026\n\016apply_for_type\030\002 \001(\005"
+    "\022\020\n\010priority\030\003 \002(\005\"j\n\017CaptionDefProto\022\016\n"
+    "\006height\030\001 \002(\005\022\r\n\005color\030\002 \002(\r\022\024\n\014stroke_c"
+    "olor\030\003 \001(\r\022\020\n\010offset_x\030\004 \001(\005\022\020\n\010offset_y"
+    "\030\005 \001(\005\"l\n\020CaptionRuleProto\022!\n\007primary\030\001 "
+    "\002(\0132\020.CaptionDefProto\022#\n\tsecondary\030\002 \001(\013"
+    "2\020.CaptionDefProto\022\020\n\010priority\030\003 \002(\005\"a\n\017"
+    "CircleRuleProto\022\016\n\006radius\030\001 \002(\001\022\r\n\005color"
+    "\030\002 \002(\r\022\035\n\006border\030\003 \001(\0132\r.LineDefProto\022\020\n"
+    "\010priority\030\004 \002(\005\"m\n\021PathTextRuleProto\022!\n\007"
+    "primary\030\001 \002(\0132\020.CaptionDefProto\022#\n\tsecon"
+    "dary\030\002 \001(\0132\020.CaptionDefProto\022\020\n\010priority"
+    "\030\003 \002(\005\"\355\001\n\020DrawElementProto\022\r\n\005scale\030\001 \002"
+    "(\005\022\035\n\005lines\030\002 \003(\0132\016.LineRuleProto\022\034\n\004are"
+    "a\030\003 \001(\0132\016.AreaRuleProto\022 \n\006symbol\030\004 \001(\0132"
+    "\020.SymbolRuleProto\022\"\n\007caption\030\005 \001(\0132\021.Cap"
+    "tionRuleProto\022 \n\006circle\030\006 \001(\0132\020.CircleRu"
+    "leProto\022%\n\tpath_text\030\007 \001(\0132\022.PathTextRul"
+    "eProto\"G\n\023ClassifElementProto\022\014\n\004name\030\001 "
+    "\002(\t\022\"\n\007element\030\002 \003(\0132\021.DrawElementProto\""
+    "4\n\016ContainerProto\022\"\n\004cont\030\001 \003(\0132\024.Classi"
+    "fElementProto*4\n\010LineJoin\022\r\n\tROUNDJOIN\020\000"
+    "\022\r\n\tBEVELJOIN\020\001\022\n\n\006NOJOIN\020\002*3\n\007LineCap\022\014"
+    "\n\010ROUNDCAP\020\000\022\013\n\007BUTTCAP\020\001\022\r\n\tSQUARECAP\020\002", 1520);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "drules_struct.proto", &protobuf_RegisterTypes);
   DashDotProto::default_instance_ = new DashDotProto();
   PathSymProto::default_instance_ = new PathSymProto();
   LineRuleProto::default_instance_ = new LineRuleProto();
@@ -68,20 +453,30 @@ struct StaticDescriptorInitializer_drules_5fstruct_2eproto {
   }
 } static_descriptor_initializer_drules_5fstruct_2eproto_;
 
+const ::google::protobuf::EnumDescriptor* LineJoin_descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return LineJoin_descriptor_;
+}
 bool LineJoin_IsValid(int value) {
   switch(value) {
     case 0:
     case 1:
+    case 2:
       return true;
     default:
       return false;
   }
 }
 
+const ::google::protobuf::EnumDescriptor* LineCap_descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return LineCap_descriptor_;
+}
 bool LineCap_IsValid(int value) {
   switch(value) {
     case 0:
     case 1:
+    case 2:
       return true;
     default:
       return false;
@@ -97,7 +492,7 @@ const int DashDotProto::kOffsetFieldNumber;
 #endif  // !_MSC_VER
 
 DashDotProto::DashDotProto()
-  : ::google::protobuf::MessageLite() {
+  : ::google::protobuf::Message() {
   SharedCtor();
 }
 
@@ -105,7 +500,7 @@ void DashDotProto::InitAsDefaultInstance() {
 }
 
 DashDotProto::DashDotProto(const DashDotProto& from)
-  : ::google::protobuf::MessageLite() {
+  : ::google::protobuf::Message() {
   SharedCtor();
   MergeFrom(from);
 }
@@ -130,6 +525,11 @@ void DashDotProto::SetCachedSize(int size) const {
   _cached_size_ = size;
   GOOGLE_SAFE_CONCURRENT_WRITES_END();
 }
+const ::google::protobuf::Descriptor* DashDotProto::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return DashDotProto_descriptor_;
+}
+
 const DashDotProto& DashDotProto::default_instance() {
   if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto();  return *default_instance_;
 }
@@ -146,6 +546,7 @@ void DashDotProto::Clear() {
   }
   dd_.Clear();
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
 }
 
 bool DashDotProto::MergePartialFromCodedStream(
@@ -198,7 +599,8 @@ bool DashDotProto::MergePartialFromCodedStream(
             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
           return true;
         }
-        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
         break;
       }
     }
@@ -220,6 +622,30 @@ void DashDotProto::SerializeWithCachedSizes(
     ::google::protobuf::internal::WireFormatLite::WriteDouble(2, this->offset(), output);
   }
   
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* DashDotProto::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // repeated double dd = 1;
+  for (int i = 0; i < this->dd_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteDoubleToArray(1, this->dd(i), target);
+  }
+  
+  // optional double offset = 2;
+  if (has_offset()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(2, this->offset(), target);
+  }
+  
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
 }
 
 int DashDotProto::ByteSize() const {
@@ -239,15 +665,27 @@ int DashDotProto::ByteSize() const {
     total_size += 1 * this->dd_size() + data_size;
   }
   
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
   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 ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const DashDotProto* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const DashDotProto*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
 }
 
 void DashDotProto::MergeFrom(const DashDotProto& from) {
@@ -258,6 +696,13 @@ void DashDotProto::MergeFrom(const DashDotProto& from) {
       set_offset(from.offset());
     }
   }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void DashDotProto::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
 }
 
 void DashDotProto::CopyFrom(const DashDotProto& from) {
@@ -276,12 +721,17 @@ void DashDotProto::Swap(DashDotProto* other) {
     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";
+::google::protobuf::Metadata DashDotProto::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = DashDotProto_descriptor_;
+  metadata.reflection = DashDotProto_reflection_;
+  return metadata;
 }
 
 
@@ -294,7 +744,7 @@ const int PathSymProto::kOffsetFieldNumber;
 #endif  // !_MSC_VER
 
 PathSymProto::PathSymProto()
-  : ::google::protobuf::MessageLite() {
+  : ::google::protobuf::Message() {
   SharedCtor();
 }
 
@@ -302,7 +752,7 @@ void PathSymProto::InitAsDefaultInstance() {
 }
 
 PathSymProto::PathSymProto(const PathSymProto& from)
-  : ::google::protobuf::MessageLite() {
+  : ::google::protobuf::Message() {
   SharedCtor();
   MergeFrom(from);
 }
@@ -332,6 +782,11 @@ void PathSymProto::SetCachedSize(int size) const {
   _cached_size_ = size;
   GOOGLE_SAFE_CONCURRENT_WRITES_END();
 }
+const ::google::protobuf::Descriptor* PathSymProto::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return PathSymProto_descriptor_;
+}
+
 const PathSymProto& PathSymProto::default_instance() {
   if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto();  return *default_instance_;
 }
@@ -353,6 +808,7 @@ void PathSymProto::Clear() {
     offset_ = 0;
   }
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
 }
 
 bool PathSymProto::MergePartialFromCodedStream(
@@ -367,6 +823,9 @@ bool PathSymProto::MergePartialFromCodedStream(
             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                 input, this->mutable_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->name().data(), this->name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
         } else {
           goto handle_uninterpreted;
         }
@@ -412,7 +871,8 @@ bool PathSymProto::MergePartialFromCodedStream(
             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
           return true;
         }
-        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
         break;
       }
     }
@@ -425,6 +885,9 @@ void PathSymProto::SerializeWithCachedSizes(
     ::google::protobuf::io::CodedOutputStream* output) const {
   // required string name = 1;
   if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
     ::google::protobuf::internal::WireFormatLite::WriteString(
       1, this->name(), output);
   }
@@ -439,6 +902,39 @@ void PathSymProto::SerializeWithCachedSizes(
     ::google::protobuf::internal::WireFormatLite::WriteDouble(3, this->offset(), output);
   }
   
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* PathSymProto::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // required string name = 1;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        1, this->name(), target);
+  }
+  
+  // required double step = 2;
+  if (has_step()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(2, this->step(), target);
+  }
+  
+  // optional double offset = 3;
+  if (has_offset()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(3, this->offset(), target);
+  }
+  
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
 }
 
 int PathSymProto::ByteSize() const {
@@ -463,15 +959,27 @@ int PathSymProto::ByteSize() const {
     }
     
   }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
   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 ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const PathSymProto* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const PathSymProto*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
 }
 
 void PathSymProto::MergeFrom(const PathSymProto& from) {
@@ -487,6 +995,13 @@ void PathSymProto::MergeFrom(const PathSymProto& from) {
       set_offset(from.offset());
     }
   }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void PathSymProto::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
 }
 
 void PathSymProto::CopyFrom(const PathSymProto& from) {
@@ -507,12 +1022,17 @@ void PathSymProto::Swap(PathSymProto* other) {
     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";
+::google::protobuf::Metadata PathSymProto::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = PathSymProto_descriptor_;
+  metadata.reflection = PathSymProto_reflection_;
+  return metadata;
 }
 
 
@@ -529,7 +1049,7 @@ const int LineRuleProto::kCapFieldNumber;
 #endif  // !_MSC_VER
 
 LineRuleProto::LineRuleProto()
-  : ::google::protobuf::MessageLite() {
+  : ::google::protobuf::Message() {
   SharedCtor();
 }
 
@@ -539,7 +1059,7 @@ void LineRuleProto::InitAsDefaultInstance() {
 }
 
 LineRuleProto::LineRuleProto(const LineRuleProto& from)
-  : ::google::protobuf::MessageLite() {
+  : ::google::protobuf::Message() {
   SharedCtor();
   MergeFrom(from);
 }
@@ -572,6 +1092,11 @@ void LineRuleProto::SetCachedSize(int size) const {
   _cached_size_ = size;
   GOOGLE_SAFE_CONCURRENT_WRITES_END();
 }
+const ::google::protobuf::Descriptor* LineRuleProto::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return LineRuleProto_descriptor_;
+}
+
 const LineRuleProto& LineRuleProto::default_instance() {
   if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto();  return *default_instance_;
 }
@@ -597,6 +1122,7 @@ void LineRuleProto::Clear() {
     cap_ = 0;
   }
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
 }
 
 bool LineRuleProto::MergePartialFromCodedStream(
@@ -691,6 +1217,8 @@ bool LineRuleProto::MergePartialFromCodedStream(
                  input, &value)));
           if (LineJoin_IsValid(value)) {
             set_join(static_cast< LineJoin >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(6, value);
           }
         } else {
           goto handle_uninterpreted;
@@ -710,6 +1238,8 @@ bool LineRuleProto::MergePartialFromCodedStream(
                  input, &value)));
           if (LineCap_IsValid(value)) {
             set_cap(static_cast< LineCap >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(7, value);
           }
         } else {
           goto handle_uninterpreted;
@@ -724,7 +1254,8 @@ bool LineRuleProto::MergePartialFromCodedStream(
             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
           return true;
         }
-        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
         break;
       }
     }
@@ -747,7 +1278,7 @@ void LineRuleProto::SerializeWithCachedSizes(
   
   // optional .DashDotProto dashdot = 3;
   if (has_dashdot()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
       3, this->dashdot(), output);
   }
   
@@ -758,7 +1289,7 @@ void LineRuleProto::SerializeWithCachedSizes(
   
   // optional .PathSymProto pathsym = 5;
   if (has_pathsym()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
       5, this->pathsym(), output);
   }
   
@@ -774,6 +1305,60 @@ void LineRuleProto::SerializeWithCachedSizes(
       7, this->cap(), output);
   }
   
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* LineRuleProto::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // required double width = 1;
+  if (has_width()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(1, this->width(), target);
+  }
+  
+  // required uint32 color = 2;
+  if (has_color()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->color(), target);
+  }
+  
+  // optional .DashDotProto dashdot = 3;
+  if (has_dashdot()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->dashdot(), target);
+  }
+  
+  // required int32 priority = 4;
+  if (has_priority()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->priority(), target);
+  }
+  
+  // optional .PathSymProto pathsym = 5;
+  if (has_pathsym()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->pathsym(), target);
+  }
+  
+  // optional .LineJoin join = 6;
+  if (has_join()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      6, this->join(), target);
+  }
+  
+  // optional .LineCap cap = 7;
+  if (has_cap()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      7, this->cap(), target);
+  }
+  
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
 }
 
 int LineRuleProto::ByteSize() const {
@@ -826,15 +1411,27 @@ int LineRuleProto::ByteSize() const {
     }
     
   }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
   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 ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const LineRuleProto* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const LineRuleProto*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
 }
 
 void LineRuleProto::MergeFrom(const LineRuleProto& from) {
@@ -862,6 +1459,13 @@ void LineRuleProto::MergeFrom(const LineRuleProto& from) {
       set_cap(from.cap());
     }
   }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void LineRuleProto::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
 }
 
 void LineRuleProto::CopyFrom(const LineRuleProto& from) {
@@ -889,12 +1493,17 @@ void LineRuleProto::Swap(LineRuleProto* other) {
     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";
+::google::protobuf::Metadata LineRuleProto::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = LineRuleProto_descriptor_;
+  metadata.reflection = LineRuleProto_reflection_;
+  return metadata;
 }
 
 
@@ -910,7 +1519,7 @@ const int LineDefProto::kCapFieldNumber;
 #endif  // !_MSC_VER
 
 LineDefProto::LineDefProto()
-  : ::google::protobuf::MessageLite() {
+  : ::google::protobuf::Message() {
   SharedCtor();
 }
 
@@ -920,7 +1529,7 @@ void LineDefProto::InitAsDefaultInstance() {
 }
 
 LineDefProto::LineDefProto(const LineDefProto& from)
-  : ::google::protobuf::MessageLite() {
+  : ::google::protobuf::Message() {
   SharedCtor();
   MergeFrom(from);
 }
@@ -952,6 +1561,11 @@ void LineDefProto::SetCachedSize(int size) const {
   _cached_size_ = size;
   GOOGLE_SAFE_CONCURRENT_WRITES_END();
 }
+const ::google::protobuf::Descriptor* LineDefProto::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return LineDefProto_descriptor_;
+}
+
 const LineDefProto& LineDefProto::default_instance() {
   if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto();  return *default_instance_;
 }
@@ -976,6 +1590,7 @@ void LineDefProto::Clear() {
     cap_ = 0;
   }
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
 }
 
 bool LineDefProto::MergePartialFromCodedStream(
@@ -1054,6 +1669,8 @@ bool LineDefProto::MergePartialFromCodedStream(
                  input, &value)));
           if (LineJoin_IsValid(value)) {
             set_join(static_cast< LineJoin >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(6, value);
           }
         } else {
           goto handle_uninterpreted;
@@ -1073,6 +1690,8 @@ bool LineDefProto::MergePartialFromCodedStream(
                  input, &value)));
           if (LineCap_IsValid(value)) {
             set_cap(static_cast< LineCap >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(7, value);
           }
         } else {
           goto handle_uninterpreted;
@@ -1087,7 +1706,8 @@ bool LineDefProto::MergePartialFromCodedStream(
             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
           return true;
         }
-        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
         break;
       }
     }
@@ -1110,13 +1730,13 @@ void LineDefProto::SerializeWithCachedSizes(
   
   // optional .DashDotProto dashdot = 3;
   if (has_dashdot()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
       3, this->dashdot(), output);
   }
   
   // optional .PathSymProto pathsym = 4;
   if (has_pathsym()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
       4, this->pathsym(), output);
   }
   
@@ -1132,6 +1752,55 @@ void LineDefProto::SerializeWithCachedSizes(
       7, this->cap(), output);
   }
   
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* LineDefProto::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // required double width = 1;
+  if (has_width()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(1, this->width(), target);
+  }
+  
+  // required uint32 color = 2;
+  if (has_color()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->color(), target);
+  }
+  
+  // optional .DashDotProto dashdot = 3;
+  if (has_dashdot()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->dashdot(), target);
+  }
+  
+  // optional .PathSymProto pathsym = 4;
+  if (has_pathsym()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->pathsym(), target);
+  }
+  
+  // optional .LineJoin join = 6;
+  if (has_join()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      6, this->join(), target);
+  }
+  
+  // optional .LineCap cap = 7;
+  if (has_cap()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      7, this->cap(), target);
+  }
+  
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
 }
 
 int LineDefProto::ByteSize() const {
@@ -1177,15 +1846,27 @@ int LineDefProto::ByteSize() const {
     }
     
   }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
   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 ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const LineDefProto* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const LineDefProto*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
 }
 
 void LineDefProto::MergeFrom(const LineDefProto& from) {
@@ -1210,6 +1891,13 @@ void LineDefProto::MergeFrom(const LineDefProto& from) {
       set_cap(from.cap());
     }
   }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void LineDefProto::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
 }
 
 void LineDefProto::CopyFrom(const LineDefProto& from) {
@@ -1236,12 +1924,17 @@ void LineDefProto::Swap(LineDefProto* other) {
     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";
+::google::protobuf::Metadata LineDefProto::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = LineDefProto_descriptor_;
+  metadata.reflection = LineDefProto_reflection_;
+  return metadata;
 }
 
 
@@ -1254,7 +1947,7 @@ const int AreaRuleProto::kPriorityFieldNumber;
 #endif  // !_MSC_VER
 
 AreaRuleProto::AreaRuleProto()
-  : ::google::protobuf::MessageLite() {
+  : ::google::protobuf::Message() {
   SharedCtor();
 }
 
@@ -1263,7 +1956,7 @@ void AreaRuleProto::InitAsDefaultInstance() {
 }
 
 AreaRuleProto::AreaRuleProto(const AreaRuleProto& from)
-  : ::google::protobuf::MessageLite() {
+  : ::google::protobuf::Message() {
   SharedCtor();
   MergeFrom(from);
 }
@@ -1291,6 +1984,11 @@ void AreaRuleProto::SetCachedSize(int size) const {
   _cached_size_ = size;
   GOOGLE_SAFE_CONCURRENT_WRITES_END();
 }
+const ::google::protobuf::Descriptor* AreaRuleProto::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return AreaRuleProto_descriptor_;
+}
+
 const AreaRuleProto& AreaRuleProto::default_instance() {
   if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto();  return *default_instance_;
 }
@@ -1310,6 +2008,7 @@ void AreaRuleProto::Clear() {
     priority_ = 0;
   }
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
 }
 
 bool AreaRuleProto::MergePartialFromCodedStream(
@@ -1369,7 +2068,8 @@ bool AreaRuleProto::MergePartialFromCodedStream(
             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
           return true;
         }
-        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
         break;
       }
     }
@@ -1387,7 +2087,7 @@ void AreaRuleProto::SerializeWithCachedSizes(
   
   // optional .LineDefProto border = 2;
   if (has_border()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
       2, this->border(), output);
   }
   
@@ -1396,6 +2096,36 @@ void AreaRuleProto::SerializeWithCachedSizes(
     ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->priority(), output);
   }
   
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* AreaRuleProto::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // required uint32 color = 1;
+  if (has_color()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->color(), target);
+  }
+  
+  // optional .LineDefProto border = 2;
+  if (has_border()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->border(), target);
+  }
+  
+  // required int32 priority = 3;
+  if (has_priority()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->priority(), target);
+  }
+  
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
 }
 
 int AreaRuleProto::ByteSize() const {
@@ -1424,15 +2154,27 @@ int AreaRuleProto::ByteSize() const {
     }
     
   }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
   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 ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const AreaRuleProto* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const AreaRuleProto*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
 }
 
 void AreaRuleProto::MergeFrom(const AreaRuleProto& from) {
@@ -1448,6 +2190,13 @@ void AreaRuleProto::MergeFrom(const AreaRuleProto& from) {
       set_priority(from.priority());
     }
   }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void AreaRuleProto::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
 }
 
 void AreaRuleProto::CopyFrom(const AreaRuleProto& from) {
@@ -1471,12 +2220,17 @@ void AreaRuleProto::Swap(AreaRuleProto* other) {
     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";
+::google::protobuf::Metadata AreaRuleProto::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = AreaRuleProto_descriptor_;
+  metadata.reflection = AreaRuleProto_reflection_;
+  return metadata;
 }
 
 
@@ -1489,7 +2243,7 @@ const int SymbolRuleProto::kPriorityFieldNumber;
 #endif  // !_MSC_VER
 
 SymbolRuleProto::SymbolRuleProto()
-  : ::google::protobuf::MessageLite() {
+  : ::google::protobuf::Message() {
   SharedCtor();
 }
 
@@ -1497,7 +2251,7 @@ void SymbolRuleProto::InitAsDefaultInstance() {
 }
 
 SymbolRuleProto::SymbolRuleProto(const SymbolRuleProto& from)
-  : ::google::protobuf::MessageLite() {
+  : ::google::protobuf::Message() {
   SharedCtor();
   MergeFrom(from);
 }
@@ -1527,6 +2281,11 @@ void SymbolRuleProto::SetCachedSize(int size) const {
   _cached_size_ = size;
   GOOGLE_SAFE_CONCURRENT_WRITES_END();
 }
+const ::google::protobuf::Descriptor* SymbolRuleProto::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SymbolRuleProto_descriptor_;
+}
+
 const SymbolRuleProto& SymbolRuleProto::default_instance() {
   if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto();  return *default_instance_;
 }
@@ -1548,6 +2307,7 @@ void SymbolRuleProto::Clear() {
     priority_ = 0;
   }
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
 }
 
 bool SymbolRuleProto::MergePartialFromCodedStream(
@@ -1562,6 +2322,9 @@ bool SymbolRuleProto::MergePartialFromCodedStream(
             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                 input, this->mutable_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->name().data(), this->name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
         } else {
           goto handle_uninterpreted;
         }
@@ -1607,7 +2370,8 @@ bool SymbolRuleProto::MergePartialFromCodedStream(
             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
           return true;
         }
-        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
         break;
       }
     }
@@ -1620,6 +2384,9 @@ void SymbolRuleProto::SerializeWithCachedSizes(
     ::google::protobuf::io::CodedOutputStream* output) const {
   // required string name = 1;
   if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
     ::google::protobuf::internal::WireFormatLite::WriteString(
       1, this->name(), output);
   }
@@ -1634,6 +2401,39 @@ void SymbolRuleProto::SerializeWithCachedSizes(
     ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->priority(), output);
   }
   
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* SymbolRuleProto::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // required string name = 1;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        1, this->name(), target);
+  }
+  
+  // optional int32 apply_for_type = 2;
+  if (has_apply_for_type()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->apply_for_type(), target);
+  }
+  
+  // required int32 priority = 3;
+  if (has_priority()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->priority(), target);
+  }
+  
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
 }
 
 int SymbolRuleProto::ByteSize() const {
@@ -1662,15 +2462,27 @@ int SymbolRuleProto::ByteSize() const {
     }
     
   }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
   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 ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SymbolRuleProto* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SymbolRuleProto*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
 }
 
 void SymbolRuleProto::MergeFrom(const SymbolRuleProto& from) {
@@ -1686,6 +2498,13 @@ void SymbolRuleProto::MergeFrom(const SymbolRuleProto& from) {
       set_priority(from.priority());
     }
   }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SymbolRuleProto::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
 }
 
 void SymbolRuleProto::CopyFrom(const SymbolRuleProto& from) {
@@ -1706,12 +2525,17 @@ void SymbolRuleProto::Swap(SymbolRuleProto* other) {
     std::swap(apply_for_type_, other->apply_for_type_);
     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 SymbolRuleProto::GetTypeName() const {
-  return "SymbolRuleProto";
+::google::protobuf::Metadata SymbolRuleProto::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SymbolRuleProto_descriptor_;
+  metadata.reflection = SymbolRuleProto_reflection_;
+  return metadata;
 }
 
 
@@ -1721,10 +2545,12 @@ void SymbolRuleProto::Swap(SymbolRuleProto* other) {
 const int CaptionDefProto::kHeightFieldNumber;
 const int CaptionDefProto::kColorFieldNumber;
 const int CaptionDefProto::kStrokeColorFieldNumber;
+const int CaptionDefProto::kOffsetXFieldNumber;
+const int CaptionDefProto::kOffsetYFieldNumber;
 #endif  // !_MSC_VER
 
 CaptionDefProto::CaptionDefProto()
-  : ::google::protobuf::MessageLite() {
+  : ::google::protobuf::Message() {
   SharedCtor();
 }
 
@@ -1732,7 +2558,7 @@ void CaptionDefProto::InitAsDefaultInstance() {
 }
 
 CaptionDefProto::CaptionDefProto(const CaptionDefProto& from)
-  : ::google::protobuf::MessageLite() {
+  : ::google::protobuf::Message() {
   SharedCtor();
   MergeFrom(from);
 }
@@ -1742,6 +2568,8 @@ void CaptionDefProto::SharedCtor() {
   height_ = 0;
   color_ = 0u;
   stroke_color_ = 0u;
+  offset_x_ = 0;
+  offset_y_ = 0;
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
 
@@ -1759,6 +2587,11 @@ void CaptionDefProto::SetCachedSize(int size) const {
   _cached_size_ = size;
   GOOGLE_SAFE_CONCURRENT_WRITES_END();
 }
+const ::google::protobuf::Descriptor* CaptionDefProto::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return CaptionDefProto_descriptor_;
+}
+
 const CaptionDefProto& CaptionDefProto::default_instance() {
   if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto();  return *default_instance_;
 }
@@ -1774,8 +2607,11 @@ void CaptionDefProto::Clear() {
     height_ = 0;
     color_ = 0u;
     stroke_color_ = 0u;
+    offset_x_ = 0;
+    offset_y_ = 0;
   }
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
 }
 
 bool CaptionDefProto::MergePartialFromCodedStream(
@@ -1827,6 +2663,38 @@ bool CaptionDefProto::MergePartialFromCodedStream(
         } else {
           goto handle_uninterpreted;
         }
+        if (input->ExpectTag(32)) goto parse_offset_x;
+        break;
+      }
+      
+      // optional int32 offset_x = 4;
+      case 4: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         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_uninterpreted;
+        }
+        if (input->ExpectTag(40)) goto parse_offset_y;
+        break;
+      }
+      
+      // optional int32 offset_y = 5;
+      case 5: {
+        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
+         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_uninterpreted;
+        }
         if (input->ExpectAtEnd()) return true;
         break;
       }
@@ -1837,7 +2705,8 @@ bool CaptionDefProto::MergePartialFromCodedStream(
             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
           return true;
         }
-        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
         break;
       }
     }
@@ -1863,6 +2732,54 @@ void CaptionDefProto::SerializeWithCachedSizes(
     ::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);
+  }
+  
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* CaptionDefProto::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // required int32 height = 1;
+  if (has_height()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->height(), target);
+  }
+  
+  // required uint32 color = 2;
+  if (has_color()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->color(), target);
+  }
+  
+  // optional uint32 stroke_color = 3;
+  if (has_stroke_color()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->stroke_color(), target);
+  }
+  
+  // optional int32 offset_x = 4;
+  if (has_offset_x()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->offset_x(), target);
+  }
+  
+  // optional int32 offset_y = 5;
+  if (has_offset_y()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(5, this->offset_y(), target);
+  }
+  
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
 }
 
 int CaptionDefProto::ByteSize() const {
@@ -1890,6 +2807,25 @@ int CaptionDefProto::ByteSize() const {
           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());
+    }
+    
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
   }
   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
   _cached_size_ = total_size;
@@ -1897,9 +2833,16 @@ int CaptionDefProto::ByteSize() const {
   return total_size;
 }
 
-void CaptionDefProto::CheckTypeAndMergeFrom(
-    const ::google::protobuf::MessageLite& from) {
-  MergeFrom(*::google::protobuf::down_cast<const CaptionDefProto*>(&from));
+void CaptionDefProto::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const CaptionDefProto* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const CaptionDefProto*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
 }
 
 void CaptionDefProto::MergeFrom(const CaptionDefProto& from) {
@@ -1914,7 +2857,20 @@ void CaptionDefProto::MergeFrom(const CaptionDefProto& from) {
     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());
+    }
   }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void CaptionDefProto::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
 }
 
 void CaptionDefProto::CopyFrom(const CaptionDefProto& from) {
@@ -1934,13 +2890,20 @@ void CaptionDefProto::Swap(CaptionDefProto* other) {
     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(_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";
+::google::protobuf::Metadata CaptionDefProto::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = CaptionDefProto_descriptor_;
+  metadata.reflection = CaptionDefProto_reflection_;
+  return metadata;
 }
 
 
@@ -1953,7 +2916,7 @@ const int CaptionRuleProto::kPriorityFieldNumber;
 #endif  // !_MSC_VER
 
 CaptionRuleProto::CaptionRuleProto()
-  : ::google::protobuf::MessageLite() {
+  : ::google::protobuf::Message() {
   SharedCtor();
 }
 
@@ -1963,7 +2926,7 @@ void CaptionRuleProto::InitAsDefaultInstance() {
 }
 
 CaptionRuleProto::CaptionRuleProto(const CaptionRuleProto& from)
-  : ::google::protobuf::MessageLite() {
+  : ::google::protobuf::Message() {
   SharedCtor();
   MergeFrom(from);
 }
@@ -1992,6 +2955,11 @@ void CaptionRuleProto::SetCachedSize(int size) const {
   _cached_size_ = size;
   GOOGLE_SAFE_CONCURRENT_WRITES_END();
 }
+const ::google::protobuf::Descriptor* CaptionRuleProto::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return CaptionRuleProto_descriptor_;
+}
+
 const CaptionRuleProto& CaptionRuleProto::default_instance() {
   if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto();  return *default_instance_;
 }
@@ -2013,6 +2981,7 @@ void CaptionRuleProto::Clear() {
     priority_ = 0;
   }
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
 }
 
 bool CaptionRuleProto::MergePartialFromCodedStream(
@@ -2070,7 +3039,8 @@ bool CaptionRuleProto::MergePartialFromCodedStream(
             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
           return true;
         }
-        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
         break;
       }
     }
@@ -2083,13 +3053,13 @@ void CaptionRuleProto::SerializeWithCachedSizes(
     ::google::protobuf::io::CodedOutputStream* output) const {
   // required .CaptionDefProto primary = 1;
   if (has_primary()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
       1, this->primary(), output);
   }
   
   // optional .CaptionDefProto secondary = 2;
   if (has_secondary()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
       2, this->secondary(), output);
   }
   
@@ -2098,6 +3068,38 @@ void CaptionRuleProto::SerializeWithCachedSizes(
     ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->priority(), output);
   }
   
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* CaptionRuleProto::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // required .CaptionDefProto primary = 1;
+  if (has_primary()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->primary(), target);
+  }
+  
+  // optional .CaptionDefProto secondary = 2;
+  if (has_secondary()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->secondary(), target);
+  }
+  
+  // required int32 priority = 3;
+  if (has_priority()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->priority(), target);
+  }
+  
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
 }
 
 int CaptionRuleProto::ByteSize() const {
@@ -2126,15 +3128,27 @@ int CaptionRuleProto::ByteSize() const {
     }
     
   }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
   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 ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const CaptionRuleProto* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const CaptionRuleProto*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
 }
 
 void CaptionRuleProto::MergeFrom(const CaptionRuleProto& from) {
@@ -2150,6 +3164,13 @@ void CaptionRuleProto::MergeFrom(const CaptionRuleProto& from) {
       set_priority(from.priority());
     }
   }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void CaptionRuleProto::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
 }
 
 void CaptionRuleProto::CopyFrom(const CaptionRuleProto& from) {
@@ -2176,12 +3197,17 @@ void CaptionRuleProto::Swap(CaptionRuleProto* other) {
     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";
+::google::protobuf::Metadata CaptionRuleProto::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = CaptionRuleProto_descriptor_;
+  metadata.reflection = CaptionRuleProto_reflection_;
+  return metadata;
 }
 
 
@@ -2195,7 +3221,7 @@ const int CircleRuleProto::kPriorityFieldNumber;
 #endif  // !_MSC_VER
 
 CircleRuleProto::CircleRuleProto()
-  : ::google::protobuf::MessageLite() {
+  : ::google::protobuf::Message() {
   SharedCtor();
 }
 
@@ -2204,7 +3230,7 @@ void CircleRuleProto::InitAsDefaultInstance() {
 }
 
 CircleRuleProto::CircleRuleProto(const CircleRuleProto& from)
-  : ::google::protobuf::MessageLite() {
+  : ::google::protobuf::Message() {
   SharedCtor();
   MergeFrom(from);
 }
@@ -2233,6 +3259,11 @@ void CircleRuleProto::SetCachedSize(int size) const {
   _cached_size_ = size;
   GOOGLE_SAFE_CONCURRENT_WRITES_END();
 }
+const ::google::protobuf::Descriptor* CircleRuleProto::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return CircleRuleProto_descriptor_;
+}
+
 const CircleRuleProto& CircleRuleProto::default_instance() {
   if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto();  return *default_instance_;
 }
@@ -2253,6 +3284,7 @@ void CircleRuleProto::Clear() {
     priority_ = 0;
   }
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
 }
 
 bool CircleRuleProto::MergePartialFromCodedStream(
@@ -2328,7 +3360,8 @@ bool CircleRuleProto::MergePartialFromCodedStream(
             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
           return true;
         }
-        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
         break;
       }
     }
@@ -2351,7 +3384,7 @@ void CircleRuleProto::SerializeWithCachedSizes(
   
   // optional .LineDefProto border = 3;
   if (has_border()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
       3, this->border(), output);
   }
   
@@ -2360,6 +3393,41 @@ void CircleRuleProto::SerializeWithCachedSizes(
     ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->priority(), output);
   }
   
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* CircleRuleProto::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // required double radius = 1;
+  if (has_radius()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(1, this->radius(), target);
+  }
+  
+  // required uint32 color = 2;
+  if (has_color()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->color(), target);
+  }
+  
+  // optional .LineDefProto border = 3;
+  if (has_border()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->border(), target);
+  }
+  
+  // required int32 priority = 4;
+  if (has_priority()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->priority(), target);
+  }
+  
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
 }
 
 int CircleRuleProto::ByteSize() const {
@@ -2393,15 +3461,27 @@ int CircleRuleProto::ByteSize() const {
     }
     
   }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
   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 ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const CircleRuleProto* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const CircleRuleProto*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
 }
 
 void CircleRuleProto::MergeFrom(const CircleRuleProto& from) {
@@ -2420,6 +3500,13 @@ void CircleRuleProto::MergeFrom(const CircleRuleProto& from) {
       set_priority(from.priority());
     }
   }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void CircleRuleProto::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
 }
 
 void CircleRuleProto::CopyFrom(const CircleRuleProto& from) {
@@ -2444,12 +3531,17 @@ void CircleRuleProto::Swap(CircleRuleProto* other) {
     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";
+::google::protobuf::Metadata CircleRuleProto::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = CircleRuleProto_descriptor_;
+  metadata.reflection = CircleRuleProto_reflection_;
+  return metadata;
 }
 
 
@@ -2462,7 +3554,7 @@ const int PathTextRuleProto::kPriorityFieldNumber;
 #endif  // !_MSC_VER
 
 PathTextRuleProto::PathTextRuleProto()
-  : ::google::protobuf::MessageLite() {
+  : ::google::protobuf::Message() {
   SharedCtor();
 }
 
@@ -2472,7 +3564,7 @@ void PathTextRuleProto::InitAsDefaultInstance() {
 }
 
 PathTextRuleProto::PathTextRuleProto(const PathTextRuleProto& from)
-  : ::google::protobuf::MessageLite() {
+  : ::google::protobuf::Message() {
   SharedCtor();
   MergeFrom(from);
 }
@@ -2501,6 +3593,11 @@ void PathTextRuleProto::SetCachedSize(int size) const {
   _cached_size_ = size;
   GOOGLE_SAFE_CONCURRENT_WRITES_END();
 }
+const ::google::protobuf::Descriptor* PathTextRuleProto::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return PathTextRuleProto_descriptor_;
+}
+
 const PathTextRuleProto& PathTextRuleProto::default_instance() {
   if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto();  return *default_instance_;
 }
@@ -2522,6 +3619,7 @@ void PathTextRuleProto::Clear() {
     priority_ = 0;
   }
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
 }
 
 bool PathTextRuleProto::MergePartialFromCodedStream(
@@ -2579,7 +3677,8 @@ bool PathTextRuleProto::MergePartialFromCodedStream(
             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
           return true;
         }
-        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
         break;
       }
     }
@@ -2592,13 +3691,13 @@ void PathTextRuleProto::SerializeWithCachedSizes(
     ::google::protobuf::io::CodedOutputStream* output) const {
   // required .CaptionDefProto primary = 1;
   if (has_primary()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
       1, this->primary(), output);
   }
   
   // optional .CaptionDefProto secondary = 2;
   if (has_secondary()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
       2, this->secondary(), output);
   }
   
@@ -2607,6 +3706,38 @@ void PathTextRuleProto::SerializeWithCachedSizes(
     ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->priority(), output);
   }
   
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* PathTextRuleProto::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // required .CaptionDefProto primary = 1;
+  if (has_primary()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->primary(), target);
+  }
+  
+  // optional .CaptionDefProto secondary = 2;
+  if (has_secondary()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->secondary(), target);
+  }
+  
+  // required int32 priority = 3;
+  if (has_priority()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->priority(), target);
+  }
+  
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
 }
 
 int PathTextRuleProto::ByteSize() const {
@@ -2635,15 +3766,27 @@ int PathTextRuleProto::ByteSize() const {
     }
     
   }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
   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 ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const PathTextRuleProto* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const PathTextRuleProto*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
 }
 
 void PathTextRuleProto::MergeFrom(const PathTextRuleProto& from) {
@@ -2659,6 +3802,13 @@ void PathTextRuleProto::MergeFrom(const PathTextRuleProto& from) {
       set_priority(from.priority());
     }
   }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void PathTextRuleProto::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
 }
 
 void PathTextRuleProto::CopyFrom(const PathTextRuleProto& from) {
@@ -2685,12 +3835,17 @@ void PathTextRuleProto::Swap(PathTextRuleProto* other) {
     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";
+::google::protobuf::Metadata PathTextRuleProto::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = PathTextRuleProto_descriptor_;
+  metadata.reflection = PathTextRuleProto_reflection_;
+  return metadata;
 }
 
 
@@ -2707,7 +3862,7 @@ const int DrawElementProto::kPathTextFieldNumber;
 #endif  // !_MSC_VER
 
 DrawElementProto::DrawElementProto()
-  : ::google::protobuf::MessageLite() {
+  : ::google::protobuf::Message() {
   SharedCtor();
 }
 
@@ -2720,7 +3875,7 @@ void DrawElementProto::InitAsDefaultInstance() {
 }
 
 DrawElementProto::DrawElementProto(const DrawElementProto& from)
-  : ::google::protobuf::MessageLite() {
+  : ::google::protobuf::Message() {
   SharedCtor();
   MergeFrom(from);
 }
@@ -2755,6 +3910,11 @@ void DrawElementProto::SetCachedSize(int size) const {
   _cached_size_ = size;
   GOOGLE_SAFE_CONCURRENT_WRITES_END();
 }
+const ::google::protobuf::Descriptor* DrawElementProto::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return DrawElementProto_descriptor_;
+}
+
 const DrawElementProto& DrawElementProto::default_instance() {
   if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto();  return *default_instance_;
 }
@@ -2786,6 +3946,7 @@ void DrawElementProto::Clear() {
   }
   lines_.Clear();
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
 }
 
 bool DrawElementProto::MergePartialFromCodedStream(
@@ -2900,7 +4061,8 @@ bool DrawElementProto::MergePartialFromCodedStream(
             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
           return true;
         }
-        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
         break;
       }
     }
@@ -2918,40 +4080,100 @@ void DrawElementProto::SerializeWithCachedSizes(
   
   // repeated .LineRuleProto lines = 2;
   for (int i = 0; i < this->lines_size(); i++) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
       2, this->lines(i), output);
   }
   
   // optional .AreaRuleProto area = 3;
   if (has_area()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
       3, this->area(), output);
   }
   
   // optional .SymbolRuleProto symbol = 4;
   if (has_symbol()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
       4, this->symbol(), output);
   }
   
   // optional .CaptionRuleProto caption = 5;
   if (has_caption()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
       5, this->caption(), output);
   }
   
   // optional .CircleRuleProto circle = 6;
   if (has_circle()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
       6, this->circle(), output);
   }
   
   // optional .PathTextRuleProto path_text = 7;
   if (has_path_text()) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
       7, this->path_text(), output);
   }
   
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* DrawElementProto::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // required int32 scale = 1;
+  if (has_scale()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->scale(), target);
+  }
+  
+  // repeated .LineRuleProto lines = 2;
+  for (int i = 0; i < this->lines_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->lines(i), target);
+  }
+  
+  // optional .AreaRuleProto area = 3;
+  if (has_area()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->area(), target);
+  }
+  
+  // optional .SymbolRuleProto symbol = 4;
+  if (has_symbol()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->symbol(), target);
+  }
+  
+  // optional .CaptionRuleProto caption = 5;
+  if (has_caption()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->caption(), target);
+  }
+  
+  // optional .CircleRuleProto circle = 6;
+  if (has_circle()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        6, this->circle(), target);
+  }
+  
+  // optional .PathTextRuleProto path_text = 7;
+  if (has_path_text()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        7, this->path_text(), target);
+  }
+  
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
 }
 
 int DrawElementProto::ByteSize() const {
@@ -3009,15 +4231,27 @@ int DrawElementProto::ByteSize() const {
         this->lines(i));
   }
   
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
   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 ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const DrawElementProto* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const DrawElementProto*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
 }
 
 void DrawElementProto::MergeFrom(const DrawElementProto& from) {
@@ -3043,6 +4277,13 @@ void DrawElementProto::MergeFrom(const DrawElementProto& from) {
       mutable_path_text()->::PathTextRuleProto::MergeFrom(from.path_text());
     }
   }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void DrawElementProto::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
 }
 
 void DrawElementProto::CopyFrom(const DrawElementProto& from) {
@@ -3085,12 +4326,17 @@ void DrawElementProto::Swap(DrawElementProto* other) {
     std::swap(circle_, other->circle_);
     std::swap(path_text_, other->path_text_);
     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";
+::google::protobuf::Metadata DrawElementProto::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = DrawElementProto_descriptor_;
+  metadata.reflection = DrawElementProto_reflection_;
+  return metadata;
 }
 
 
@@ -3102,7 +4348,7 @@ const int ClassifElementProto::kElementFieldNumber;
 #endif  // !_MSC_VER
 
 ClassifElementProto::ClassifElementProto()
-  : ::google::protobuf::MessageLite() {
+  : ::google::protobuf::Message() {
   SharedCtor();
 }
 
@@ -3110,7 +4356,7 @@ void ClassifElementProto::InitAsDefaultInstance() {
 }
 
 ClassifElementProto::ClassifElementProto(const ClassifElementProto& from)
-  : ::google::protobuf::MessageLite() {
+  : ::google::protobuf::Message() {
   SharedCtor();
   MergeFrom(from);
 }
@@ -3138,6 +4384,11 @@ void ClassifElementProto::SetCachedSize(int size) const {
   _cached_size_ = size;
   GOOGLE_SAFE_CONCURRENT_WRITES_END();
 }
+const ::google::protobuf::Descriptor* ClassifElementProto::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ClassifElementProto_descriptor_;
+}
+
 const ClassifElementProto& ClassifElementProto::default_instance() {
   if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto();  return *default_instance_;
 }
@@ -3158,6 +4409,7 @@ void ClassifElementProto::Clear() {
   }
   element_.Clear();
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
 }
 
 bool ClassifElementProto::MergePartialFromCodedStream(
@@ -3172,6 +4424,9 @@ bool ClassifElementProto::MergePartialFromCodedStream(
             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                 input, this->mutable_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+            this->name().data(), this->name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE);
         } else {
           goto handle_uninterpreted;
         }
@@ -3200,7 +4455,8 @@ bool ClassifElementProto::MergePartialFromCodedStream(
             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
           return true;
         }
-        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
         break;
       }
     }
@@ -3213,16 +4469,49 @@ void ClassifElementProto::SerializeWithCachedSizes(
     ::google::protobuf::io::CodedOutputStream* output) const {
   // required string name = 1;
   if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
     ::google::protobuf::internal::WireFormatLite::WriteString(
       1, this->name(), output);
   }
   
   // repeated .DrawElementProto element = 2;
   for (int i = 0; i < this->element_size(); i++) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
       2, this->element(i), output);
   }
   
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* ClassifElementProto::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // required string name = 1;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE);
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        1, this->name(), target);
+  }
+  
+  // repeated .DrawElementProto element = 2;
+  for (int i = 0; i < this->element_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->element(i), target);
+  }
+  
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
 }
 
 int ClassifElementProto::ByteSize() const {
@@ -3245,15 +4534,27 @@ int ClassifElementProto::ByteSize() const {
         this->element(i));
   }
   
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
   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 ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ClassifElementProto* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ClassifElementProto*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
 }
 
 void ClassifElementProto::MergeFrom(const ClassifElementProto& from) {
@@ -3264,6 +4565,13 @@ void ClassifElementProto::MergeFrom(const ClassifElementProto& from) {
       set_name(from.name());
     }
   }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ClassifElementProto::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
 }
 
 void ClassifElementProto::CopyFrom(const ClassifElementProto& from) {
@@ -3286,12 +4594,17 @@ void ClassifElementProto::Swap(ClassifElementProto* other) {
     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";
+::google::protobuf::Metadata ClassifElementProto::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ClassifElementProto_descriptor_;
+  metadata.reflection = ClassifElementProto_reflection_;
+  return metadata;
 }
 
 
@@ -3302,7 +4615,7 @@ const int ContainerProto::kContFieldNumber;
 #endif  // !_MSC_VER
 
 ContainerProto::ContainerProto()
-  : ::google::protobuf::MessageLite() {
+  : ::google::protobuf::Message() {
   SharedCtor();
 }
 
@@ -3310,7 +4623,7 @@ void ContainerProto::InitAsDefaultInstance() {
 }
 
 ContainerProto::ContainerProto(const ContainerProto& from)
-  : ::google::protobuf::MessageLite() {
+  : ::google::protobuf::Message() {
   SharedCtor();
   MergeFrom(from);
 }
@@ -3334,6 +4647,11 @@ void ContainerProto::SetCachedSize(int size) const {
   _cached_size_ = size;
   GOOGLE_SAFE_CONCURRENT_WRITES_END();
 }
+const ::google::protobuf::Descriptor* ContainerProto::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ContainerProto_descriptor_;
+}
+
 const ContainerProto& ContainerProto::default_instance() {
   if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto();  return *default_instance_;
 }
@@ -3347,6 +4665,7 @@ ContainerProto* ContainerProto::New() const {
 void ContainerProto::Clear() {
   cont_.Clear();
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
 }
 
 bool ContainerProto::MergePartialFromCodedStream(
@@ -3376,7 +4695,8 @@ bool ContainerProto::MergePartialFromCodedStream(
             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
           return true;
         }
-        DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag));
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
         break;
       }
     }
@@ -3389,10 +4709,30 @@ void ContainerProto::SerializeWithCachedSizes(
     ::google::protobuf::io::CodedOutputStream* output) const {
   // repeated .ClassifElementProto cont = 1;
   for (int i = 0; i < this->cont_size(); i++) {
-    ::google::protobuf::internal::WireFormatLite::WriteMessage(
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
       1, this->cont(i), output);
   }
   
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+}
+
+::google::protobuf::uint8* ContainerProto::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // repeated .ClassifElementProto cont = 1;
+  for (int i = 0; i < this->cont_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->cont(i), target);
+  }
+  
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  return target;
 }
 
 int ContainerProto::ByteSize() const {
@@ -3406,20 +4746,39 @@ int ContainerProto::ByteSize() const {
         this->cont(i));
   }
   
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
   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 ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ContainerProto* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ContainerProto*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
 }
 
 void ContainerProto::MergeFrom(const ContainerProto& from) {
   GOOGLE_CHECK_NE(&from, this);
   cont_.MergeFrom(from.cont_);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ContainerProto::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
 }
 
 void ContainerProto::CopyFrom(const ContainerProto& from) {
@@ -3440,12 +4799,17 @@ void ContainerProto::Swap(ContainerProto* other) {
   if (other != this) {
     cont_.Swap(&other->cont_);
     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";
+::google::protobuf::Metadata ContainerProto::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ContainerProto_descriptor_;
+  metadata.reflection = ContainerProto_reflection_;
+  return metadata;
 }
 
 
diff --git a/indexer/drules_struct_lite.pb.h b/indexer/drules_struct_lite.pb.h
index f7de5bbe9f..8e87a63e21 100644
--- a/indexer/drules_struct_lite.pb.h
+++ b/indexer/drules_struct_lite.pb.h
@@ -22,6 +22,7 @@
 #include <google/protobuf/generated_message_util.h>
 #include <google/protobuf/repeated_field.h>
 #include <google/protobuf/extension_set.h>
+#include <google/protobuf/generated_message_reflection.h>
 // @@protoc_insertion_point(includes)
 
 // Internal implementation detail -- do not call these.
@@ -45,25 +46,47 @@ class ContainerProto;
 
 enum LineJoin {
   ROUNDJOIN = 0,
-  BEVELJOIN = 1
+  BEVELJOIN = 1,
+  NOJOIN = 2
 };
 bool LineJoin_IsValid(int value);
 const LineJoin LineJoin_MIN = ROUNDJOIN;
-const LineJoin LineJoin_MAX = BEVELJOIN;
+const LineJoin LineJoin_MAX = NOJOIN;
 const int LineJoin_ARRAYSIZE = LineJoin_MAX + 1;
 
+const ::google::protobuf::EnumDescriptor* LineJoin_descriptor();
+inline const ::std::string& LineJoin_Name(LineJoin value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    LineJoin_descriptor(), value);
+}
+inline bool LineJoin_Parse(
+    const ::std::string& name, LineJoin* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<LineJoin>(
+    LineJoin_descriptor(), name, value);
+}
 enum LineCap {
   ROUNDCAP = 0,
-  BUTTCAP = 1
+  BUTTCAP = 1,
+  SQUARECAP = 2
 };
 bool LineCap_IsValid(int value);
 const LineCap LineCap_MIN = ROUNDCAP;
-const LineCap LineCap_MAX = BUTTCAP;
+const LineCap LineCap_MAX = SQUARECAP;
 const int LineCap_ARRAYSIZE = LineCap_MAX + 1;
 
+const ::google::protobuf::EnumDescriptor* LineCap_descriptor();
+inline const ::std::string& LineCap_Name(LineCap value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    LineCap_descriptor(), value);
+}
+inline bool LineCap_Parse(
+    const ::std::string& name, LineCap* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<LineCap>(
+    LineCap_descriptor(), name, value);
+}
 // ===================================================================
 
-class DashDotProto : public ::google::protobuf::MessageLite {
+class DashDotProto : public ::google::protobuf::Message {
  public:
   DashDotProto();
   virtual ~DashDotProto();
@@ -75,6 +98,15 @@ class DashDotProto : public ::google::protobuf::MessageLite {
     return *this;
   }
   
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+  
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+  
+  static const ::google::protobuf::Descriptor* descriptor();
   static const DashDotProto& default_instance();
   
   void Swap(DashDotProto* other);
@@ -82,7 +114,8 @@ class DashDotProto : public ::google::protobuf::MessageLite {
   // implements Message ----------------------------------------------
   
   DashDotProto* New() const;
-  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
   void CopyFrom(const DashDotProto& from);
   void MergeFrom(const DashDotProto& from);
   void Clear();
@@ -93,6 +126,7 @@ class DashDotProto : public ::google::protobuf::MessageLite {
       ::google::protobuf::io::CodedInputStream* input);
   void SerializeWithCachedSizes(
       ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
   int GetCachedSize() const { return _cached_size_; }
   private:
   void SharedCtor();
@@ -100,7 +134,7 @@ class DashDotProto : public ::google::protobuf::MessageLite {
   void SetCachedSize(int size) const;
   public:
   
-  ::std::string GetTypeName() const;
+  ::google::protobuf::Metadata GetMetadata() const;
   
   // nested types ----------------------------------------------------
   
@@ -130,6 +164,8 @@ class DashDotProto : public ::google::protobuf::MessageLite {
   inline void set_has_offset();
   inline void clear_has_offset();
   
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+  
   ::google::protobuf::RepeatedField< double > dd_;
   double offset_;
   
@@ -145,7 +181,7 @@ class DashDotProto : public ::google::protobuf::MessageLite {
 };
 // -------------------------------------------------------------------
 
-class PathSymProto : public ::google::protobuf::MessageLite {
+class PathSymProto : public ::google::protobuf::Message {
  public:
   PathSymProto();
   virtual ~PathSymProto();
@@ -157,6 +193,15 @@ class PathSymProto : public ::google::protobuf::MessageLite {
     return *this;
   }
   
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+  
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+  
+  static const ::google::protobuf::Descriptor* descriptor();
   static const PathSymProto& default_instance();
   
   void Swap(PathSymProto* other);
@@ -164,7 +209,8 @@ class PathSymProto : public ::google::protobuf::MessageLite {
   // implements Message ----------------------------------------------
   
   PathSymProto* New() const;
-  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
   void CopyFrom(const PathSymProto& from);
   void MergeFrom(const PathSymProto& from);
   void Clear();
@@ -175,6 +221,7 @@ class PathSymProto : public ::google::protobuf::MessageLite {
       ::google::protobuf::io::CodedInputStream* input);
   void SerializeWithCachedSizes(
       ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
   int GetCachedSize() const { return _cached_size_; }
   private:
   void SharedCtor();
@@ -182,7 +229,7 @@ class PathSymProto : public ::google::protobuf::MessageLite {
   void SetCachedSize(int size) const;
   public:
   
-  ::std::string GetTypeName() const;
+  ::google::protobuf::Metadata GetMetadata() const;
   
   // nested types ----------------------------------------------------
   
@@ -222,6 +269,8 @@ class PathSymProto : public ::google::protobuf::MessageLite {
   inline void set_has_offset();
   inline void clear_has_offset();
   
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+  
   ::std::string* name_;
   double step_;
   double offset_;
@@ -238,7 +287,7 @@ class PathSymProto : public ::google::protobuf::MessageLite {
 };
 // -------------------------------------------------------------------
 
-class LineRuleProto : public ::google::protobuf::MessageLite {
+class LineRuleProto : public ::google::protobuf::Message {
  public:
   LineRuleProto();
   virtual ~LineRuleProto();
@@ -250,6 +299,15 @@ class LineRuleProto : public ::google::protobuf::MessageLite {
     return *this;
   }
   
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+  
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+  
+  static const ::google::protobuf::Descriptor* descriptor();
   static const LineRuleProto& default_instance();
   
   void Swap(LineRuleProto* other);
@@ -257,7 +315,8 @@ class LineRuleProto : public ::google::protobuf::MessageLite {
   // implements Message ----------------------------------------------
   
   LineRuleProto* New() const;
-  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
   void CopyFrom(const LineRuleProto& from);
   void MergeFrom(const LineRuleProto& from);
   void Clear();
@@ -268,6 +327,7 @@ class LineRuleProto : public ::google::protobuf::MessageLite {
       ::google::protobuf::io::CodedInputStream* input);
   void SerializeWithCachedSizes(
       ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
   int GetCachedSize() const { return _cached_size_; }
   private:
   void SharedCtor();
@@ -275,7 +335,7 @@ class LineRuleProto : public ::google::protobuf::MessageLite {
   void SetCachedSize(int size) const;
   public:
   
-  ::std::string GetTypeName() const;
+  ::google::protobuf::Metadata GetMetadata() const;
   
   // nested types ----------------------------------------------------
   
@@ -349,6 +409,8 @@ class LineRuleProto : public ::google::protobuf::MessageLite {
   inline void set_has_cap();
   inline void clear_has_cap();
   
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+  
   double width_;
   ::DashDotProto* dashdot_;
   ::google::protobuf::uint32 color_;
@@ -369,7 +431,7 @@ class LineRuleProto : public ::google::protobuf::MessageLite {
 };
 // -------------------------------------------------------------------
 
-class LineDefProto : public ::google::protobuf::MessageLite {
+class LineDefProto : public ::google::protobuf::Message {
  public:
   LineDefProto();
   virtual ~LineDefProto();
@@ -381,6 +443,15 @@ class LineDefProto : public ::google::protobuf::MessageLite {
     return *this;
   }
   
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+  
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+  
+  static const ::google::protobuf::Descriptor* descriptor();
   static const LineDefProto& default_instance();
   
   void Swap(LineDefProto* other);
@@ -388,7 +459,8 @@ class LineDefProto : public ::google::protobuf::MessageLite {
   // implements Message ----------------------------------------------
   
   LineDefProto* New() const;
-  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
   void CopyFrom(const LineDefProto& from);
   void MergeFrom(const LineDefProto& from);
   void Clear();
@@ -399,6 +471,7 @@ class LineDefProto : public ::google::protobuf::MessageLite {
       ::google::protobuf::io::CodedInputStream* input);
   void SerializeWithCachedSizes(
       ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
   int GetCachedSize() const { return _cached_size_; }
   private:
   void SharedCtor();
@@ -406,7 +479,7 @@ class LineDefProto : public ::google::protobuf::MessageLite {
   void SetCachedSize(int size) const;
   public:
   
-  ::std::string GetTypeName() const;
+  ::google::protobuf::Metadata GetMetadata() const;
   
   // nested types ----------------------------------------------------
   
@@ -471,6 +544,8 @@ class LineDefProto : public ::google::protobuf::MessageLite {
   inline void set_has_cap();
   inline void clear_has_cap();
   
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+  
   double width_;
   ::DashDotProto* dashdot_;
   ::google::protobuf::uint32 color_;
@@ -490,7 +565,7 @@ class LineDefProto : public ::google::protobuf::MessageLite {
 };
 // -------------------------------------------------------------------
 
-class AreaRuleProto : public ::google::protobuf::MessageLite {
+class AreaRuleProto : public ::google::protobuf::Message {
  public:
   AreaRuleProto();
   virtual ~AreaRuleProto();
@@ -502,6 +577,15 @@ class AreaRuleProto : public ::google::protobuf::MessageLite {
     return *this;
   }
   
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+  
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+  
+  static const ::google::protobuf::Descriptor* descriptor();
   static const AreaRuleProto& default_instance();
   
   void Swap(AreaRuleProto* other);
@@ -509,7 +593,8 @@ class AreaRuleProto : public ::google::protobuf::MessageLite {
   // implements Message ----------------------------------------------
   
   AreaRuleProto* New() const;
-  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
   void CopyFrom(const AreaRuleProto& from);
   void MergeFrom(const AreaRuleProto& from);
   void Clear();
@@ -520,6 +605,7 @@ class AreaRuleProto : public ::google::protobuf::MessageLite {
       ::google::protobuf::io::CodedInputStream* input);
   void SerializeWithCachedSizes(
       ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
   int GetCachedSize() const { return _cached_size_; }
   private:
   void SharedCtor();
@@ -527,7 +613,7 @@ class AreaRuleProto : public ::google::protobuf::MessageLite {
   void SetCachedSize(int size) const;
   public:
   
-  ::std::string GetTypeName() const;
+  ::google::protobuf::Metadata GetMetadata() const;
   
   // nested types ----------------------------------------------------
   
@@ -564,6 +650,8 @@ class AreaRuleProto : public ::google::protobuf::MessageLite {
   inline void set_has_priority();
   inline void clear_has_priority();
   
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+  
   ::LineDefProto* border_;
   ::google::protobuf::uint32 color_;
   ::google::protobuf::int32 priority_;
@@ -580,7 +668,7 @@ class AreaRuleProto : public ::google::protobuf::MessageLite {
 };
 // -------------------------------------------------------------------
 
-class SymbolRuleProto : public ::google::protobuf::MessageLite {
+class SymbolRuleProto : public ::google::protobuf::Message {
  public:
   SymbolRuleProto();
   virtual ~SymbolRuleProto();
@@ -592,6 +680,15 @@ class SymbolRuleProto : public ::google::protobuf::MessageLite {
     return *this;
   }
   
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+  
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+  
+  static const ::google::protobuf::Descriptor* descriptor();
   static const SymbolRuleProto& default_instance();
   
   void Swap(SymbolRuleProto* other);
@@ -599,7 +696,8 @@ class SymbolRuleProto : public ::google::protobuf::MessageLite {
   // implements Message ----------------------------------------------
   
   SymbolRuleProto* New() const;
-  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
   void CopyFrom(const SymbolRuleProto& from);
   void MergeFrom(const SymbolRuleProto& from);
   void Clear();
@@ -610,6 +708,7 @@ class SymbolRuleProto : public ::google::protobuf::MessageLite {
       ::google::protobuf::io::CodedInputStream* input);
   void SerializeWithCachedSizes(
       ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
   int GetCachedSize() const { return _cached_size_; }
   private:
   void SharedCtor();
@@ -617,7 +716,7 @@ class SymbolRuleProto : public ::google::protobuf::MessageLite {
   void SetCachedSize(int size) const;
   public:
   
-  ::std::string GetTypeName() const;
+  ::google::protobuf::Metadata GetMetadata() const;
   
   // nested types ----------------------------------------------------
   
@@ -657,6 +756,8 @@ class SymbolRuleProto : public ::google::protobuf::MessageLite {
   inline void set_has_priority();
   inline void clear_has_priority();
   
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+  
   ::std::string* name_;
   ::google::protobuf::int32 apply_for_type_;
   ::google::protobuf::int32 priority_;
@@ -673,7 +774,7 @@ class SymbolRuleProto : public ::google::protobuf::MessageLite {
 };
 // -------------------------------------------------------------------
 
-class CaptionDefProto : public ::google::protobuf::MessageLite {
+class CaptionDefProto : public ::google::protobuf::Message {
  public:
   CaptionDefProto();
   virtual ~CaptionDefProto();
@@ -685,6 +786,15 @@ class CaptionDefProto : public ::google::protobuf::MessageLite {
     return *this;
   }
   
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+  
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+  
+  static const ::google::protobuf::Descriptor* descriptor();
   static const CaptionDefProto& default_instance();
   
   void Swap(CaptionDefProto* other);
@@ -692,7 +802,8 @@ class CaptionDefProto : public ::google::protobuf::MessageLite {
   // implements Message ----------------------------------------------
   
   CaptionDefProto* New() const;
-  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
   void CopyFrom(const CaptionDefProto& from);
   void MergeFrom(const CaptionDefProto& from);
   void Clear();
@@ -703,6 +814,7 @@ class CaptionDefProto : public ::google::protobuf::MessageLite {
       ::google::protobuf::io::CodedInputStream* input);
   void SerializeWithCachedSizes(
       ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
   int GetCachedSize() const { return _cached_size_; }
   private:
   void SharedCtor();
@@ -710,7 +822,7 @@ class CaptionDefProto : public ::google::protobuf::MessageLite {
   void SetCachedSize(int size) const;
   public:
   
-  ::std::string GetTypeName() const;
+  ::google::protobuf::Metadata GetMetadata() const;
   
   // nested types ----------------------------------------------------
   
@@ -737,6 +849,20 @@ class CaptionDefProto : public ::google::protobuf::MessageLite {
   inline ::google::protobuf::uint32 stroke_color() const;
   inline void set_stroke_color(::google::protobuf::uint32 value);
   
+  // optional int32 offset_x = 4;
+  inline bool has_offset_x() const;
+  inline void clear_offset_x();
+  static const int kOffsetXFieldNumber = 4;
+  inline ::google::protobuf::int32 offset_x() const;
+  inline void set_offset_x(::google::protobuf::int32 value);
+  
+  // optional int32 offset_y = 5;
+  inline bool has_offset_y() const;
+  inline void clear_offset_y();
+  static const int kOffsetYFieldNumber = 5;
+  inline ::google::protobuf::int32 offset_y() const;
+  inline void set_offset_y(::google::protobuf::int32 value);
+  
   // @@protoc_insertion_point(class_scope:CaptionDefProto)
  private:
   inline void set_has_height();
@@ -745,13 +871,21 @@ class CaptionDefProto : public ::google::protobuf::MessageLite {
   inline void clear_has_color();
   inline void set_has_stroke_color();
   inline void clear_has_stroke_color();
+  inline void set_has_offset_x();
+  inline void clear_has_offset_x();
+  inline void set_has_offset_y();
+  inline void clear_has_offset_y();
+  
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
   
   ::google::protobuf::int32 height_;
   ::google::protobuf::uint32 color_;
   ::google::protobuf::uint32 stroke_color_;
+  ::google::protobuf::int32 offset_x_;
+  ::google::protobuf::int32 offset_y_;
   
   mutable int _cached_size_;
-  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
+  ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32];
   
   friend void  protobuf_AddDesc_drules_5fstruct_2eproto();
   friend void protobuf_AssignDesc_drules_5fstruct_2eproto();
@@ -762,7 +896,7 @@ class CaptionDefProto : public ::google::protobuf::MessageLite {
 };
 // -------------------------------------------------------------------
 
-class CaptionRuleProto : public ::google::protobuf::MessageLite {
+class CaptionRuleProto : public ::google::protobuf::Message {
  public:
   CaptionRuleProto();
   virtual ~CaptionRuleProto();
@@ -774,6 +908,15 @@ class CaptionRuleProto : public ::google::protobuf::MessageLite {
     return *this;
   }
   
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+  
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+  
+  static const ::google::protobuf::Descriptor* descriptor();
   static const CaptionRuleProto& default_instance();
   
   void Swap(CaptionRuleProto* other);
@@ -781,7 +924,8 @@ class CaptionRuleProto : public ::google::protobuf::MessageLite {
   // implements Message ----------------------------------------------
   
   CaptionRuleProto* New() const;
-  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
   void CopyFrom(const CaptionRuleProto& from);
   void MergeFrom(const CaptionRuleProto& from);
   void Clear();
@@ -792,6 +936,7 @@ class CaptionRuleProto : public ::google::protobuf::MessageLite {
       ::google::protobuf::io::CodedInputStream* input);
   void SerializeWithCachedSizes(
       ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
   int GetCachedSize() const { return _cached_size_; }
   private:
   void SharedCtor();
@@ -799,7 +944,7 @@ class CaptionRuleProto : public ::google::protobuf::MessageLite {
   void SetCachedSize(int size) const;
   public:
   
-  ::std::string GetTypeName() const;
+  ::google::protobuf::Metadata GetMetadata() const;
   
   // nested types ----------------------------------------------------
   
@@ -837,6 +982,8 @@ class CaptionRuleProto : public ::google::protobuf::MessageLite {
   inline void set_has_priority();
   inline void clear_has_priority();
   
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+  
   ::CaptionDefProto* primary_;
   ::CaptionDefProto* secondary_;
   ::google::protobuf::int32 priority_;
@@ -853,7 +1000,7 @@ class CaptionRuleProto : public ::google::protobuf::MessageLite {
 };
 // -------------------------------------------------------------------
 
-class CircleRuleProto : public ::google::protobuf::MessageLite {
+class CircleRuleProto : public ::google::protobuf::Message {
  public:
   CircleRuleProto();
   virtual ~CircleRuleProto();
@@ -865,6 +1012,15 @@ class CircleRuleProto : public ::google::protobuf::MessageLite {
     return *this;
   }
   
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+  
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+  
+  static const ::google::protobuf::Descriptor* descriptor();
   static const CircleRuleProto& default_instance();
   
   void Swap(CircleRuleProto* other);
@@ -872,7 +1028,8 @@ class CircleRuleProto : public ::google::protobuf::MessageLite {
   // implements Message ----------------------------------------------
   
   CircleRuleProto* New() const;
-  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
   void CopyFrom(const CircleRuleProto& from);
   void MergeFrom(const CircleRuleProto& from);
   void Clear();
@@ -883,6 +1040,7 @@ class CircleRuleProto : public ::google::protobuf::MessageLite {
       ::google::protobuf::io::CodedInputStream* input);
   void SerializeWithCachedSizes(
       ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
   int GetCachedSize() const { return _cached_size_; }
   private:
   void SharedCtor();
@@ -890,7 +1048,7 @@ class CircleRuleProto : public ::google::protobuf::MessageLite {
   void SetCachedSize(int size) const;
   public:
   
-  ::std::string GetTypeName() const;
+  ::google::protobuf::Metadata GetMetadata() const;
   
   // nested types ----------------------------------------------------
   
@@ -936,6 +1094,8 @@ class CircleRuleProto : public ::google::protobuf::MessageLite {
   inline void set_has_priority();
   inline void clear_has_priority();
   
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+  
   double radius_;
   ::LineDefProto* border_;
   ::google::protobuf::uint32 color_;
@@ -953,7 +1113,7 @@ class CircleRuleProto : public ::google::protobuf::MessageLite {
 };
 // -------------------------------------------------------------------
 
-class PathTextRuleProto : public ::google::protobuf::MessageLite {
+class PathTextRuleProto : public ::google::protobuf::Message {
  public:
   PathTextRuleProto();
   virtual ~PathTextRuleProto();
@@ -965,6 +1125,15 @@ class PathTextRuleProto : public ::google::protobuf::MessageLite {
     return *this;
   }
   
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+  
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+  
+  static const ::google::protobuf::Descriptor* descriptor();
   static const PathTextRuleProto& default_instance();
   
   void Swap(PathTextRuleProto* other);
@@ -972,7 +1141,8 @@ class PathTextRuleProto : public ::google::protobuf::MessageLite {
   // implements Message ----------------------------------------------
   
   PathTextRuleProto* New() const;
-  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
   void CopyFrom(const PathTextRuleProto& from);
   void MergeFrom(const PathTextRuleProto& from);
   void Clear();
@@ -983,6 +1153,7 @@ class PathTextRuleProto : public ::google::protobuf::MessageLite {
       ::google::protobuf::io::CodedInputStream* input);
   void SerializeWithCachedSizes(
       ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
   int GetCachedSize() const { return _cached_size_; }
   private:
   void SharedCtor();
@@ -990,7 +1161,7 @@ class PathTextRuleProto : public ::google::protobuf::MessageLite {
   void SetCachedSize(int size) const;
   public:
   
-  ::std::string GetTypeName() const;
+  ::google::protobuf::Metadata GetMetadata() const;
   
   // nested types ----------------------------------------------------
   
@@ -1028,6 +1199,8 @@ class PathTextRuleProto : public ::google::protobuf::MessageLite {
   inline void set_has_priority();
   inline void clear_has_priority();
   
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+  
   ::CaptionDefProto* primary_;
   ::CaptionDefProto* secondary_;
   ::google::protobuf::int32 priority_;
@@ -1044,7 +1217,7 @@ class PathTextRuleProto : public ::google::protobuf::MessageLite {
 };
 // -------------------------------------------------------------------
 
-class DrawElementProto : public ::google::protobuf::MessageLite {
+class DrawElementProto : public ::google::protobuf::Message {
  public:
   DrawElementProto();
   virtual ~DrawElementProto();
@@ -1056,6 +1229,15 @@ class DrawElementProto : public ::google::protobuf::MessageLite {
     return *this;
   }
   
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+  
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+  
+  static const ::google::protobuf::Descriptor* descriptor();
   static const DrawElementProto& default_instance();
   
   void Swap(DrawElementProto* other);
@@ -1063,7 +1245,8 @@ class DrawElementProto : public ::google::protobuf::MessageLite {
   // implements Message ----------------------------------------------
   
   DrawElementProto* New() const;
-  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
   void CopyFrom(const DrawElementProto& from);
   void MergeFrom(const DrawElementProto& from);
   void Clear();
@@ -1074,6 +1257,7 @@ class DrawElementProto : public ::google::protobuf::MessageLite {
       ::google::protobuf::io::CodedInputStream* input);
   void SerializeWithCachedSizes(
       ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
   int GetCachedSize() const { return _cached_size_; }
   private:
   void SharedCtor();
@@ -1081,7 +1265,7 @@ class DrawElementProto : public ::google::protobuf::MessageLite {
   void SetCachedSize(int size) const;
   public:
   
-  ::std::string GetTypeName() const;
+  ::google::protobuf::Metadata GetMetadata() const;
   
   // nested types ----------------------------------------------------
   
@@ -1161,6 +1345,8 @@ class DrawElementProto : public ::google::protobuf::MessageLite {
   inline void set_has_path_text();
   inline void clear_has_path_text();
   
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+  
   ::google::protobuf::RepeatedPtrField< ::LineRuleProto > lines_;
   ::AreaRuleProto* area_;
   ::SymbolRuleProto* symbol_;
@@ -1181,7 +1367,7 @@ class DrawElementProto : public ::google::protobuf::MessageLite {
 };
 // -------------------------------------------------------------------
 
-class ClassifElementProto : public ::google::protobuf::MessageLite {
+class ClassifElementProto : public ::google::protobuf::Message {
  public:
   ClassifElementProto();
   virtual ~ClassifElementProto();
@@ -1193,6 +1379,15 @@ class ClassifElementProto : public ::google::protobuf::MessageLite {
     return *this;
   }
   
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+  
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+  
+  static const ::google::protobuf::Descriptor* descriptor();
   static const ClassifElementProto& default_instance();
   
   void Swap(ClassifElementProto* other);
@@ -1200,7 +1395,8 @@ class ClassifElementProto : public ::google::protobuf::MessageLite {
   // implements Message ----------------------------------------------
   
   ClassifElementProto* New() const;
-  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
   void CopyFrom(const ClassifElementProto& from);
   void MergeFrom(const ClassifElementProto& from);
   void Clear();
@@ -1211,6 +1407,7 @@ class ClassifElementProto : public ::google::protobuf::MessageLite {
       ::google::protobuf::io::CodedInputStream* input);
   void SerializeWithCachedSizes(
       ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
   int GetCachedSize() const { return _cached_size_; }
   private:
   void SharedCtor();
@@ -1218,7 +1415,7 @@ class ClassifElementProto : public ::google::protobuf::MessageLite {
   void SetCachedSize(int size) const;
   public:
   
-  ::std::string GetTypeName() const;
+  ::google::protobuf::Metadata GetMetadata() const;
   
   // nested types ----------------------------------------------------
   
@@ -1252,6 +1449,8 @@ class ClassifElementProto : public ::google::protobuf::MessageLite {
   inline void set_has_name();
   inline void clear_has_name();
   
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+  
   ::std::string* name_;
   ::google::protobuf::RepeatedPtrField< ::DrawElementProto > element_;
   
@@ -1267,7 +1466,7 @@ class ClassifElementProto : public ::google::protobuf::MessageLite {
 };
 // -------------------------------------------------------------------
 
-class ContainerProto : public ::google::protobuf::MessageLite {
+class ContainerProto : public ::google::protobuf::Message {
  public:
   ContainerProto();
   virtual ~ContainerProto();
@@ -1279,6 +1478,15 @@ class ContainerProto : public ::google::protobuf::MessageLite {
     return *this;
   }
   
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+  
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+  
+  static const ::google::protobuf::Descriptor* descriptor();
   static const ContainerProto& default_instance();
   
   void Swap(ContainerProto* other);
@@ -1286,7 +1494,8 @@ class ContainerProto : public ::google::protobuf::MessageLite {
   // implements Message ----------------------------------------------
   
   ContainerProto* New() const;
-  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from);
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
   void CopyFrom(const ContainerProto& from);
   void MergeFrom(const ContainerProto& from);
   void Clear();
@@ -1297,6 +1506,7 @@ class ContainerProto : public ::google::protobuf::MessageLite {
       ::google::protobuf::io::CodedInputStream* input);
   void SerializeWithCachedSizes(
       ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
   int GetCachedSize() const { return _cached_size_; }
   private:
   void SharedCtor();
@@ -1304,7 +1514,7 @@ class ContainerProto : public ::google::protobuf::MessageLite {
   void SetCachedSize(int size) const;
   public:
   
-  ::std::string GetTypeName() const;
+  ::google::protobuf::Metadata GetMetadata() const;
   
   // nested types ----------------------------------------------------
   
@@ -1325,6 +1535,8 @@ class ContainerProto : public ::google::protobuf::MessageLite {
   // @@protoc_insertion_point(class_scope:ContainerProto)
  private:
   
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+  
   ::google::protobuf::RepeatedPtrField< ::ClassifElementProto > cont_;
   
   mutable int _cached_size_;
@@ -2076,6 +2288,50 @@ inline void CaptionDefProto::set_stroke_color(::google::protobuf::uint32 value)
   stroke_color_ = value;
 }
 
+// optional int32 offset_x = 4;
+inline bool CaptionDefProto::has_offset_x() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void CaptionDefProto::set_has_offset_x() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void CaptionDefProto::clear_has_offset_x() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void CaptionDefProto::clear_offset_x() {
+  offset_x_ = 0;
+  clear_has_offset_x();
+}
+inline ::google::protobuf::int32 CaptionDefProto::offset_x() const {
+  return offset_x_;
+}
+inline void CaptionDefProto::set_offset_x(::google::protobuf::int32 value) {
+  set_has_offset_x();
+  offset_x_ = value;
+}
+
+// optional int32 offset_y = 5;
+inline bool CaptionDefProto::has_offset_y() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void CaptionDefProto::set_has_offset_y() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void CaptionDefProto::clear_has_offset_y() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void CaptionDefProto::clear_offset_y() {
+  offset_y_ = 0;
+  clear_has_offset_y();
+}
+inline ::google::protobuf::int32 CaptionDefProto::offset_y() const {
+  return offset_y_;
+}
+inline void CaptionDefProto::set_offset_y(::google::protobuf::int32 value) {
+  set_has_offset_y();
+  offset_y_ = value;
+}
+
 // -------------------------------------------------------------------
 
 // CaptionRuleProto
@@ -2658,6 +2914,23 @@ ContainerProto::mutable_cont() {
 
 // @@protoc_insertion_point(namespace_scope)
 
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< LineJoin>() {
+  return LineJoin_descriptor();
+}
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< LineCap>() {
+  return LineCap_descriptor();
+}
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
 // @@protoc_insertion_point(global_scope)
 
 #endif  // PROTOBUF_drules_5fstruct_2eproto__INCLUDED