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

#include "define.pb.h"

#include <algorithm>

#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/wire_format_lite.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/reflection_ops.h>
#include <google/protobuf/wire_format.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
extern PROTOBUF_INTERNAL_EXPORT_define_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_LossResult_define_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_define_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_MeasureLidar_define_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_define_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_Region_define_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_define_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_RegionEtc_define_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_define_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_measure_info_define_2eproto;
class LossResultDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<LossResult> _instance;
} _LossResult_default_instance_;
class DetectResultDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<DetectResult> _instance;
} _DetectResult_default_instance_;
class RegionEtcDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<RegionEtc> _instance;
} _RegionEtc_default_instance_;
class RegionDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<Region> _instance;
} _Region_default_instance_;
class MeasureLidarDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<MeasureLidar> _instance;
} _MeasureLidar_default_instance_;
class MeasureConfigDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<MeasureConfig> _instance;
} _MeasureConfig_default_instance_;
class measure_infoDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<measure_info> _instance;
} _measure_info_default_instance_;
class measure_statuDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<measure_statu> _instance;
} _measure_statu_default_instance_;
static void InitDefaultsscc_info_DetectResult_define_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_DetectResult_default_instance_;
    new (ptr) ::DetectResult();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::DetectResult::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_DetectResult_define_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_DetectResult_define_2eproto}, {
      &scc_info_LossResult_define_2eproto.base,}};

static void InitDefaultsscc_info_LossResult_define_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_LossResult_default_instance_;
    new (ptr) ::LossResult();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::LossResult::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_LossResult_define_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_LossResult_define_2eproto}, {}};

static void InitDefaultsscc_info_MeasureConfig_define_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_MeasureConfig_default_instance_;
    new (ptr) ::MeasureConfig();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::MeasureConfig::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_MeasureConfig_define_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_MeasureConfig_define_2eproto}, {
      &scc_info_MeasureLidar_define_2eproto.base,}};

static void InitDefaultsscc_info_MeasureLidar_define_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_MeasureLidar_default_instance_;
    new (ptr) ::MeasureLidar();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::MeasureLidar::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_MeasureLidar_define_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_MeasureLidar_define_2eproto}, {
      &scc_info_Region_define_2eproto.base,}};

static void InitDefaultsscc_info_Region_define_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_Region_default_instance_;
    new (ptr) ::Region();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::Region::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_Region_define_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_Region_define_2eproto}, {
      &scc_info_RegionEtc_define_2eproto.base,}};

static void InitDefaultsscc_info_RegionEtc_define_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_RegionEtc_default_instance_;
    new (ptr) ::RegionEtc();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::RegionEtc::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_RegionEtc_define_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_RegionEtc_define_2eproto}, {}};

static void InitDefaultsscc_info_measure_info_define_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_measure_info_default_instance_;
    new (ptr) ::measure_info();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::measure_info::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_measure_info_define_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, 0, InitDefaultsscc_info_measure_info_define_2eproto}, {}};

static void InitDefaultsscc_info_measure_statu_define_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::_measure_statu_default_instance_;
    new (ptr) ::measure_statu();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::measure_statu::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_measure_statu_define_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, 0, InitDefaultsscc_info_measure_statu_define_2eproto}, {
      &scc_info_measure_info_define_2eproto.base,}};

static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_define_2eproto[8];
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_define_2eproto[2];
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_define_2eproto = nullptr;

const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_define_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  PROTOBUF_FIELD_OFFSET(::LossResult, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::LossResult, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::LossResult, lf_loss_),
  PROTOBUF_FIELD_OFFSET(::LossResult, rf_loss_),
  PROTOBUF_FIELD_OFFSET(::LossResult, lb_loss_),
  PROTOBUF_FIELD_OFFSET(::LossResult, rb_loss_),
  PROTOBUF_FIELD_OFFSET(::LossResult, total_avg_loss_),
  0,
  1,
  2,
  3,
  4,
  PROTOBUF_FIELD_OFFSET(::DetectResult, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::DetectResult, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::DetectResult, cx_),
  PROTOBUF_FIELD_OFFSET(::DetectResult, cy_),
  PROTOBUF_FIELD_OFFSET(::DetectResult, theta_),
  PROTOBUF_FIELD_OFFSET(::DetectResult, wheel_base_),
  PROTOBUF_FIELD_OFFSET(::DetectResult, width_),
  PROTOBUF_FIELD_OFFSET(::DetectResult, body_width_),
  PROTOBUF_FIELD_OFFSET(::DetectResult, front_theta_),
  PROTOBUF_FIELD_OFFSET(::DetectResult, single_wheel_width_),
  PROTOBUF_FIELD_OFFSET(::DetectResult, single_wheel_length_),
  PROTOBUF_FIELD_OFFSET(::DetectResult, success_),
  PROTOBUF_FIELD_OFFSET(::DetectResult, loss_),
  1,
  2,
  3,
  4,
  5,
  6,
  7,
  8,
  9,
  10,
  0,
  PROTOBUF_FIELD_OFFSET(::RegionEtc, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::RegionEtc, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::RegionEtc, maxx_),
  PROTOBUF_FIELD_OFFSET(::RegionEtc, minx_),
  PROTOBUF_FIELD_OFFSET(::RegionEtc, maxy_),
  PROTOBUF_FIELD_OFFSET(::RegionEtc, miny_),
  PROTOBUF_FIELD_OFFSET(::RegionEtc, maxz_),
  PROTOBUF_FIELD_OFFSET(::RegionEtc, minz_),
  0,
  1,
  2,
  3,
  4,
  5,
  PROTOBUF_FIELD_OFFSET(::Region, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::Region, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::Region, cut_region_),
  PROTOBUF_FIELD_OFFSET(::Region, turnplate_cx_),
  PROTOBUF_FIELD_OFFSET(::Region, turnplate_cy_),
  PROTOBUF_FIELD_OFFSET(::Region, border_minx_),
  PROTOBUF_FIELD_OFFSET(::Region, border_maxx_),
  PROTOBUF_FIELD_OFFSET(::Region, plc_offsetx_),
  PROTOBUF_FIELD_OFFSET(::Region, plc_offsety_),
  PROTOBUF_FIELD_OFFSET(::Region, plc_offset_degree_),
  PROTOBUF_FIELD_OFFSET(::Region, plc_border_miny_),
  PROTOBUF_FIELD_OFFSET(::Region, plc_border_maxy_),
  PROTOBUF_FIELD_OFFSET(::Region, car_min_width_),
  PROTOBUF_FIELD_OFFSET(::Region, car_max_width_),
  PROTOBUF_FIELD_OFFSET(::Region, car_min_wheelbase_),
  PROTOBUF_FIELD_OFFSET(::Region, car_max_wheelbase_),
  PROTOBUF_FIELD_OFFSET(::Region, turnplate_angle_min_),
  PROTOBUF_FIELD_OFFSET(::Region, turnplate_angle_max_),
  PROTOBUF_FIELD_OFFSET(::Region, turnplate_angle_limit_anti_clockwise_),
  PROTOBUF_FIELD_OFFSET(::Region, turnplate_angle_limit_clockwise_),
  0,
  1,
  2,
  3,
  4,
  5,
  6,
  7,
  8,
  9,
  10,
  11,
  12,
  13,
  14,
  15,
  16,
  17,
  PROTOBUF_FIELD_OFFSET(::MeasureLidar, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::MeasureLidar, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::MeasureLidar, measuretopic_),
  PROTOBUF_FIELD_OFFSET(::MeasureLidar, region_),
  PROTOBUF_FIELD_OFFSET(::MeasureLidar, lidartopic_),
  0,
  1,
  ~0u,
  PROTOBUF_FIELD_OFFSET(::MeasureConfig, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::MeasureConfig, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::MeasureConfig, sendtopics_),
  PROTOBUF_FIELD_OFFSET(::MeasureConfig, lidartopics_),
  PROTOBUF_FIELD_OFFSET(::MeasureConfig, measures_),
  0,
  1,
  ~0u,
  PROTOBUF_FIELD_OFFSET(::measure_info, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::measure_info, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::measure_info, cx_),
  PROTOBUF_FIELD_OFFSET(::measure_info, cy_),
  PROTOBUF_FIELD_OFFSET(::measure_info, theta_),
  PROTOBUF_FIELD_OFFSET(::measure_info, length_),
  PROTOBUF_FIELD_OFFSET(::measure_info, width_),
  PROTOBUF_FIELD_OFFSET(::measure_info, height_),
  PROTOBUF_FIELD_OFFSET(::measure_info, wheelbase_),
  PROTOBUF_FIELD_OFFSET(::measure_info, front_theta_),
  PROTOBUF_FIELD_OFFSET(::measure_info, border_statu_),
  PROTOBUF_FIELD_OFFSET(::measure_info, ground_status_),
  PROTOBUF_FIELD_OFFSET(::measure_info, is_stop_),
  0,
  1,
  2,
  3,
  4,
  5,
  6,
  7,
  8,
  9,
  10,
  PROTOBUF_FIELD_OFFSET(::measure_statu, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::measure_statu, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::measure_statu, info_),
  0,
};
static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  { 0, 10, sizeof(::LossResult)},
  { 15, 31, sizeof(::DetectResult)},
  { 42, 53, sizeof(::RegionEtc)},
  { 59, 82, sizeof(::Region)},
  { 100, 108, sizeof(::MeasureLidar)},
  { 111, 119, sizeof(::MeasureConfig)},
  { 122, 138, sizeof(::measure_info)},
  { 149, 155, sizeof(::measure_statu)},
};

static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_LossResult_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_DetectResult_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_RegionEtc_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_Region_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_MeasureLidar_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_MeasureConfig_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_measure_info_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::_measure_statu_default_instance_),
};

const char descriptor_table_protodef_define_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
  "\n\014define.proto\"h\n\nLossResult\022\017\n\007lf_loss\030"
  "\001 \002(\002\022\017\n\007rf_loss\030\002 \002(\002\022\017\n\007lb_loss\030\003 \002(\002\022"
  "\017\n\007rb_loss\030\004 \002(\002\022\026\n\016total_avg_loss\030\005 \002(\002"
  "\"\346\001\n\014DetectResult\022\n\n\002cx\030\001 \002(\002\022\n\n\002cy\030\002 \002("
  "\002\022\r\n\005theta\030\003 \002(\002\022\022\n\nwheel_base\030\004 \002(\002\022\r\n\005"
  "width\030\005 \002(\002\022\022\n\nbody_width\030\006 \002(\002\022\023\n\013front"
  "_theta\030\007 \002(\002\022\032\n\022single_wheel_width\030\010 \002(\002"
  "\022\033\n\023single_wheel_length\030\t \002(\002\022\017\n\007success"
  "\030\n \002(\010\022\031\n\004loss\030\013 \002(\0132\013.LossResult\"_\n\tReg"
  "ionEtc\022\014\n\004maxx\030\001 \002(\001\022\014\n\004minx\030\002 \002(\001\022\014\n\004ma"
  "xy\030\003 \002(\001\022\014\n\004miny\030\004 \002(\001\022\014\n\004maxz\030\005 \002(\001\022\014\n\004"
  "minz\030\006 \002(\001\"\352\003\n\006Region\022\036\n\ncut_region\030\001 \002("
  "\0132\n.RegionEtc\022\024\n\014turnplate_cx\030\002 \002(\002\022\024\n\014t"
  "urnplate_cy\030\003 \002(\002\022\023\n\013border_minx\030\004 \002(\002\022\023"
  "\n\013border_maxx\030\005 \002(\002\022\023\n\013plc_offsetx\030\006 \002(\002"
  "\022\023\n\013plc_offsety\030\007 \002(\002\022\031\n\021plc_offset_degr"
  "ee\030\010 \002(\002\022\027\n\017plc_border_miny\030\t \002(\002\022\027\n\017plc"
  "_border_maxy\030\n \002(\002\022\025\n\rcar_min_width\030\013 \002("
  "\002\022\025\n\rcar_max_width\030\014 \002(\002\022\031\n\021car_min_whee"
  "lbase\030\r \002(\002\022\031\n\021car_max_wheelbase\030\016 \002(\002\022\033"
  "\n\023turnplate_angle_min\030\017 \002(\002\022\033\n\023turnplate"
  "_angle_max\030\020 \002(\002\022,\n$turnplate_angle_limi"
  "t_anti_clockwise\030\021 \002(\002\022\'\n\037turnplate_angl"
  "e_limit_clockwise\030\022 \002(\002\"Q\n\014MeasureLidar\022"
  "\024\n\014measureTopic\030\001 \002(\t\022\027\n\006region\030\002 \002(\0132\007."
  "Region\022\022\n\nlidarTopic\030\005 \003(\t\"Y\n\rMeasureCon"
  "fig\022\022\n\nsendTopics\030\001 \002(\t\022\023\n\013lidarTopics\030\002"
  " \002(\t\022\037\n\010measures\030\005 \003(\0132\r.MeasureLidar\"\353\001"
  "\n\014measure_info\022\r\n\002cx\030\001 \002(\002:\0010\022\r\n\002cy\030\002 \002("
  "\002:\0010\022\020\n\005theta\030\003 \002(\002:\0010\022\021\n\006length\030\004 \002(\002:\001"
  "0\022\020\n\005width\030\005 \002(\002:\0010\022\021\n\006height\030\006 \002(\002:\0010\022\024"
  "\n\twheelbase\030\007 \002(\002:\0010\022\026\n\013front_theta\030\010 \002("
  "\002:\0010\022\027\n\014border_statu\030\t \002(\005:\0010\022\030\n\rground_"
  "status\030\n \002(\005:\0011\022\022\n\007is_stop\030\013 \002(\005:\0012\",\n\rm"
  "easure_statu\022\033\n\004info\030\001 \002(\0132\r.measure_inf"
  "o*\241\002\n\014Range_status\022\021\n\rRange_correct\020\000\022\016\n"
  "\nRange_back\020\001\022\016\n\nRange_left\020\002\022\017\n\013Range_r"
  "ight\020\004\022\017\n\013Range_front\020\010\022\020\n\014Range_bottom\020"
  "\020\022\023\n\017Range_car_width\020 \022\027\n\023Range_car_whee"
  "lbase\020@\022\033\n\026Range_angle_anti_clock\020\200\001\022\026\n\021"
  "Range_angle_clock\020\200\002\022 \n\033Range_steering_w"
  "heel_nozero\020\200\004\022\016\n\tRange_top\020\200\010\022\025\n\020Range_"
  "car_moving\020\200\020*F\n\014Ground_statu\022\006\n\002ok\020\000\022\t\n"
  "\005Noise\020\001\022\013\n\007Nothing\020\002\022\026\n\022Car_border_reac"
  "hed\020\003"
  ;
static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_define_2eproto_deps[1] = {
};
static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_define_2eproto_sccs[8] = {
  &scc_info_DetectResult_define_2eproto.base,
  &scc_info_LossResult_define_2eproto.base,
  &scc_info_MeasureConfig_define_2eproto.base,
  &scc_info_MeasureLidar_define_2eproto.base,
  &scc_info_Region_define_2eproto.base,
  &scc_info_RegionEtc_define_2eproto.base,
  &scc_info_measure_info_define_2eproto.base,
  &scc_info_measure_statu_define_2eproto.base,
};
static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_define_2eproto_once;
const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_define_2eproto = {
  false, false, descriptor_table_protodef_define_2eproto, "define.proto", 1765,
  &descriptor_table_define_2eproto_once, descriptor_table_define_2eproto_sccs, descriptor_table_define_2eproto_deps, 8, 0,
  schemas, file_default_instances, TableStruct_define_2eproto::offsets,
  file_level_metadata_define_2eproto, 8, file_level_enum_descriptors_define_2eproto, file_level_service_descriptors_define_2eproto,
};

// Force running AddDescriptors() at dynamic initialization time.
static bool dynamic_init_dummy_define_2eproto = (static_cast<void>(::PROTOBUF_NAMESPACE_ID::internal::AddDescriptors(&descriptor_table_define_2eproto)), true);
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Range_status_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_define_2eproto);
  return file_level_enum_descriptors_define_2eproto[0];
}
bool Range_status_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 4:
    case 8:
    case 16:
    case 32:
    case 64:
    case 128:
    case 256:
    case 512:
    case 1024:
    case 2048:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Ground_statu_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_define_2eproto);
  return file_level_enum_descriptors_define_2eproto[1];
}
bool Ground_statu_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}


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

void LossResult::InitAsDefaultInstance() {
}
class LossResult::_Internal {
 public:
  using HasBits = decltype(std::declval<LossResult>()._has_bits_);
  static void set_has_lf_loss(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_rf_loss(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_lb_loss(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_rb_loss(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_total_avg_loss(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x0000001f) ^ 0x0000001f) != 0;
  }
};

LossResult::LossResult(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:LossResult)
}
LossResult::LossResult(const LossResult& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&lf_loss_, &from.lf_loss_,
    static_cast<size_t>(reinterpret_cast<char*>(&total_avg_loss_) -
    reinterpret_cast<char*>(&lf_loss_)) + sizeof(total_avg_loss_));
  // @@protoc_insertion_point(copy_constructor:LossResult)
}

void LossResult::SharedCtor() {
  ::memset(&lf_loss_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&total_avg_loss_) -
      reinterpret_cast<char*>(&lf_loss_)) + sizeof(total_avg_loss_));
}

LossResult::~LossResult() {
  // @@protoc_insertion_point(destructor:LossResult)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void LossResult::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void LossResult::ArenaDtor(void* object) {
  LossResult* _this = reinterpret_cast< LossResult* >(object);
  (void)_this;
}
void LossResult::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void LossResult::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const LossResult& LossResult::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_LossResult_define_2eproto.base);
  return *internal_default_instance();
}


void LossResult::Clear() {
// @@protoc_insertion_point(message_clear_start:LossResult)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    ::memset(&lf_loss_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&total_avg_loss_) -
        reinterpret_cast<char*>(&lf_loss_)) + sizeof(total_avg_loss_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* LossResult::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // required float lf_loss = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13)) {
          _Internal::set_has_lf_loss(&has_bits);
          lf_loss_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // required float rf_loss = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) {
          _Internal::set_has_rf_loss(&has_bits);
          rf_loss_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // required float lb_loss = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 29)) {
          _Internal::set_has_lb_loss(&has_bits);
          lb_loss_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // required float rb_loss = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 37)) {
          _Internal::set_has_rb_loss(&has_bits);
          rb_loss_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // required float total_avg_loss = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 45)) {
          _Internal::set_has_total_avg_loss(&has_bits);
          total_avg_loss_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* LossResult::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:LossResult)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required float lf_loss = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_lf_loss(), target);
  }

  // required float rf_loss = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_rf_loss(), target);
  }

  // required float lb_loss = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_lb_loss(), target);
  }

  // required float rb_loss = 4;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(4, this->_internal_rb_loss(), target);
  }

  // required float total_avg_loss = 5;
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(5, this->_internal_total_avg_loss(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:LossResult)
  return target;
}

size_t LossResult::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:LossResult)
  size_t total_size = 0;

  if (_internal_has_lf_loss()) {
    // required float lf_loss = 1;
    total_size += 1 + 4;
  }

  if (_internal_has_rf_loss()) {
    // required float rf_loss = 2;
    total_size += 1 + 4;
  }

  if (_internal_has_lb_loss()) {
    // required float lb_loss = 3;
    total_size += 1 + 4;
  }

  if (_internal_has_rb_loss()) {
    // required float rb_loss = 4;
    total_size += 1 + 4;
  }

  if (_internal_has_total_avg_loss()) {
    // required float total_avg_loss = 5;
    total_size += 1 + 4;
  }

  return total_size;
}
size_t LossResult::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:LossResult)
  size_t total_size = 0;

  if (((_has_bits_[0] & 0x0000001f) ^ 0x0000001f) == 0) {  // All required fields are present.
    // required float lf_loss = 1;
    total_size += 1 + 4;

    // required float rf_loss = 2;
    total_size += 1 + 4;

    // required float lb_loss = 3;
    total_size += 1 + 4;

    // required float rb_loss = 4;
    total_size += 1 + 4;

    // required float total_avg_loss = 5;
    total_size += 1 + 4;

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void LossResult::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:LossResult)
  GOOGLE_DCHECK_NE(&from, this);
  const LossResult* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<LossResult>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:LossResult)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:LossResult)
    MergeFrom(*source);
  }
}

void LossResult::MergeFrom(const LossResult& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:LossResult)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    if (cached_has_bits & 0x00000001u) {
      lf_loss_ = from.lf_loss_;
    }
    if (cached_has_bits & 0x00000002u) {
      rf_loss_ = from.rf_loss_;
    }
    if (cached_has_bits & 0x00000004u) {
      lb_loss_ = from.lb_loss_;
    }
    if (cached_has_bits & 0x00000008u) {
      rb_loss_ = from.rb_loss_;
    }
    if (cached_has_bits & 0x00000010u) {
      total_avg_loss_ = from.total_avg_loss_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void LossResult::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:LossResult)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void LossResult::CopyFrom(const LossResult& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:LossResult)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool LossResult::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  return true;
}

void LossResult::InternalSwap(LossResult* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(LossResult, total_avg_loss_)
      + sizeof(LossResult::total_avg_loss_)
      - PROTOBUF_FIELD_OFFSET(LossResult, lf_loss_)>(
          reinterpret_cast<char*>(&lf_loss_),
          reinterpret_cast<char*>(&other->lf_loss_));
}

::PROTOBUF_NAMESPACE_ID::Metadata LossResult::GetMetadata() const {
  return GetMetadataStatic();
}


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

void DetectResult::InitAsDefaultInstance() {
  ::_DetectResult_default_instance_._instance.get_mutable()->loss_ = const_cast< ::LossResult*>(
      ::LossResult::internal_default_instance());
}
class DetectResult::_Internal {
 public:
  using HasBits = decltype(std::declval<DetectResult>()._has_bits_);
  static void set_has_cx(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_cy(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_theta(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_wheel_base(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_width(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
  static void set_has_body_width(HasBits* has_bits) {
    (*has_bits)[0] |= 64u;
  }
  static void set_has_front_theta(HasBits* has_bits) {
    (*has_bits)[0] |= 128u;
  }
  static void set_has_single_wheel_width(HasBits* has_bits) {
    (*has_bits)[0] |= 256u;
  }
  static void set_has_single_wheel_length(HasBits* has_bits) {
    (*has_bits)[0] |= 512u;
  }
  static void set_has_success(HasBits* has_bits) {
    (*has_bits)[0] |= 1024u;
  }
  static const ::LossResult& loss(const DetectResult* msg);
  static void set_has_loss(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x000007ff) ^ 0x000007ff) != 0;
  }
};

const ::LossResult&
DetectResult::_Internal::loss(const DetectResult* msg) {
  return *msg->loss_;
}
DetectResult::DetectResult(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:DetectResult)
}
DetectResult::DetectResult(const DetectResult& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_loss()) {
    loss_ = new ::LossResult(*from.loss_);
  } else {
    loss_ = nullptr;
  }
  ::memcpy(&cx_, &from.cx_,
    static_cast<size_t>(reinterpret_cast<char*>(&success_) -
    reinterpret_cast<char*>(&cx_)) + sizeof(success_));
  // @@protoc_insertion_point(copy_constructor:DetectResult)
}

void DetectResult::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_DetectResult_define_2eproto.base);
  ::memset(&loss_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&success_) -
      reinterpret_cast<char*>(&loss_)) + sizeof(success_));
}

DetectResult::~DetectResult() {
  // @@protoc_insertion_point(destructor:DetectResult)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void DetectResult::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  if (this != internal_default_instance()) delete loss_;
}

void DetectResult::ArenaDtor(void* object) {
  DetectResult* _this = reinterpret_cast< DetectResult* >(object);
  (void)_this;
}
void DetectResult::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void DetectResult::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const DetectResult& DetectResult::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_DetectResult_define_2eproto.base);
  return *internal_default_instance();
}


void DetectResult::Clear() {
// @@protoc_insertion_point(message_clear_start:DetectResult)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(loss_ != nullptr);
    loss_->Clear();
  }
  if (cached_has_bits & 0x000000feu) {
    ::memset(&cx_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&front_theta_) -
        reinterpret_cast<char*>(&cx_)) + sizeof(front_theta_));
  }
  if (cached_has_bits & 0x00000700u) {
    ::memset(&single_wheel_width_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&success_) -
        reinterpret_cast<char*>(&single_wheel_width_)) + sizeof(success_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* DetectResult::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // required float cx = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13)) {
          _Internal::set_has_cx(&has_bits);
          cx_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // required float cy = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) {
          _Internal::set_has_cy(&has_bits);
          cy_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // required float theta = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 29)) {
          _Internal::set_has_theta(&has_bits);
          theta_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // required float wheel_base = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 37)) {
          _Internal::set_has_wheel_base(&has_bits);
          wheel_base_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // required float width = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 45)) {
          _Internal::set_has_width(&has_bits);
          width_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // required float body_width = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 53)) {
          _Internal::set_has_body_width(&has_bits);
          body_width_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // required float front_theta = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 61)) {
          _Internal::set_has_front_theta(&has_bits);
          front_theta_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // required float single_wheel_width = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 69)) {
          _Internal::set_has_single_wheel_width(&has_bits);
          single_wheel_width_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // required float single_wheel_length = 9;
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 77)) {
          _Internal::set_has_single_wheel_length(&has_bits);
          single_wheel_length_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // required bool success = 10;
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 80)) {
          _Internal::set_has_success(&has_bits);
          success_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // required .LossResult loss = 11;
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) {
          ptr = ctx->ParseMessage(_internal_mutable_loss(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* DetectResult::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:DetectResult)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required float cx = 1;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_cx(), target);
  }

  // required float cy = 2;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_cy(), target);
  }

  // required float theta = 3;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_theta(), target);
  }

  // required float wheel_base = 4;
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(4, this->_internal_wheel_base(), target);
  }

  // required float width = 5;
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(5, this->_internal_width(), target);
  }

  // required float body_width = 6;
  if (cached_has_bits & 0x00000040u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(6, this->_internal_body_width(), target);
  }

  // required float front_theta = 7;
  if (cached_has_bits & 0x00000080u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(7, this->_internal_front_theta(), target);
  }

  // required float single_wheel_width = 8;
  if (cached_has_bits & 0x00000100u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(8, this->_internal_single_wheel_width(), target);
  }

  // required float single_wheel_length = 9;
  if (cached_has_bits & 0x00000200u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(9, this->_internal_single_wheel_length(), target);
  }

  // required bool success = 10;
  if (cached_has_bits & 0x00000400u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(10, this->_internal_success(), target);
  }

  // required .LossResult loss = 11;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        11, _Internal::loss(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:DetectResult)
  return target;
}

size_t DetectResult::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:DetectResult)
  size_t total_size = 0;

  if (_internal_has_loss()) {
    // required .LossResult loss = 11;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *loss_);
  }

  if (_internal_has_cx()) {
    // required float cx = 1;
    total_size += 1 + 4;
  }

  if (_internal_has_cy()) {
    // required float cy = 2;
    total_size += 1 + 4;
  }

  if (_internal_has_theta()) {
    // required float theta = 3;
    total_size += 1 + 4;
  }

  if (_internal_has_wheel_base()) {
    // required float wheel_base = 4;
    total_size += 1 + 4;
  }

  if (_internal_has_width()) {
    // required float width = 5;
    total_size += 1 + 4;
  }

  if (_internal_has_body_width()) {
    // required float body_width = 6;
    total_size += 1 + 4;
  }

  if (_internal_has_front_theta()) {
    // required float front_theta = 7;
    total_size += 1 + 4;
  }

  if (_internal_has_single_wheel_width()) {
    // required float single_wheel_width = 8;
    total_size += 1 + 4;
  }

  if (_internal_has_single_wheel_length()) {
    // required float single_wheel_length = 9;
    total_size += 1 + 4;
  }

  if (_internal_has_success()) {
    // required bool success = 10;
    total_size += 1 + 1;
  }

  return total_size;
}
size_t DetectResult::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:DetectResult)
  size_t total_size = 0;

  if (((_has_bits_[0] & 0x000007ff) ^ 0x000007ff) == 0) {  // All required fields are present.
    // required .LossResult loss = 11;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *loss_);

    // required float cx = 1;
    total_size += 1 + 4;

    // required float cy = 2;
    total_size += 1 + 4;

    // required float theta = 3;
    total_size += 1 + 4;

    // required float wheel_base = 4;
    total_size += 1 + 4;

    // required float width = 5;
    total_size += 1 + 4;

    // required float body_width = 6;
    total_size += 1 + 4;

    // required float front_theta = 7;
    total_size += 1 + 4;

    // required float single_wheel_width = 8;
    total_size += 1 + 4;

    // required float single_wheel_length = 9;
    total_size += 1 + 4;

    // required bool success = 10;
    total_size += 1 + 1;

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void DetectResult::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:DetectResult)
  GOOGLE_DCHECK_NE(&from, this);
  const DetectResult* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<DetectResult>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:DetectResult)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:DetectResult)
    MergeFrom(*source);
  }
}

void DetectResult::MergeFrom(const DetectResult& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:DetectResult)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_mutable_loss()->::LossResult::MergeFrom(from._internal_loss());
    }
    if (cached_has_bits & 0x00000002u) {
      cx_ = from.cx_;
    }
    if (cached_has_bits & 0x00000004u) {
      cy_ = from.cy_;
    }
    if (cached_has_bits & 0x00000008u) {
      theta_ = from.theta_;
    }
    if (cached_has_bits & 0x00000010u) {
      wheel_base_ = from.wheel_base_;
    }
    if (cached_has_bits & 0x00000020u) {
      width_ = from.width_;
    }
    if (cached_has_bits & 0x00000040u) {
      body_width_ = from.body_width_;
    }
    if (cached_has_bits & 0x00000080u) {
      front_theta_ = from.front_theta_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 0x00000700u) {
    if (cached_has_bits & 0x00000100u) {
      single_wheel_width_ = from.single_wheel_width_;
    }
    if (cached_has_bits & 0x00000200u) {
      single_wheel_length_ = from.single_wheel_length_;
    }
    if (cached_has_bits & 0x00000400u) {
      success_ = from.success_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void DetectResult::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:DetectResult)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void DetectResult::CopyFrom(const DetectResult& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:DetectResult)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool DetectResult::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  if (_internal_has_loss()) {
    if (!loss_->IsInitialized()) return false;
  }
  return true;
}

void DetectResult::InternalSwap(DetectResult* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(DetectResult, success_)
      + sizeof(DetectResult::success_)
      - PROTOBUF_FIELD_OFFSET(DetectResult, loss_)>(
          reinterpret_cast<char*>(&loss_),
          reinterpret_cast<char*>(&other->loss_));
}

::PROTOBUF_NAMESPACE_ID::Metadata DetectResult::GetMetadata() const {
  return GetMetadataStatic();
}


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

void RegionEtc::InitAsDefaultInstance() {
}
class RegionEtc::_Internal {
 public:
  using HasBits = decltype(std::declval<RegionEtc>()._has_bits_);
  static void set_has_maxx(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_minx(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_maxy(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_miny(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_maxz(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_minz(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x0000003f) ^ 0x0000003f) != 0;
  }
};

RegionEtc::RegionEtc(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:RegionEtc)
}
RegionEtc::RegionEtc(const RegionEtc& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&maxx_, &from.maxx_,
    static_cast<size_t>(reinterpret_cast<char*>(&minz_) -
    reinterpret_cast<char*>(&maxx_)) + sizeof(minz_));
  // @@protoc_insertion_point(copy_constructor:RegionEtc)
}

void RegionEtc::SharedCtor() {
  ::memset(&maxx_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&minz_) -
      reinterpret_cast<char*>(&maxx_)) + sizeof(minz_));
}

RegionEtc::~RegionEtc() {
  // @@protoc_insertion_point(destructor:RegionEtc)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void RegionEtc::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void RegionEtc::ArenaDtor(void* object) {
  RegionEtc* _this = reinterpret_cast< RegionEtc* >(object);
  (void)_this;
}
void RegionEtc::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void RegionEtc::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const RegionEtc& RegionEtc::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_RegionEtc_define_2eproto.base);
  return *internal_default_instance();
}


void RegionEtc::Clear() {
// @@protoc_insertion_point(message_clear_start:RegionEtc)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000003fu) {
    ::memset(&maxx_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&minz_) -
        reinterpret_cast<char*>(&maxx_)) + sizeof(minz_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* RegionEtc::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // required double maxx = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 9)) {
          _Internal::set_has_maxx(&has_bits);
          maxx_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      // required double minx = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 17)) {
          _Internal::set_has_minx(&has_bits);
          minx_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      // required double maxy = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 25)) {
          _Internal::set_has_maxy(&has_bits);
          maxy_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      // required double miny = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 33)) {
          _Internal::set_has_miny(&has_bits);
          miny_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      // required double maxz = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 41)) {
          _Internal::set_has_maxz(&has_bits);
          maxz_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      // required double minz = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 49)) {
          _Internal::set_has_minz(&has_bits);
          minz_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* RegionEtc::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:RegionEtc)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required double maxx = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(1, this->_internal_maxx(), target);
  }

  // required double minx = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(2, this->_internal_minx(), target);
  }

  // required double maxy = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(3, this->_internal_maxy(), target);
  }

  // required double miny = 4;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(4, this->_internal_miny(), target);
  }

  // required double maxz = 5;
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(5, this->_internal_maxz(), target);
  }

  // required double minz = 6;
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(6, this->_internal_minz(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:RegionEtc)
  return target;
}

size_t RegionEtc::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:RegionEtc)
  size_t total_size = 0;

  if (_internal_has_maxx()) {
    // required double maxx = 1;
    total_size += 1 + 8;
  }

  if (_internal_has_minx()) {
    // required double minx = 2;
    total_size += 1 + 8;
  }

  if (_internal_has_maxy()) {
    // required double maxy = 3;
    total_size += 1 + 8;
  }

  if (_internal_has_miny()) {
    // required double miny = 4;
    total_size += 1 + 8;
  }

  if (_internal_has_maxz()) {
    // required double maxz = 5;
    total_size += 1 + 8;
  }

  if (_internal_has_minz()) {
    // required double minz = 6;
    total_size += 1 + 8;
  }

  return total_size;
}
size_t RegionEtc::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:RegionEtc)
  size_t total_size = 0;

  if (((_has_bits_[0] & 0x0000003f) ^ 0x0000003f) == 0) {  // All required fields are present.
    // required double maxx = 1;
    total_size += 1 + 8;

    // required double minx = 2;
    total_size += 1 + 8;

    // required double maxy = 3;
    total_size += 1 + 8;

    // required double miny = 4;
    total_size += 1 + 8;

    // required double maxz = 5;
    total_size += 1 + 8;

    // required double minz = 6;
    total_size += 1 + 8;

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void RegionEtc::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:RegionEtc)
  GOOGLE_DCHECK_NE(&from, this);
  const RegionEtc* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RegionEtc>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:RegionEtc)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:RegionEtc)
    MergeFrom(*source);
  }
}

void RegionEtc::MergeFrom(const RegionEtc& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:RegionEtc)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000003fu) {
    if (cached_has_bits & 0x00000001u) {
      maxx_ = from.maxx_;
    }
    if (cached_has_bits & 0x00000002u) {
      minx_ = from.minx_;
    }
    if (cached_has_bits & 0x00000004u) {
      maxy_ = from.maxy_;
    }
    if (cached_has_bits & 0x00000008u) {
      miny_ = from.miny_;
    }
    if (cached_has_bits & 0x00000010u) {
      maxz_ = from.maxz_;
    }
    if (cached_has_bits & 0x00000020u) {
      minz_ = from.minz_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void RegionEtc::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:RegionEtc)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void RegionEtc::CopyFrom(const RegionEtc& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:RegionEtc)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool RegionEtc::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  return true;
}

void RegionEtc::InternalSwap(RegionEtc* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(RegionEtc, minz_)
      + sizeof(RegionEtc::minz_)
      - PROTOBUF_FIELD_OFFSET(RegionEtc, maxx_)>(
          reinterpret_cast<char*>(&maxx_),
          reinterpret_cast<char*>(&other->maxx_));
}

::PROTOBUF_NAMESPACE_ID::Metadata RegionEtc::GetMetadata() const {
  return GetMetadataStatic();
}


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

void Region::InitAsDefaultInstance() {
  ::_Region_default_instance_._instance.get_mutable()->cut_region_ = const_cast< ::RegionEtc*>(
      ::RegionEtc::internal_default_instance());
}
class Region::_Internal {
 public:
  using HasBits = decltype(std::declval<Region>()._has_bits_);
  static const ::RegionEtc& cut_region(const Region* msg);
  static void set_has_cut_region(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_turnplate_cx(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_turnplate_cy(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_border_minx(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_border_maxx(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_plc_offsetx(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
  static void set_has_plc_offsety(HasBits* has_bits) {
    (*has_bits)[0] |= 64u;
  }
  static void set_has_plc_offset_degree(HasBits* has_bits) {
    (*has_bits)[0] |= 128u;
  }
  static void set_has_plc_border_miny(HasBits* has_bits) {
    (*has_bits)[0] |= 256u;
  }
  static void set_has_plc_border_maxy(HasBits* has_bits) {
    (*has_bits)[0] |= 512u;
  }
  static void set_has_car_min_width(HasBits* has_bits) {
    (*has_bits)[0] |= 1024u;
  }
  static void set_has_car_max_width(HasBits* has_bits) {
    (*has_bits)[0] |= 2048u;
  }
  static void set_has_car_min_wheelbase(HasBits* has_bits) {
    (*has_bits)[0] |= 4096u;
  }
  static void set_has_car_max_wheelbase(HasBits* has_bits) {
    (*has_bits)[0] |= 8192u;
  }
  static void set_has_turnplate_angle_min(HasBits* has_bits) {
    (*has_bits)[0] |= 16384u;
  }
  static void set_has_turnplate_angle_max(HasBits* has_bits) {
    (*has_bits)[0] |= 32768u;
  }
  static void set_has_turnplate_angle_limit_anti_clockwise(HasBits* has_bits) {
    (*has_bits)[0] |= 65536u;
  }
  static void set_has_turnplate_angle_limit_clockwise(HasBits* has_bits) {
    (*has_bits)[0] |= 131072u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x0003ffff) ^ 0x0003ffff) != 0;
  }
};

const ::RegionEtc&
Region::_Internal::cut_region(const Region* msg) {
  return *msg->cut_region_;
}
Region::Region(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:Region)
}
Region::Region(const Region& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_cut_region()) {
    cut_region_ = new ::RegionEtc(*from.cut_region_);
  } else {
    cut_region_ = nullptr;
  }
  ::memcpy(&turnplate_cx_, &from.turnplate_cx_,
    static_cast<size_t>(reinterpret_cast<char*>(&turnplate_angle_limit_clockwise_) -
    reinterpret_cast<char*>(&turnplate_cx_)) + sizeof(turnplate_angle_limit_clockwise_));
  // @@protoc_insertion_point(copy_constructor:Region)
}

void Region::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Region_define_2eproto.base);
  ::memset(&cut_region_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&turnplate_angle_limit_clockwise_) -
      reinterpret_cast<char*>(&cut_region_)) + sizeof(turnplate_angle_limit_clockwise_));
}

Region::~Region() {
  // @@protoc_insertion_point(destructor:Region)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void Region::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  if (this != internal_default_instance()) delete cut_region_;
}

void Region::ArenaDtor(void* object) {
  Region* _this = reinterpret_cast< Region* >(object);
  (void)_this;
}
void Region::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void Region::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const Region& Region::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Region_define_2eproto.base);
  return *internal_default_instance();
}


void Region::Clear() {
// @@protoc_insertion_point(message_clear_start:Region)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(cut_region_ != nullptr);
    cut_region_->Clear();
  }
  if (cached_has_bits & 0x000000feu) {
    ::memset(&turnplate_cx_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&plc_offset_degree_) -
        reinterpret_cast<char*>(&turnplate_cx_)) + sizeof(plc_offset_degree_));
  }
  if (cached_has_bits & 0x0000ff00u) {
    ::memset(&plc_border_miny_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&turnplate_angle_max_) -
        reinterpret_cast<char*>(&plc_border_miny_)) + sizeof(turnplate_angle_max_));
  }
  if (cached_has_bits & 0x00030000u) {
    ::memset(&turnplate_angle_limit_anti_clockwise_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&turnplate_angle_limit_clockwise_) -
        reinterpret_cast<char*>(&turnplate_angle_limit_anti_clockwise_)) + sizeof(turnplate_angle_limit_clockwise_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Region::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // required .RegionEtc cut_region = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_cut_region(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // required float turnplate_cx = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) {
          _Internal::set_has_turnplate_cx(&has_bits);
          turnplate_cx_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // required float turnplate_cy = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 29)) {
          _Internal::set_has_turnplate_cy(&has_bits);
          turnplate_cy_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // required float border_minx = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 37)) {
          _Internal::set_has_border_minx(&has_bits);
          border_minx_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // required float border_maxx = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 45)) {
          _Internal::set_has_border_maxx(&has_bits);
          border_maxx_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // required float plc_offsetx = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 53)) {
          _Internal::set_has_plc_offsetx(&has_bits);
          plc_offsetx_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // required float plc_offsety = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 61)) {
          _Internal::set_has_plc_offsety(&has_bits);
          plc_offsety_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // required float plc_offset_degree = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 69)) {
          _Internal::set_has_plc_offset_degree(&has_bits);
          plc_offset_degree_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // required float plc_border_miny = 9;
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 77)) {
          _Internal::set_has_plc_border_miny(&has_bits);
          plc_border_miny_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // required float plc_border_maxy = 10;
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 85)) {
          _Internal::set_has_plc_border_maxy(&has_bits);
          plc_border_maxy_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // required float car_min_width = 11;
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 93)) {
          _Internal::set_has_car_min_width(&has_bits);
          car_min_width_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // required float car_max_width = 12;
      case 12:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 101)) {
          _Internal::set_has_car_max_width(&has_bits);
          car_max_width_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // required float car_min_wheelbase = 13;
      case 13:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 109)) {
          _Internal::set_has_car_min_wheelbase(&has_bits);
          car_min_wheelbase_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // required float car_max_wheelbase = 14;
      case 14:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 117)) {
          _Internal::set_has_car_max_wheelbase(&has_bits);
          car_max_wheelbase_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // required float turnplate_angle_min = 15;
      case 15:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 125)) {
          _Internal::set_has_turnplate_angle_min(&has_bits);
          turnplate_angle_min_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // required float turnplate_angle_max = 16;
      case 16:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 133)) {
          _Internal::set_has_turnplate_angle_max(&has_bits);
          turnplate_angle_max_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // required float turnplate_angle_limit_anti_clockwise = 17;
      case 17:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 141)) {
          _Internal::set_has_turnplate_angle_limit_anti_clockwise(&has_bits);
          turnplate_angle_limit_anti_clockwise_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // required float turnplate_angle_limit_clockwise = 18;
      case 18:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 149)) {
          _Internal::set_has_turnplate_angle_limit_clockwise(&has_bits);
          turnplate_angle_limit_clockwise_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* Region::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:Region)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required .RegionEtc cut_region = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::cut_region(this), target, stream);
  }

  // required float turnplate_cx = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_turnplate_cx(), target);
  }

  // required float turnplate_cy = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_turnplate_cy(), target);
  }

  // required float border_minx = 4;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(4, this->_internal_border_minx(), target);
  }

  // required float border_maxx = 5;
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(5, this->_internal_border_maxx(), target);
  }

  // required float plc_offsetx = 6;
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(6, this->_internal_plc_offsetx(), target);
  }

  // required float plc_offsety = 7;
  if (cached_has_bits & 0x00000040u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(7, this->_internal_plc_offsety(), target);
  }

  // required float plc_offset_degree = 8;
  if (cached_has_bits & 0x00000080u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(8, this->_internal_plc_offset_degree(), target);
  }

  // required float plc_border_miny = 9;
  if (cached_has_bits & 0x00000100u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(9, this->_internal_plc_border_miny(), target);
  }

  // required float plc_border_maxy = 10;
  if (cached_has_bits & 0x00000200u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(10, this->_internal_plc_border_maxy(), target);
  }

  // required float car_min_width = 11;
  if (cached_has_bits & 0x00000400u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(11, this->_internal_car_min_width(), target);
  }

  // required float car_max_width = 12;
  if (cached_has_bits & 0x00000800u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(12, this->_internal_car_max_width(), target);
  }

  // required float car_min_wheelbase = 13;
  if (cached_has_bits & 0x00001000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(13, this->_internal_car_min_wheelbase(), target);
  }

  // required float car_max_wheelbase = 14;
  if (cached_has_bits & 0x00002000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(14, this->_internal_car_max_wheelbase(), target);
  }

  // required float turnplate_angle_min = 15;
  if (cached_has_bits & 0x00004000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(15, this->_internal_turnplate_angle_min(), target);
  }

  // required float turnplate_angle_max = 16;
  if (cached_has_bits & 0x00008000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(16, this->_internal_turnplate_angle_max(), target);
  }

  // required float turnplate_angle_limit_anti_clockwise = 17;
  if (cached_has_bits & 0x00010000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(17, this->_internal_turnplate_angle_limit_anti_clockwise(), target);
  }

  // required float turnplate_angle_limit_clockwise = 18;
  if (cached_has_bits & 0x00020000u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(18, this->_internal_turnplate_angle_limit_clockwise(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:Region)
  return target;
}

size_t Region::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:Region)
  size_t total_size = 0;

  if (_internal_has_cut_region()) {
    // required .RegionEtc cut_region = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *cut_region_);
  }

  if (_internal_has_turnplate_cx()) {
    // required float turnplate_cx = 2;
    total_size += 1 + 4;
  }

  if (_internal_has_turnplate_cy()) {
    // required float turnplate_cy = 3;
    total_size += 1 + 4;
  }

  if (_internal_has_border_minx()) {
    // required float border_minx = 4;
    total_size += 1 + 4;
  }

  if (_internal_has_border_maxx()) {
    // required float border_maxx = 5;
    total_size += 1 + 4;
  }

  if (_internal_has_plc_offsetx()) {
    // required float plc_offsetx = 6;
    total_size += 1 + 4;
  }

  if (_internal_has_plc_offsety()) {
    // required float plc_offsety = 7;
    total_size += 1 + 4;
  }

  if (_internal_has_plc_offset_degree()) {
    // required float plc_offset_degree = 8;
    total_size += 1 + 4;
  }

  if (_internal_has_plc_border_miny()) {
    // required float plc_border_miny = 9;
    total_size += 1 + 4;
  }

  if (_internal_has_plc_border_maxy()) {
    // required float plc_border_maxy = 10;
    total_size += 1 + 4;
  }

  if (_internal_has_car_min_width()) {
    // required float car_min_width = 11;
    total_size += 1 + 4;
  }

  if (_internal_has_car_max_width()) {
    // required float car_max_width = 12;
    total_size += 1 + 4;
  }

  if (_internal_has_car_min_wheelbase()) {
    // required float car_min_wheelbase = 13;
    total_size += 1 + 4;
  }

  if (_internal_has_car_max_wheelbase()) {
    // required float car_max_wheelbase = 14;
    total_size += 1 + 4;
  }

  if (_internal_has_turnplate_angle_min()) {
    // required float turnplate_angle_min = 15;
    total_size += 1 + 4;
  }

  if (_internal_has_turnplate_angle_max()) {
    // required float turnplate_angle_max = 16;
    total_size += 2 + 4;
  }

  if (_internal_has_turnplate_angle_limit_anti_clockwise()) {
    // required float turnplate_angle_limit_anti_clockwise = 17;
    total_size += 2 + 4;
  }

  if (_internal_has_turnplate_angle_limit_clockwise()) {
    // required float turnplate_angle_limit_clockwise = 18;
    total_size += 2 + 4;
  }

  return total_size;
}
size_t Region::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:Region)
  size_t total_size = 0;

  if (((_has_bits_[0] & 0x0003ffff) ^ 0x0003ffff) == 0) {  // All required fields are present.
    // required .RegionEtc cut_region = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *cut_region_);

    // required float turnplate_cx = 2;
    total_size += 1 + 4;

    // required float turnplate_cy = 3;
    total_size += 1 + 4;

    // required float border_minx = 4;
    total_size += 1 + 4;

    // required float border_maxx = 5;
    total_size += 1 + 4;

    // required float plc_offsetx = 6;
    total_size += 1 + 4;

    // required float plc_offsety = 7;
    total_size += 1 + 4;

    // required float plc_offset_degree = 8;
    total_size += 1 + 4;

    // required float plc_border_miny = 9;
    total_size += 1 + 4;

    // required float plc_border_maxy = 10;
    total_size += 1 + 4;

    // required float car_min_width = 11;
    total_size += 1 + 4;

    // required float car_max_width = 12;
    total_size += 1 + 4;

    // required float car_min_wheelbase = 13;
    total_size += 1 + 4;

    // required float car_max_wheelbase = 14;
    total_size += 1 + 4;

    // required float turnplate_angle_min = 15;
    total_size += 1 + 4;

    // required float turnplate_angle_max = 16;
    total_size += 2 + 4;

    // required float turnplate_angle_limit_anti_clockwise = 17;
    total_size += 2 + 4;

    // required float turnplate_angle_limit_clockwise = 18;
    total_size += 2 + 4;

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void Region::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:Region)
  GOOGLE_DCHECK_NE(&from, this);
  const Region* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<Region>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:Region)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:Region)
    MergeFrom(*source);
  }
}

void Region::MergeFrom(const Region& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:Region)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_mutable_cut_region()->::RegionEtc::MergeFrom(from._internal_cut_region());
    }
    if (cached_has_bits & 0x00000002u) {
      turnplate_cx_ = from.turnplate_cx_;
    }
    if (cached_has_bits & 0x00000004u) {
      turnplate_cy_ = from.turnplate_cy_;
    }
    if (cached_has_bits & 0x00000008u) {
      border_minx_ = from.border_minx_;
    }
    if (cached_has_bits & 0x00000010u) {
      border_maxx_ = from.border_maxx_;
    }
    if (cached_has_bits & 0x00000020u) {
      plc_offsetx_ = from.plc_offsetx_;
    }
    if (cached_has_bits & 0x00000040u) {
      plc_offsety_ = from.plc_offsety_;
    }
    if (cached_has_bits & 0x00000080u) {
      plc_offset_degree_ = from.plc_offset_degree_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 0x0000ff00u) {
    if (cached_has_bits & 0x00000100u) {
      plc_border_miny_ = from.plc_border_miny_;
    }
    if (cached_has_bits & 0x00000200u) {
      plc_border_maxy_ = from.plc_border_maxy_;
    }
    if (cached_has_bits & 0x00000400u) {
      car_min_width_ = from.car_min_width_;
    }
    if (cached_has_bits & 0x00000800u) {
      car_max_width_ = from.car_max_width_;
    }
    if (cached_has_bits & 0x00001000u) {
      car_min_wheelbase_ = from.car_min_wheelbase_;
    }
    if (cached_has_bits & 0x00002000u) {
      car_max_wheelbase_ = from.car_max_wheelbase_;
    }
    if (cached_has_bits & 0x00004000u) {
      turnplate_angle_min_ = from.turnplate_angle_min_;
    }
    if (cached_has_bits & 0x00008000u) {
      turnplate_angle_max_ = from.turnplate_angle_max_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 0x00030000u) {
    if (cached_has_bits & 0x00010000u) {
      turnplate_angle_limit_anti_clockwise_ = from.turnplate_angle_limit_anti_clockwise_;
    }
    if (cached_has_bits & 0x00020000u) {
      turnplate_angle_limit_clockwise_ = from.turnplate_angle_limit_clockwise_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void Region::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:Region)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void Region::CopyFrom(const Region& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:Region)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool Region::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  if (_internal_has_cut_region()) {
    if (!cut_region_->IsInitialized()) return false;
  }
  return true;
}

void Region::InternalSwap(Region* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Region, turnplate_angle_limit_clockwise_)
      + sizeof(Region::turnplate_angle_limit_clockwise_)
      - PROTOBUF_FIELD_OFFSET(Region, cut_region_)>(
          reinterpret_cast<char*>(&cut_region_),
          reinterpret_cast<char*>(&other->cut_region_));
}

::PROTOBUF_NAMESPACE_ID::Metadata Region::GetMetadata() const {
  return GetMetadataStatic();
}


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

void MeasureLidar::InitAsDefaultInstance() {
  ::_MeasureLidar_default_instance_._instance.get_mutable()->region_ = const_cast< ::Region*>(
      ::Region::internal_default_instance());
}
class MeasureLidar::_Internal {
 public:
  using HasBits = decltype(std::declval<MeasureLidar>()._has_bits_);
  static void set_has_measuretopic(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::Region& region(const MeasureLidar* msg);
  static void set_has_region(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000003) ^ 0x00000003) != 0;
  }
};

const ::Region&
MeasureLidar::_Internal::region(const MeasureLidar* msg) {
  return *msg->region_;
}
MeasureLidar::MeasureLidar(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena),
  lidartopic_(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:MeasureLidar)
}
MeasureLidar::MeasureLidar(const MeasureLidar& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_),
      lidartopic_(from.lidartopic_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  measuretopic_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_measuretopic()) {
    measuretopic_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_measuretopic(),
      GetArena());
  }
  if (from._internal_has_region()) {
    region_ = new ::Region(*from.region_);
  } else {
    region_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:MeasureLidar)
}

void MeasureLidar::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_MeasureLidar_define_2eproto.base);
  measuretopic_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  region_ = nullptr;
}

MeasureLidar::~MeasureLidar() {
  // @@protoc_insertion_point(destructor:MeasureLidar)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void MeasureLidar::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  measuretopic_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete region_;
}

void MeasureLidar::ArenaDtor(void* object) {
  MeasureLidar* _this = reinterpret_cast< MeasureLidar* >(object);
  (void)_this;
}
void MeasureLidar::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void MeasureLidar::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const MeasureLidar& MeasureLidar::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_MeasureLidar_define_2eproto.base);
  return *internal_default_instance();
}


void MeasureLidar::Clear() {
// @@protoc_insertion_point(message_clear_start:MeasureLidar)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  lidartopic_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      measuretopic_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(region_ != nullptr);
      region_->Clear();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* MeasureLidar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // required string measureTopic = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_measuretopic();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MeasureLidar.measureTopic");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // required .Region region = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_region(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated string lidarTopic = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr -= 1;
          do {
            ptr += 1;
            auto str = _internal_add_lidartopic();
            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
            #ifndef NDEBUG
            ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MeasureLidar.lidarTopic");
            #endif  // !NDEBUG
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* MeasureLidar::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:MeasureLidar)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required string measureTopic = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_measuretopic().data(), static_cast<int>(this->_internal_measuretopic().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "MeasureLidar.measureTopic");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_measuretopic(), target);
  }

  // required .Region region = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::region(this), target, stream);
  }

  // repeated string lidarTopic = 5;
  for (int i = 0, n = this->_internal_lidartopic_size(); i < n; i++) {
    const auto& s = this->_internal_lidartopic(i);
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      s.data(), static_cast<int>(s.length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "MeasureLidar.lidarTopic");
    target = stream->WriteString(5, s, target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:MeasureLidar)
  return target;
}

size_t MeasureLidar::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:MeasureLidar)
  size_t total_size = 0;

  if (_internal_has_measuretopic()) {
    // required string measureTopic = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_measuretopic());
  }

  if (_internal_has_region()) {
    // required .Region region = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *region_);
  }

  return total_size;
}
size_t MeasureLidar::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:MeasureLidar)
  size_t total_size = 0;

  if (((_has_bits_[0] & 0x00000003) ^ 0x00000003) == 0) {  // All required fields are present.
    // required string measureTopic = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_measuretopic());

    // required .Region region = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *region_);

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated string lidarTopic = 5;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(lidartopic_.size());
  for (int i = 0, n = lidartopic_.size(); i < n; i++) {
    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
      lidartopic_.Get(i));
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void MeasureLidar::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:MeasureLidar)
  GOOGLE_DCHECK_NE(&from, this);
  const MeasureLidar* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<MeasureLidar>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:MeasureLidar)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:MeasureLidar)
    MergeFrom(*source);
  }
}

void MeasureLidar::MergeFrom(const MeasureLidar& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:MeasureLidar)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  lidartopic_.MergeFrom(from.lidartopic_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_measuretopic(from._internal_measuretopic());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_region()->::Region::MergeFrom(from._internal_region());
    }
  }
}

void MeasureLidar::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:MeasureLidar)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void MeasureLidar::CopyFrom(const MeasureLidar& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:MeasureLidar)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MeasureLidar::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  if (_internal_has_region()) {
    if (!region_->IsInitialized()) return false;
  }
  return true;
}

void MeasureLidar::InternalSwap(MeasureLidar* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  lidartopic_.InternalSwap(&other->lidartopic_);
  measuretopic_.Swap(&other->measuretopic_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  swap(region_, other->region_);
}

::PROTOBUF_NAMESPACE_ID::Metadata MeasureLidar::GetMetadata() const {
  return GetMetadataStatic();
}


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

void MeasureConfig::InitAsDefaultInstance() {
}
class MeasureConfig::_Internal {
 public:
  using HasBits = decltype(std::declval<MeasureConfig>()._has_bits_);
  static void set_has_sendtopics(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_lidartopics(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000003) ^ 0x00000003) != 0;
  }
};

MeasureConfig::MeasureConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena),
  measures_(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:MeasureConfig)
}
MeasureConfig::MeasureConfig(const MeasureConfig& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_),
      measures_(from.measures_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  sendtopics_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_sendtopics()) {
    sendtopics_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_sendtopics(),
      GetArena());
  }
  lidartopics_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_lidartopics()) {
    lidartopics_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_lidartopics(),
      GetArena());
  }
  // @@protoc_insertion_point(copy_constructor:MeasureConfig)
}

void MeasureConfig::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_MeasureConfig_define_2eproto.base);
  sendtopics_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  lidartopics_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

MeasureConfig::~MeasureConfig() {
  // @@protoc_insertion_point(destructor:MeasureConfig)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void MeasureConfig::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  sendtopics_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  lidartopics_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void MeasureConfig::ArenaDtor(void* object) {
  MeasureConfig* _this = reinterpret_cast< MeasureConfig* >(object);
  (void)_this;
}
void MeasureConfig::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void MeasureConfig::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const MeasureConfig& MeasureConfig::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_MeasureConfig_define_2eproto.base);
  return *internal_default_instance();
}


void MeasureConfig::Clear() {
// @@protoc_insertion_point(message_clear_start:MeasureConfig)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  measures_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      sendtopics_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000002u) {
      lidartopics_.ClearNonDefaultToEmpty();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* MeasureConfig::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // required string sendTopics = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_sendtopics();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MeasureConfig.sendTopics");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // required string lidarTopics = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          auto str = _internal_mutable_lidartopics();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "MeasureConfig.lidarTopics");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .MeasureLidar measures = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_measures(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* MeasureConfig::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:MeasureConfig)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required string sendTopics = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_sendtopics().data(), static_cast<int>(this->_internal_sendtopics().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "MeasureConfig.sendTopics");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_sendtopics(), target);
  }

  // required string lidarTopics = 2;
  if (cached_has_bits & 0x00000002u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_lidartopics().data(), static_cast<int>(this->_internal_lidartopics().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "MeasureConfig.lidarTopics");
    target = stream->WriteStringMaybeAliased(
        2, this->_internal_lidartopics(), target);
  }

  // repeated .MeasureLidar measures = 5;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_measures_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(5, this->_internal_measures(i), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:MeasureConfig)
  return target;
}

size_t MeasureConfig::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:MeasureConfig)
  size_t total_size = 0;

  if (_internal_has_sendtopics()) {
    // required string sendTopics = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_sendtopics());
  }

  if (_internal_has_lidartopics()) {
    // required string lidarTopics = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_lidartopics());
  }

  return total_size;
}
size_t MeasureConfig::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:MeasureConfig)
  size_t total_size = 0;

  if (((_has_bits_[0] & 0x00000003) ^ 0x00000003) == 0) {  // All required fields are present.
    // required string sendTopics = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_sendtopics());

    // required string lidarTopics = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_lidartopics());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .MeasureLidar measures = 5;
  total_size += 1UL * this->_internal_measures_size();
  for (const auto& msg : this->measures_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void MeasureConfig::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:MeasureConfig)
  GOOGLE_DCHECK_NE(&from, this);
  const MeasureConfig* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<MeasureConfig>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:MeasureConfig)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:MeasureConfig)
    MergeFrom(*source);
  }
}

void MeasureConfig::MergeFrom(const MeasureConfig& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:MeasureConfig)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  measures_.MergeFrom(from.measures_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_sendtopics(from._internal_sendtopics());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_set_lidartopics(from._internal_lidartopics());
    }
  }
}

void MeasureConfig::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:MeasureConfig)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void MeasureConfig::CopyFrom(const MeasureConfig& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:MeasureConfig)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MeasureConfig::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(measures_)) return false;
  return true;
}

void MeasureConfig::InternalSwap(MeasureConfig* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  measures_.InternalSwap(&other->measures_);
  sendtopics_.Swap(&other->sendtopics_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  lidartopics_.Swap(&other->lidartopics_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}

::PROTOBUF_NAMESPACE_ID::Metadata MeasureConfig::GetMetadata() const {
  return GetMetadataStatic();
}


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

void measure_info::InitAsDefaultInstance() {
}
class measure_info::_Internal {
 public:
  using HasBits = decltype(std::declval<measure_info>()._has_bits_);
  static void set_has_cx(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_cy(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_theta(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_length(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_width(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_height(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
  static void set_has_wheelbase(HasBits* has_bits) {
    (*has_bits)[0] |= 64u;
  }
  static void set_has_front_theta(HasBits* has_bits) {
    (*has_bits)[0] |= 128u;
  }
  static void set_has_border_statu(HasBits* has_bits) {
    (*has_bits)[0] |= 256u;
  }
  static void set_has_ground_status(HasBits* has_bits) {
    (*has_bits)[0] |= 512u;
  }
  static void set_has_is_stop(HasBits* has_bits) {
    (*has_bits)[0] |= 1024u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x000007ff) ^ 0x000007ff) != 0;
  }
};

measure_info::measure_info(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:measure_info)
}
measure_info::measure_info(const measure_info& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&cx_, &from.cx_,
    static_cast<size_t>(reinterpret_cast<char*>(&is_stop_) -
    reinterpret_cast<char*>(&cx_)) + sizeof(is_stop_));
  // @@protoc_insertion_point(copy_constructor:measure_info)
}

void measure_info::SharedCtor() {
  ::memset(&cx_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&border_statu_) -
      reinterpret_cast<char*>(&cx_)) + sizeof(border_statu_));
  ground_status_ = 1;
  is_stop_ = 2;
}

measure_info::~measure_info() {
  // @@protoc_insertion_point(destructor:measure_info)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void measure_info::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
}

void measure_info::ArenaDtor(void* object) {
  measure_info* _this = reinterpret_cast< measure_info* >(object);
  (void)_this;
}
void measure_info::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void measure_info::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const measure_info& measure_info::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_measure_info_define_2eproto.base);
  return *internal_default_instance();
}


void measure_info::Clear() {
// @@protoc_insertion_point(message_clear_start:measure_info)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    ::memset(&cx_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&front_theta_) -
        reinterpret_cast<char*>(&cx_)) + sizeof(front_theta_));
  }
  if (cached_has_bits & 0x00000700u) {
    border_statu_ = 0;
    ground_status_ = 1;
    is_stop_ = 2;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* measure_info::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // required float cx = 1 [default = 0];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13)) {
          _Internal::set_has_cx(&has_bits);
          cx_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // required float cy = 2 [default = 0];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) {
          _Internal::set_has_cy(&has_bits);
          cy_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // required float theta = 3 [default = 0];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 29)) {
          _Internal::set_has_theta(&has_bits);
          theta_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // required float length = 4 [default = 0];
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 37)) {
          _Internal::set_has_length(&has_bits);
          length_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // required float width = 5 [default = 0];
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 45)) {
          _Internal::set_has_width(&has_bits);
          width_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // required float height = 6 [default = 0];
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 53)) {
          _Internal::set_has_height(&has_bits);
          height_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // required float wheelbase = 7 [default = 0];
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 61)) {
          _Internal::set_has_wheelbase(&has_bits);
          wheelbase_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // required float front_theta = 8 [default = 0];
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 69)) {
          _Internal::set_has_front_theta(&has_bits);
          front_theta_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
          ptr += sizeof(float);
        } else goto handle_unusual;
        continue;
      // required int32 border_statu = 9 [default = 0];
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 72)) {
          _Internal::set_has_border_statu(&has_bits);
          border_statu_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // required int32 ground_status = 10 [default = 1];
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 80)) {
          _Internal::set_has_ground_status(&has_bits);
          ground_status_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // required int32 is_stop = 11 [default = 2];
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 88)) {
          _Internal::set_has_is_stop(&has_bits);
          is_stop_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* measure_info::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:measure_info)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required float cx = 1 [default = 0];
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_cx(), target);
  }

  // required float cy = 2 [default = 0];
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_cy(), target);
  }

  // required float theta = 3 [default = 0];
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_theta(), target);
  }

  // required float length = 4 [default = 0];
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(4, this->_internal_length(), target);
  }

  // required float width = 5 [default = 0];
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(5, this->_internal_width(), target);
  }

  // required float height = 6 [default = 0];
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(6, this->_internal_height(), target);
  }

  // required float wheelbase = 7 [default = 0];
  if (cached_has_bits & 0x00000040u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(7, this->_internal_wheelbase(), target);
  }

  // required float front_theta = 8 [default = 0];
  if (cached_has_bits & 0x00000080u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(8, this->_internal_front_theta(), target);
  }

  // required int32 border_statu = 9 [default = 0];
  if (cached_has_bits & 0x00000100u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(9, this->_internal_border_statu(), target);
  }

  // required int32 ground_status = 10 [default = 1];
  if (cached_has_bits & 0x00000200u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(10, this->_internal_ground_status(), target);
  }

  // required int32 is_stop = 11 [default = 2];
  if (cached_has_bits & 0x00000400u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(11, this->_internal_is_stop(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:measure_info)
  return target;
}

size_t measure_info::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:measure_info)
  size_t total_size = 0;

  if (_internal_has_cx()) {
    // required float cx = 1 [default = 0];
    total_size += 1 + 4;
  }

  if (_internal_has_cy()) {
    // required float cy = 2 [default = 0];
    total_size += 1 + 4;
  }

  if (_internal_has_theta()) {
    // required float theta = 3 [default = 0];
    total_size += 1 + 4;
  }

  if (_internal_has_length()) {
    // required float length = 4 [default = 0];
    total_size += 1 + 4;
  }

  if (_internal_has_width()) {
    // required float width = 5 [default = 0];
    total_size += 1 + 4;
  }

  if (_internal_has_height()) {
    // required float height = 6 [default = 0];
    total_size += 1 + 4;
  }

  if (_internal_has_wheelbase()) {
    // required float wheelbase = 7 [default = 0];
    total_size += 1 + 4;
  }

  if (_internal_has_front_theta()) {
    // required float front_theta = 8 [default = 0];
    total_size += 1 + 4;
  }

  if (_internal_has_border_statu()) {
    // required int32 border_statu = 9 [default = 0];
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_border_statu());
  }

  if (_internal_has_ground_status()) {
    // required int32 ground_status = 10 [default = 1];
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_ground_status());
  }

  if (_internal_has_is_stop()) {
    // required int32 is_stop = 11 [default = 2];
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_is_stop());
  }

  return total_size;
}
size_t measure_info::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:measure_info)
  size_t total_size = 0;

  if (((_has_bits_[0] & 0x000007ff) ^ 0x000007ff) == 0) {  // All required fields are present.
    // required float cx = 1 [default = 0];
    total_size += 1 + 4;

    // required float cy = 2 [default = 0];
    total_size += 1 + 4;

    // required float theta = 3 [default = 0];
    total_size += 1 + 4;

    // required float length = 4 [default = 0];
    total_size += 1 + 4;

    // required float width = 5 [default = 0];
    total_size += 1 + 4;

    // required float height = 6 [default = 0];
    total_size += 1 + 4;

    // required float wheelbase = 7 [default = 0];
    total_size += 1 + 4;

    // required float front_theta = 8 [default = 0];
    total_size += 1 + 4;

    // required int32 border_statu = 9 [default = 0];
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_border_statu());

    // required int32 ground_status = 10 [default = 1];
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_ground_status());

    // required int32 is_stop = 11 [default = 2];
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_is_stop());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void measure_info::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:measure_info)
  GOOGLE_DCHECK_NE(&from, this);
  const measure_info* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<measure_info>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:measure_info)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:measure_info)
    MergeFrom(*source);
  }
}

void measure_info::MergeFrom(const measure_info& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:measure_info)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    if (cached_has_bits & 0x00000001u) {
      cx_ = from.cx_;
    }
    if (cached_has_bits & 0x00000002u) {
      cy_ = from.cy_;
    }
    if (cached_has_bits & 0x00000004u) {
      theta_ = from.theta_;
    }
    if (cached_has_bits & 0x00000008u) {
      length_ = from.length_;
    }
    if (cached_has_bits & 0x00000010u) {
      width_ = from.width_;
    }
    if (cached_has_bits & 0x00000020u) {
      height_ = from.height_;
    }
    if (cached_has_bits & 0x00000040u) {
      wheelbase_ = from.wheelbase_;
    }
    if (cached_has_bits & 0x00000080u) {
      front_theta_ = from.front_theta_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  if (cached_has_bits & 0x00000700u) {
    if (cached_has_bits & 0x00000100u) {
      border_statu_ = from.border_statu_;
    }
    if (cached_has_bits & 0x00000200u) {
      ground_status_ = from.ground_status_;
    }
    if (cached_has_bits & 0x00000400u) {
      is_stop_ = from.is_stop_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void measure_info::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:measure_info)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void measure_info::CopyFrom(const measure_info& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:measure_info)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool measure_info::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  return true;
}

void measure_info::InternalSwap(measure_info* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(measure_info, border_statu_)
      + sizeof(measure_info::border_statu_)
      - PROTOBUF_FIELD_OFFSET(measure_info, cx_)>(
          reinterpret_cast<char*>(&cx_),
          reinterpret_cast<char*>(&other->cx_));
  swap(ground_status_, other->ground_status_);
  swap(is_stop_, other->is_stop_);
}

::PROTOBUF_NAMESPACE_ID::Metadata measure_info::GetMetadata() const {
  return GetMetadataStatic();
}


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

void measure_statu::InitAsDefaultInstance() {
  ::_measure_statu_default_instance_._instance.get_mutable()->info_ = const_cast< ::measure_info*>(
      ::measure_info::internal_default_instance());
}
class measure_statu::_Internal {
 public:
  using HasBits = decltype(std::declval<measure_statu>()._has_bits_);
  static const ::measure_info& info(const measure_statu* msg);
  static void set_has_info(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0;
  }
};

const ::measure_info&
measure_statu::_Internal::info(const measure_statu* msg) {
  return *msg->info_;
}
measure_statu::measure_statu(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:measure_statu)
}
measure_statu::measure_statu(const measure_statu& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_info()) {
    info_ = new ::measure_info(*from.info_);
  } else {
    info_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:measure_statu)
}

void measure_statu::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_measure_statu_define_2eproto.base);
  info_ = nullptr;
}

measure_statu::~measure_statu() {
  // @@protoc_insertion_point(destructor:measure_statu)
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

void measure_statu::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  if (this != internal_default_instance()) delete info_;
}

void measure_statu::ArenaDtor(void* object) {
  measure_statu* _this = reinterpret_cast< measure_statu* >(object);
  (void)_this;
}
void measure_statu::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void measure_statu::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}
const measure_statu& measure_statu::default_instance() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_measure_statu_define_2eproto.base);
  return *internal_default_instance();
}


void measure_statu::Clear() {
// @@protoc_insertion_point(message_clear_start:measure_statu)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(info_ != nullptr);
    info_->Clear();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* measure_statu::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); (void)arena;
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    CHK_(ptr);
    switch (tag >> 3) {
      // required .measure_info info = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_info(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag & 7) == 4 || tag == 0) {
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* measure_statu::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:measure_statu)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // required .measure_info info = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::info(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:measure_statu)
  return target;
}

size_t measure_statu::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:measure_statu)
  size_t total_size = 0;

  // required .measure_info info = 1;
  if (_internal_has_info()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *info_);
  }
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

void measure_statu::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:measure_statu)
  GOOGLE_DCHECK_NE(&from, this);
  const measure_statu* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<measure_statu>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:measure_statu)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:measure_statu)
    MergeFrom(*source);
  }
}

void measure_statu::MergeFrom(const measure_statu& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:measure_statu)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_info()) {
    _internal_mutable_info()->::measure_info::MergeFrom(from._internal_info());
  }
}

void measure_statu::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:measure_statu)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void measure_statu::CopyFrom(const measure_statu& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:measure_statu)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool measure_statu::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  if (_internal_has_info()) {
    if (!info_->IsInitialized()) return false;
  }
  return true;
}

void measure_statu::InternalSwap(measure_statu* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(info_, other->info_);
}

::PROTOBUF_NAMESPACE_ID::Metadata measure_statu::GetMetadata() const {
  return GetMetadataStatic();
}


// @@protoc_insertion_point(namespace_scope)
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::LossResult* Arena::CreateMaybeMessage< ::LossResult >(Arena* arena) {
  return Arena::CreateMessageInternal< ::LossResult >(arena);
}
template<> PROTOBUF_NOINLINE ::DetectResult* Arena::CreateMaybeMessage< ::DetectResult >(Arena* arena) {
  return Arena::CreateMessageInternal< ::DetectResult >(arena);
}
template<> PROTOBUF_NOINLINE ::RegionEtc* Arena::CreateMaybeMessage< ::RegionEtc >(Arena* arena) {
  return Arena::CreateMessageInternal< ::RegionEtc >(arena);
}
template<> PROTOBUF_NOINLINE ::Region* Arena::CreateMaybeMessage< ::Region >(Arena* arena) {
  return Arena::CreateMessageInternal< ::Region >(arena);
}
template<> PROTOBUF_NOINLINE ::MeasureLidar* Arena::CreateMaybeMessage< ::MeasureLidar >(Arena* arena) {
  return Arena::CreateMessageInternal< ::MeasureLidar >(arena);
}
template<> PROTOBUF_NOINLINE ::MeasureConfig* Arena::CreateMaybeMessage< ::MeasureConfig >(Arena* arena) {
  return Arena::CreateMessageInternal< ::MeasureConfig >(arena);
}
template<> PROTOBUF_NOINLINE ::measure_info* Arena::CreateMaybeMessage< ::measure_info >(Arena* arena) {
  return Arena::CreateMessageInternal< ::measure_info >(arena);
}
template<> PROTOBUF_NOINLINE ::measure_statu* Arena::CreateMaybeMessage< ::measure_statu >(Arena* arena) {
  return Arena::CreateMessageInternal< ::measure_statu >(arena);
}
PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>
