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

#include "setting.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_setting_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_box_param_setting_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_setting_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_lidar_parameter_setting_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_setting_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_plc_param_setting_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_setting_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_shutter_param_setting_2eproto;
namespace shutter {
class lidar_parameterDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<lidar_parameter> _instance;
} _lidar_parameter_default_instance_;
class box_paramDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<box_param> _instance;
} _box_param_default_instance_;
class plc_paramDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<plc_param> _instance;
} _plc_param_default_instance_;
class shutter_paramDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<shutter_param> _instance;
} _shutter_param_default_instance_;
class setting_parameterDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<setting_parameter> _instance;
} _setting_parameter_default_instance_;
}  // namespace shutter
static void InitDefaultsscc_info_box_param_setting_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::shutter::_box_param_default_instance_;
    new (ptr) ::shutter::box_param();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::shutter::box_param::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_lidar_parameter_setting_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::shutter::_lidar_parameter_default_instance_;
    new (ptr) ::shutter::lidar_parameter();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::shutter::lidar_parameter::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_plc_param_setting_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::shutter::_plc_param_default_instance_;
    new (ptr) ::shutter::plc_param();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::shutter::plc_param::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_setting_parameter_setting_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::shutter::_setting_parameter_default_instance_;
    new (ptr) ::shutter::setting_parameter();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::shutter::setting_parameter::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_setting_parameter_setting_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_setting_parameter_setting_2eproto}, {
      &scc_info_shutter_param_setting_2eproto.base,
      &scc_info_plc_param_setting_2eproto.base,}};

static void InitDefaultsscc_info_shutter_param_setting_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::shutter::_shutter_param_default_instance_;
    new (ptr) ::shutter::shutter_param();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::shutter::shutter_param::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_shutter_param_setting_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, 0, InitDefaultsscc_info_shutter_param_setting_2eproto}, {
      &scc_info_lidar_parameter_setting_2eproto.base,
      &scc_info_box_param_setting_2eproto.base,}};

static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_setting_2eproto[5];
static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_setting_2eproto = nullptr;
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_setting_2eproto = nullptr;

const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_setting_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  PROTOBUF_FIELD_OFFSET(::shutter::lidar_parameter, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::shutter::lidar_parameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::shutter::lidar_parameter, sncode_),
  PROTOBUF_FIELD_OFFSET(::shutter::lidar_parameter, r_),
  PROTOBUF_FIELD_OFFSET(::shutter::lidar_parameter, p_),
  PROTOBUF_FIELD_OFFSET(::shutter::lidar_parameter, y_),
  PROTOBUF_FIELD_OFFSET(::shutter::lidar_parameter, tx_),
  PROTOBUF_FIELD_OFFSET(::shutter::lidar_parameter, ty_),
  PROTOBUF_FIELD_OFFSET(::shutter::lidar_parameter, tz_),
  PROTOBUF_FIELD_OFFSET(::shutter::lidar_parameter, fps_),
  0,
  1,
  2,
  3,
  4,
  5,
  6,
  7,
  PROTOBUF_FIELD_OFFSET(::shutter::box_param, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::shutter::box_param, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::shutter::box_param, minx_),
  PROTOBUF_FIELD_OFFSET(::shutter::box_param, maxx_),
  PROTOBUF_FIELD_OFFSET(::shutter::box_param, miny_),
  PROTOBUF_FIELD_OFFSET(::shutter::box_param, maxy_),
  PROTOBUF_FIELD_OFFSET(::shutter::box_param, minz_),
  PROTOBUF_FIELD_OFFSET(::shutter::box_param, maxz_),
  0,
  1,
  2,
  3,
  4,
  5,
  PROTOBUF_FIELD_OFFSET(::shutter::plc_param, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::shutter::plc_param, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::shutter::plc_param, ip_),
  PROTOBUF_FIELD_OFFSET(::shutter::plc_param, dbnumber_),
  PROTOBUF_FIELD_OFFSET(::shutter::plc_param, start_id_),
  0,
  1,
  2,
  PROTOBUF_FIELD_OFFSET(::shutter::shutter_param, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::shutter::shutter_param, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::shutter::shutter_param, lidars_),
  PROTOBUF_FIELD_OFFSET(::shutter::shutter_param, box_),
  PROTOBUF_FIELD_OFFSET(::shutter::shutter_param, verify_box1_),
  PROTOBUF_FIELD_OFFSET(::shutter::shutter_param, verify_box2_),
  ~0u,
  0,
  1,
  2,
  PROTOBUF_FIELD_OFFSET(::shutter::setting_parameter, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::shutter::setting_parameter, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::shutter::setting_parameter, entrance_parameter_),
  PROTOBUF_FIELD_OFFSET(::shutter::setting_parameter, export_parameter_),
  PROTOBUF_FIELD_OFFSET(::shutter::setting_parameter, plc_setting_),
  0,
  1,
  2,
};
static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  { 0, 13, sizeof(::shutter::lidar_parameter)},
  { 21, 32, sizeof(::shutter::box_param)},
  { 38, 46, sizeof(::shutter::plc_param)},
  { 49, 58, sizeof(::shutter::shutter_param)},
  { 62, 70, sizeof(::shutter::setting_parameter)},
};

static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::shutter::_lidar_parameter_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::shutter::_box_param_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::shutter::_plc_param_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::shutter::_shutter_param_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::shutter::_setting_parameter_default_instance_),
};

const char descriptor_table_protodef_setting_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
  "\n\rsetting.proto\022\007shutter\"\211\001\n\017lidar_param"
  "eter\022\016\n\006sncode\030\001 \001(\t\022\014\n\001r\030\002 \001(\001:\0010\022\014\n\001p\030"
  "\003 \001(\001:\0010\022\014\n\001y\030\004 \001(\001:\0010\022\r\n\002tx\030\005 \001(\001:\0011\022\r\n"
  "\002ty\030\006 \001(\001:\0011\022\r\n\002tz\030\007 \001(\001:\0011\022\017\n\003fps\030\010 \001(\001"
  ":\00210\"_\n\tbox_param\022\014\n\004minx\030\001 \001(\001\022\014\n\004maxx\030"
  "\002 \001(\001\022\014\n\004miny\030\003 \001(\001\022\014\n\004maxy\030\004 \001(\001\022\014\n\004min"
  "z\030\005 \001(\001\022\014\n\004maxz\030\006 \001(\001\">\n\tplc_param\022\n\n\002ip"
  "\030\001 \002(\t\022\020\n\010dbnumber\030\002 \002(\005\022\023\n\010start_id\030\003 \001"
  "(\005:\0010\"\254\001\n\rshutter_param\022(\n\006lidars\030\001 \003(\0132"
  "\030.shutter.lidar_parameter\022\037\n\003box\030\002 \001(\0132\022"
  ".shutter.box_param\022\'\n\013verify_box1\030\003 \001(\0132"
  "\022.shutter.box_param\022\'\n\013verify_box2\030\004 \001(\013"
  "2\022.shutter.box_param\"\242\001\n\021setting_paramet"
  "er\0222\n\022entrance_parameter\030\001 \001(\0132\026.shutter"
  ".shutter_param\0220\n\020export_parameter\030\002 \001(\013"
  "2\026.shutter.shutter_param\022\'\n\013plc_setting\030"
  "\003 \002(\0132\022.shutter.plc_param"
  ;
static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_setting_2eproto_deps[1] = {
};
static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_setting_2eproto_sccs[5] = {
  &scc_info_box_param_setting_2eproto.base,
  &scc_info_lidar_parameter_setting_2eproto.base,
  &scc_info_plc_param_setting_2eproto.base,
  &scc_info_setting_parameter_setting_2eproto.base,
  &scc_info_shutter_param_setting_2eproto.base,
};
static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_setting_2eproto_once;
const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_setting_2eproto = {
  false, false, descriptor_table_protodef_setting_2eproto, "setting.proto", 665,
  &descriptor_table_setting_2eproto_once, descriptor_table_setting_2eproto_sccs, descriptor_table_setting_2eproto_deps, 5, 0,
  schemas, file_default_instances, TableStruct_setting_2eproto::offsets,
  file_level_metadata_setting_2eproto, 5, file_level_enum_descriptors_setting_2eproto, file_level_service_descriptors_setting_2eproto,
};

// Force running AddDescriptors() at dynamic initialization time.
static bool dynamic_init_dummy_setting_2eproto = (static_cast<void>(::PROTOBUF_NAMESPACE_ID::internal::AddDescriptors(&descriptor_table_setting_2eproto)), true);
namespace shutter {

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

void lidar_parameter::InitAsDefaultInstance() {
}
class lidar_parameter::_Internal {
 public:
  using HasBits = decltype(std::declval<lidar_parameter>()._has_bits_);
  static void set_has_sncode(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_r(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_p(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_y(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_tx(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_ty(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
  static void set_has_tz(HasBits* has_bits) {
    (*has_bits)[0] |= 64u;
  }
  static void set_has_fps(HasBits* has_bits) {
    (*has_bits)[0] |= 128u;
  }
};

lidar_parameter::lidar_parameter(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:shutter.lidar_parameter)
}
lidar_parameter::lidar_parameter(const lidar_parameter& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  sncode_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_sncode()) {
    sncode_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_sncode(),
      GetArena());
  }
  ::memcpy(&r_, &from.r_,
    static_cast<size_t>(reinterpret_cast<char*>(&fps_) -
    reinterpret_cast<char*>(&r_)) + sizeof(fps_));
  // @@protoc_insertion_point(copy_constructor:shutter.lidar_parameter)
}

void lidar_parameter::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_lidar_parameter_setting_2eproto.base);
  sncode_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&r_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&y_) -
      reinterpret_cast<char*>(&r_)) + sizeof(y_));
  tx_ = 1;
  ty_ = 1;
  tz_ = 1;
  fps_ = 10;
}

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

void lidar_parameter::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  sncode_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

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


void lidar_parameter::Clear() {
// @@protoc_insertion_point(message_clear_start:shutter.lidar_parameter)
  ::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) {
    sncode_.ClearNonDefaultToEmpty();
  }
  if (cached_has_bits & 0x000000feu) {
    ::memset(&r_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&y_) -
        reinterpret_cast<char*>(&r_)) + sizeof(y_));
    tx_ = 1;
    ty_ = 1;
    tz_ = 1;
    fps_ = 10;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* lidar_parameter::_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) {
      // optional string sncode = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_sncode();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "shutter.lidar_parameter.sncode");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional double r = 2 [default = 0];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 17)) {
          _Internal::set_has_r(&has_bits);
          r_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      // optional double p = 3 [default = 0];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 25)) {
          _Internal::set_has_p(&has_bits);
          p_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      // optional double y = 4 [default = 0];
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 33)) {
          _Internal::set_has_y(&has_bits);
          y_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      // optional double tx = 5 [default = 1];
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 41)) {
          _Internal::set_has_tx(&has_bits);
          tx_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      // optional double ty = 6 [default = 1];
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 49)) {
          _Internal::set_has_ty(&has_bits);
          ty_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      // optional double tz = 7 [default = 1];
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 57)) {
          _Internal::set_has_tz(&has_bits);
          tz_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      // optional double fps = 8 [default = 10];
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 65)) {
          _Internal::set_has_fps(&has_bits);
          fps_ = ::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* lidar_parameter::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:shutter.lidar_parameter)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

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

  // optional double r = 2 [default = 0];
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(2, this->_internal_r(), target);
  }

  // optional double p = 3 [default = 0];
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(3, this->_internal_p(), target);
  }

  // optional double y = 4 [default = 0];
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(4, this->_internal_y(), target);
  }

  // optional double tx = 5 [default = 1];
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(5, this->_internal_tx(), target);
  }

  // optional double ty = 6 [default = 1];
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(6, this->_internal_ty(), target);
  }

  // optional double tz = 7 [default = 1];
  if (cached_has_bits & 0x00000040u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(7, this->_internal_tz(), target);
  }

  // optional double fps = 8 [default = 10];
  if (cached_has_bits & 0x00000080u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(8, this->_internal_fps(), 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:shutter.lidar_parameter)
  return target;
}

size_t lidar_parameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:shutter.lidar_parameter)
  size_t total_size = 0;

  ::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) {
    // optional string sncode = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_sncode());
    }

    // optional double r = 2 [default = 0];
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 + 8;
    }

    // optional double p = 3 [default = 0];
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 + 8;
    }

    // optional double y = 4 [default = 0];
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 + 8;
    }

    // optional double tx = 5 [default = 1];
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 + 8;
    }

    // optional double ty = 6 [default = 1];
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 + 8;
    }

    // optional double tz = 7 [default = 1];
    if (cached_has_bits & 0x00000040u) {
      total_size += 1 + 8;
    }

    // optional double fps = 8 [default = 10];
    if (cached_has_bits & 0x00000080u) {
      total_size += 1 + 8;
    }

  }
  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 lidar_parameter::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:shutter.lidar_parameter)
  GOOGLE_DCHECK_NE(&from, this);
  const lidar_parameter* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<lidar_parameter>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:shutter.lidar_parameter)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:shutter.lidar_parameter)
    MergeFrom(*source);
  }
}

void lidar_parameter::MergeFrom(const lidar_parameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:shutter.lidar_parameter)
  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_set_sncode(from._internal_sncode());
    }
    if (cached_has_bits & 0x00000002u) {
      r_ = from.r_;
    }
    if (cached_has_bits & 0x00000004u) {
      p_ = from.p_;
    }
    if (cached_has_bits & 0x00000008u) {
      y_ = from.y_;
    }
    if (cached_has_bits & 0x00000010u) {
      tx_ = from.tx_;
    }
    if (cached_has_bits & 0x00000020u) {
      ty_ = from.ty_;
    }
    if (cached_has_bits & 0x00000040u) {
      tz_ = from.tz_;
    }
    if (cached_has_bits & 0x00000080u) {
      fps_ = from.fps_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

bool lidar_parameter::IsInitialized() const {
  return true;
}

void lidar_parameter::InternalSwap(lidar_parameter* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  sncode_.Swap(&other->sncode_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(lidar_parameter, y_)
      + sizeof(lidar_parameter::y_)
      - PROTOBUF_FIELD_OFFSET(lidar_parameter, r_)>(
          reinterpret_cast<char*>(&r_),
          reinterpret_cast<char*>(&other->r_));
  swap(tx_, other->tx_);
  swap(ty_, other->ty_);
  swap(tz_, other->tz_);
  swap(fps_, other->fps_);
}

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


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

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

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

void box_param::SharedCtor() {
  ::memset(&minx_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&maxz_) -
      reinterpret_cast<char*>(&minx_)) + sizeof(maxz_));
}

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

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

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


void box_param::Clear() {
// @@protoc_insertion_point(message_clear_start:shutter.box_param)
  ::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(&minx_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&maxz_) -
        reinterpret_cast<char*>(&minx_)) + sizeof(maxz_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* box_param::_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) {
      // optional double minx = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 9)) {
          _Internal::set_has_minx(&has_bits);
          minx_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      // optional double maxx = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 17)) {
          _Internal::set_has_maxx(&has_bits);
          maxx_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      // optional double miny = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 25)) {
          _Internal::set_has_miny(&has_bits);
          miny_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      // optional double maxy = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 33)) {
          _Internal::set_has_maxy(&has_bits);
          maxy_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      // optional double minz = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 41)) {
          _Internal::set_has_minz(&has_bits);
          minz_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      // optional double maxz = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 49)) {
          _Internal::set_has_maxz(&has_bits);
          maxz_ = ::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* box_param::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:shutter.box_param)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

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

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

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

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

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

  // optional double maxz = 6;
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(6, this->_internal_maxz(), 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:shutter.box_param)
  return target;
}

size_t box_param::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:shutter.box_param)
  size_t total_size = 0;

  ::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) {
    // optional double minx = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 + 8;
    }

    // optional double maxx = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 + 8;
    }

    // optional double miny = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 + 8;
    }

    // optional double maxy = 4;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 + 8;
    }

    // optional double minz = 5;
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 + 8;
    }

    // optional double maxz = 6;
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 + 8;
    }

  }
  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 box_param::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:shutter.box_param)
  GOOGLE_DCHECK_NE(&from, this);
  const box_param* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<box_param>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:shutter.box_param)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:shutter.box_param)
    MergeFrom(*source);
  }
}

void box_param::MergeFrom(const box_param& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:shutter.box_param)
  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) {
      minx_ = from.minx_;
    }
    if (cached_has_bits & 0x00000002u) {
      maxx_ = from.maxx_;
    }
    if (cached_has_bits & 0x00000004u) {
      miny_ = from.miny_;
    }
    if (cached_has_bits & 0x00000008u) {
      maxy_ = from.maxy_;
    }
    if (cached_has_bits & 0x00000010u) {
      minz_ = from.minz_;
    }
    if (cached_has_bits & 0x00000020u) {
      maxz_ = from.maxz_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

bool box_param::IsInitialized() const {
  return true;
}

void box_param::InternalSwap(box_param* 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(box_param, maxz_)
      + sizeof(box_param::maxz_)
      - PROTOBUF_FIELD_OFFSET(box_param, minx_)>(
          reinterpret_cast<char*>(&minx_),
          reinterpret_cast<char*>(&other->minx_));
}

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


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

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

plc_param::plc_param(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:shutter.plc_param)
}
plc_param::plc_param(const plc_param& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ip_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_ip()) {
    ip_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_ip(),
      GetArena());
  }
  ::memcpy(&dbnumber_, &from.dbnumber_,
    static_cast<size_t>(reinterpret_cast<char*>(&start_id_) -
    reinterpret_cast<char*>(&dbnumber_)) + sizeof(start_id_));
  // @@protoc_insertion_point(copy_constructor:shutter.plc_param)
}

void plc_param::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_plc_param_setting_2eproto.base);
  ip_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&dbnumber_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&start_id_) -
      reinterpret_cast<char*>(&dbnumber_)) + sizeof(start_id_));
}

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

void plc_param::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  ip_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

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


void plc_param::Clear() {
// @@protoc_insertion_point(message_clear_start:shutter.plc_param)
  ::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) {
    ip_.ClearNonDefaultToEmpty();
  }
  if (cached_has_bits & 0x00000006u) {
    ::memset(&dbnumber_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&start_id_) -
        reinterpret_cast<char*>(&dbnumber_)) + sizeof(start_id_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* plc_param::_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 ip = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_ip();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "shutter.plc_param.ip");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // required int32 dbnumber = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_dbnumber(&has_bits);
          dbnumber_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 start_id = 3 [default = 0];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_start_id(&has_bits);
          start_id_ = ::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* plc_param::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:shutter.plc_param)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

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

  // required int32 dbnumber = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_dbnumber(), target);
  }

  // optional int32 start_id = 3 [default = 0];
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_start_id(), 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:shutter.plc_param)
  return target;
}

size_t plc_param::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:shutter.plc_param)
  size_t total_size = 0;

  if (_internal_has_ip()) {
    // required string ip = 1;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_ip());
  }

  if (_internal_has_dbnumber()) {
    // required int32 dbnumber = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_dbnumber());
  }

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

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

    // required int32 dbnumber = 2;
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_dbnumber());

  } 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;

  // optional int32 start_id = 3 [default = 0];
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000004u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_start_id());
  }

  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 plc_param::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:shutter.plc_param)
  GOOGLE_DCHECK_NE(&from, this);
  const plc_param* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<plc_param>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:shutter.plc_param)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:shutter.plc_param)
    MergeFrom(*source);
  }
}

void plc_param::MergeFrom(const plc_param& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:shutter.plc_param)
  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 & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_ip(from._internal_ip());
    }
    if (cached_has_bits & 0x00000002u) {
      dbnumber_ = from.dbnumber_;
    }
    if (cached_has_bits & 0x00000004u) {
      start_id_ = from.start_id_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

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

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

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

void plc_param::InternalSwap(plc_param* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ip_.Swap(&other->ip_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(plc_param, start_id_)
      + sizeof(plc_param::start_id_)
      - PROTOBUF_FIELD_OFFSET(plc_param, dbnumber_)>(
          reinterpret_cast<char*>(&dbnumber_),
          reinterpret_cast<char*>(&other->dbnumber_));
}

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


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

void shutter_param::InitAsDefaultInstance() {
  ::shutter::_shutter_param_default_instance_._instance.get_mutable()->box_ = const_cast< ::shutter::box_param*>(
      ::shutter::box_param::internal_default_instance());
  ::shutter::_shutter_param_default_instance_._instance.get_mutable()->verify_box1_ = const_cast< ::shutter::box_param*>(
      ::shutter::box_param::internal_default_instance());
  ::shutter::_shutter_param_default_instance_._instance.get_mutable()->verify_box2_ = const_cast< ::shutter::box_param*>(
      ::shutter::box_param::internal_default_instance());
}
class shutter_param::_Internal {
 public:
  using HasBits = decltype(std::declval<shutter_param>()._has_bits_);
  static const ::shutter::box_param& box(const shutter_param* msg);
  static void set_has_box(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::shutter::box_param& verify_box1(const shutter_param* msg);
  static void set_has_verify_box1(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static const ::shutter::box_param& verify_box2(const shutter_param* msg);
  static void set_has_verify_box2(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
};

const ::shutter::box_param&
shutter_param::_Internal::box(const shutter_param* msg) {
  return *msg->box_;
}
const ::shutter::box_param&
shutter_param::_Internal::verify_box1(const shutter_param* msg) {
  return *msg->verify_box1_;
}
const ::shutter::box_param&
shutter_param::_Internal::verify_box2(const shutter_param* msg) {
  return *msg->verify_box2_;
}
shutter_param::shutter_param(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena),
  lidars_(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:shutter.shutter_param)
}
shutter_param::shutter_param(const shutter_param& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_),
      lidars_(from.lidars_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_box()) {
    box_ = new ::shutter::box_param(*from.box_);
  } else {
    box_ = nullptr;
  }
  if (from._internal_has_verify_box1()) {
    verify_box1_ = new ::shutter::box_param(*from.verify_box1_);
  } else {
    verify_box1_ = nullptr;
  }
  if (from._internal_has_verify_box2()) {
    verify_box2_ = new ::shutter::box_param(*from.verify_box2_);
  } else {
    verify_box2_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:shutter.shutter_param)
}

void shutter_param::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_shutter_param_setting_2eproto.base);
  ::memset(&box_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&verify_box2_) -
      reinterpret_cast<char*>(&box_)) + sizeof(verify_box2_));
}

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

void shutter_param::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  if (this != internal_default_instance()) delete box_;
  if (this != internal_default_instance()) delete verify_box1_;
  if (this != internal_default_instance()) delete verify_box2_;
}

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


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

  lidars_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(box_ != nullptr);
      box_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(verify_box1_ != nullptr);
      verify_box1_->Clear();
    }
    if (cached_has_bits & 0x00000004u) {
      GOOGLE_DCHECK(verify_box2_ != nullptr);
      verify_box2_->Clear();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* shutter_param::_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) {
      // repeated .shutter.lidar_parameter lidars = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_lidars(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
        } else goto handle_unusual;
        continue;
      // optional .shutter.box_param box = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_box(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .shutter.box_param verify_box1 = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_verify_box1(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .shutter.box_param verify_box2 = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_verify_box2(), 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* shutter_param::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:shutter.shutter_param)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated .shutter.lidar_parameter lidars = 1;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_lidars_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(1, this->_internal_lidars(i), target, stream);
  }

  cached_has_bits = _has_bits_[0];
  // optional .shutter.box_param box = 2;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::box(this), target, stream);
  }

  // optional .shutter.box_param verify_box1 = 3;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::verify_box1(this), target, stream);
  }

  // optional .shutter.box_param verify_box2 = 4;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        4, _Internal::verify_box2(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:shutter.shutter_param)
  return target;
}

size_t shutter_param::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:shutter.shutter_param)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .shutter.lidar_parameter lidars = 1;
  total_size += 1UL * this->_internal_lidars_size();
  for (const auto& msg : this->lidars_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    // optional .shutter.box_param box = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *box_);
    }

    // optional .shutter.box_param verify_box1 = 3;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *verify_box1_);
    }

    // optional .shutter.box_param verify_box2 = 4;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *verify_box2_);
    }

  }
  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 shutter_param::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:shutter.shutter_param)
  GOOGLE_DCHECK_NE(&from, this);
  const shutter_param* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<shutter_param>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:shutter.shutter_param)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:shutter.shutter_param)
    MergeFrom(*source);
  }
}

void shutter_param::MergeFrom(const shutter_param& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:shutter.shutter_param)
  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;

  lidars_.MergeFrom(from.lidars_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_mutable_box()->::shutter::box_param::MergeFrom(from._internal_box());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_verify_box1()->::shutter::box_param::MergeFrom(from._internal_verify_box1());
    }
    if (cached_has_bits & 0x00000004u) {
      _internal_mutable_verify_box2()->::shutter::box_param::MergeFrom(from._internal_verify_box2());
    }
  }
}

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

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

bool shutter_param::IsInitialized() const {
  return true;
}

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

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


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

void setting_parameter::InitAsDefaultInstance() {
  ::shutter::_setting_parameter_default_instance_._instance.get_mutable()->entrance_parameter_ = const_cast< ::shutter::shutter_param*>(
      ::shutter::shutter_param::internal_default_instance());
  ::shutter::_setting_parameter_default_instance_._instance.get_mutable()->export_parameter_ = const_cast< ::shutter::shutter_param*>(
      ::shutter::shutter_param::internal_default_instance());
  ::shutter::_setting_parameter_default_instance_._instance.get_mutable()->plc_setting_ = const_cast< ::shutter::plc_param*>(
      ::shutter::plc_param::internal_default_instance());
}
class setting_parameter::_Internal {
 public:
  using HasBits = decltype(std::declval<setting_parameter>()._has_bits_);
  static const ::shutter::shutter_param& entrance_parameter(const setting_parameter* msg);
  static void set_has_entrance_parameter(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::shutter::shutter_param& export_parameter(const setting_parameter* msg);
  static void set_has_export_parameter(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static const ::shutter::plc_param& plc_setting(const setting_parameter* msg);
  static void set_has_plc_setting(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static bool MissingRequiredFields(const HasBits& has_bits) {
    return ((has_bits[0] & 0x00000004) ^ 0x00000004) != 0;
  }
};

const ::shutter::shutter_param&
setting_parameter::_Internal::entrance_parameter(const setting_parameter* msg) {
  return *msg->entrance_parameter_;
}
const ::shutter::shutter_param&
setting_parameter::_Internal::export_parameter(const setting_parameter* msg) {
  return *msg->export_parameter_;
}
const ::shutter::plc_param&
setting_parameter::_Internal::plc_setting(const setting_parameter* msg) {
  return *msg->plc_setting_;
}
setting_parameter::setting_parameter(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:shutter.setting_parameter)
}
setting_parameter::setting_parameter(const setting_parameter& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_entrance_parameter()) {
    entrance_parameter_ = new ::shutter::shutter_param(*from.entrance_parameter_);
  } else {
    entrance_parameter_ = nullptr;
  }
  if (from._internal_has_export_parameter()) {
    export_parameter_ = new ::shutter::shutter_param(*from.export_parameter_);
  } else {
    export_parameter_ = nullptr;
  }
  if (from._internal_has_plc_setting()) {
    plc_setting_ = new ::shutter::plc_param(*from.plc_setting_);
  } else {
    plc_setting_ = nullptr;
  }
  // @@protoc_insertion_point(copy_constructor:shutter.setting_parameter)
}

void setting_parameter::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_setting_parameter_setting_2eproto.base);
  ::memset(&entrance_parameter_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&plc_setting_) -
      reinterpret_cast<char*>(&entrance_parameter_)) + sizeof(plc_setting_));
}

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

void setting_parameter::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  if (this != internal_default_instance()) delete entrance_parameter_;
  if (this != internal_default_instance()) delete export_parameter_;
  if (this != internal_default_instance()) delete plc_setting_;
}

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


void setting_parameter::Clear() {
// @@protoc_insertion_point(message_clear_start:shutter.setting_parameter)
  ::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 & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(entrance_parameter_ != nullptr);
      entrance_parameter_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(export_parameter_ != nullptr);
      export_parameter_->Clear();
    }
    if (cached_has_bits & 0x00000004u) {
      GOOGLE_DCHECK(plc_setting_ != nullptr);
      plc_setting_->Clear();
    }
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* setting_parameter::_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) {
      // optional .shutter.shutter_param entrance_parameter = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_entrance_parameter(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .shutter.shutter_param export_parameter = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_export_parameter(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // required .shutter.plc_param plc_setting = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_plc_setting(), 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* setting_parameter::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:shutter.setting_parameter)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

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

  // optional .shutter.shutter_param export_parameter = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::export_parameter(this), target, stream);
  }

  // required .shutter.plc_param plc_setting = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::plc_setting(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:shutter.setting_parameter)
  return target;
}

size_t setting_parameter::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:shutter.setting_parameter)
  size_t total_size = 0;

  // required .shutter.plc_param plc_setting = 3;
  if (_internal_has_plc_setting()) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
        *plc_setting_);
  }
  ::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 & 0x00000003u) {
    // optional .shutter.shutter_param entrance_parameter = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *entrance_parameter_);
    }

    // optional .shutter.shutter_param export_parameter = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *export_parameter_);
    }

  }
  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 setting_parameter::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:shutter.setting_parameter)
  GOOGLE_DCHECK_NE(&from, this);
  const setting_parameter* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<setting_parameter>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:shutter.setting_parameter)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:shutter.setting_parameter)
    MergeFrom(*source);
  }
}

void setting_parameter::MergeFrom(const setting_parameter& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:shutter.setting_parameter)
  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 & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_mutable_entrance_parameter()->::shutter::shutter_param::MergeFrom(from._internal_entrance_parameter());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_export_parameter()->::shutter::shutter_param::MergeFrom(from._internal_export_parameter());
    }
    if (cached_has_bits & 0x00000004u) {
      _internal_mutable_plc_setting()->::shutter::plc_param::MergeFrom(from._internal_plc_setting());
    }
  }
}

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

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

bool setting_parameter::IsInitialized() const {
  if (_Internal::MissingRequiredFields(_has_bits_)) return false;
  if (_internal_has_plc_setting()) {
    if (!plc_setting_->IsInitialized()) return false;
  }
  return true;
}

void setting_parameter::InternalSwap(setting_parameter* 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(setting_parameter, plc_setting_)
      + sizeof(setting_parameter::plc_setting_)
      - PROTOBUF_FIELD_OFFSET(setting_parameter, entrance_parameter_)>(
          reinterpret_cast<char*>(&entrance_parameter_),
          reinterpret_cast<char*>(&other->entrance_parameter_));
}

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


// @@protoc_insertion_point(namespace_scope)
}  // namespace shutter
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::shutter::lidar_parameter* Arena::CreateMaybeMessage< ::shutter::lidar_parameter >(Arena* arena) {
  return Arena::CreateMessageInternal< ::shutter::lidar_parameter >(arena);
}
template<> PROTOBUF_NOINLINE ::shutter::box_param* Arena::CreateMaybeMessage< ::shutter::box_param >(Arena* arena) {
  return Arena::CreateMessageInternal< ::shutter::box_param >(arena);
}
template<> PROTOBUF_NOINLINE ::shutter::plc_param* Arena::CreateMaybeMessage< ::shutter::plc_param >(Arena* arena) {
  return Arena::CreateMessageInternal< ::shutter::plc_param >(arena);
}
template<> PROTOBUF_NOINLINE ::shutter::shutter_param* Arena::CreateMaybeMessage< ::shutter::shutter_param >(Arena* arena) {
  return Arena::CreateMessageInternal< ::shutter::shutter_param >(arena);
}
template<> PROTOBUF_NOINLINE ::shutter::setting_parameter* Arena::CreateMaybeMessage< ::shutter::setting_parameter >(Arena* arena) {
  return Arena::CreateMessageInternal< ::shutter::setting_parameter >(arena);
}
PROTOBUF_NAMESPACE_CLOSE

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