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

#include "keyboard.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_keyboard_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Ack_keyboard_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_keyboard_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Bitmap_keyboard_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_keyboard_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Error_keyboard_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_keyboard_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_FunctionKeyEvent_keyboard_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_keyboard_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_HelloReq_keyboard_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_keyboard_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_HelloRsp_keyboard_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_keyboard_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_LedState_keyboard_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_keyboard_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_ThemeRgb_keyboard_2eproto;
extern PROTOBUF_INTERNAL_EXPORT_keyboard_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_TimeSync_keyboard_2eproto;
namespace keyboard {
namespace cdc {
class CdcFrameDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<CdcFrame> _instance;
} _CdcFrame_default_instance_;
class CdcPacketBodyDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<CdcPacketBody> _instance;
  const ::keyboard::cdc::HelloReq* hello_req_;
  const ::keyboard::cdc::HelloRsp* hello_rsp_;
  const ::keyboard::cdc::Bitmap* bitmap_;
  const ::keyboard::cdc::FunctionKeyEvent* function_key_event_;
  const ::keyboard::cdc::LedState* led_state_;
  const ::keyboard::cdc::TimeSync* time_sync_;
  const ::keyboard::cdc::ThemeRgb* theme_rgb_;
  const ::keyboard::cdc::Ack* ack_;
  const ::keyboard::cdc::Error* error_;
} _CdcPacketBody_default_instance_;
class HelloReqDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<HelloReq> _instance;
} _HelloReq_default_instance_;
class HelloRspDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<HelloRsp> _instance;
} _HelloRsp_default_instance_;
class BitmapDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<Bitmap> _instance;
} _Bitmap_default_instance_;
class FunctionKeyEventDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<FunctionKeyEvent> _instance;
} _FunctionKeyEvent_default_instance_;
class LedStateDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<LedState> _instance;
} _LedState_default_instance_;
class TimeSyncDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<TimeSync> _instance;
} _TimeSync_default_instance_;
class ThemeRgbDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<ThemeRgb> _instance;
} _ThemeRgb_default_instance_;
class AckDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<Ack> _instance;
} _Ack_default_instance_;
class ErrorDefaultTypeInternal {
 public:
  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<Error> _instance;
} _Error_default_instance_;
}  // namespace cdc
}  // namespace keyboard
static void InitDefaultsscc_info_Ack_keyboard_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::keyboard::cdc::_Ack_default_instance_;
    new (ptr) ::keyboard::cdc::Ack();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::keyboard::cdc::Ack::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_Bitmap_keyboard_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::keyboard::cdc::_Bitmap_default_instance_;
    new (ptr) ::keyboard::cdc::Bitmap();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::keyboard::cdc::Bitmap::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_CdcFrame_keyboard_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::keyboard::cdc::_CdcFrame_default_instance_;
    new (ptr) ::keyboard::cdc::CdcFrame();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::keyboard::cdc::CdcFrame::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_CdcPacketBody_keyboard_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::keyboard::cdc::_CdcPacketBody_default_instance_;
    new (ptr) ::keyboard::cdc::CdcPacketBody();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::keyboard::cdc::CdcPacketBody::InitAsDefaultInstance();
}

::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<9> scc_info_CdcPacketBody_keyboard_2eproto =
    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 9, 0, InitDefaultsscc_info_CdcPacketBody_keyboard_2eproto}, {
      &scc_info_HelloReq_keyboard_2eproto.base,
      &scc_info_HelloRsp_keyboard_2eproto.base,
      &scc_info_Bitmap_keyboard_2eproto.base,
      &scc_info_FunctionKeyEvent_keyboard_2eproto.base,
      &scc_info_LedState_keyboard_2eproto.base,
      &scc_info_TimeSync_keyboard_2eproto.base,
      &scc_info_ThemeRgb_keyboard_2eproto.base,
      &scc_info_Ack_keyboard_2eproto.base,
      &scc_info_Error_keyboard_2eproto.base,}};

static void InitDefaultsscc_info_Error_keyboard_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::keyboard::cdc::_Error_default_instance_;
    new (ptr) ::keyboard::cdc::Error();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::keyboard::cdc::Error::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_FunctionKeyEvent_keyboard_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::keyboard::cdc::_FunctionKeyEvent_default_instance_;
    new (ptr) ::keyboard::cdc::FunctionKeyEvent();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::keyboard::cdc::FunctionKeyEvent::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_HelloReq_keyboard_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::keyboard::cdc::_HelloReq_default_instance_;
    new (ptr) ::keyboard::cdc::HelloReq();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::keyboard::cdc::HelloReq::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_HelloRsp_keyboard_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::keyboard::cdc::_HelloRsp_default_instance_;
    new (ptr) ::keyboard::cdc::HelloRsp();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::keyboard::cdc::HelloRsp::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_LedState_keyboard_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::keyboard::cdc::_LedState_default_instance_;
    new (ptr) ::keyboard::cdc::LedState();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::keyboard::cdc::LedState::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_ThemeRgb_keyboard_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::keyboard::cdc::_ThemeRgb_default_instance_;
    new (ptr) ::keyboard::cdc::ThemeRgb();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::keyboard::cdc::ThemeRgb::InitAsDefaultInstance();
}

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

static void InitDefaultsscc_info_TimeSync_keyboard_2eproto() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {
    void* ptr = &::keyboard::cdc::_TimeSync_default_instance_;
    new (ptr) ::keyboard::cdc::TimeSync();
    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  }
  ::keyboard::cdc::TimeSync::InitAsDefaultInstance();
}

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

static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_keyboard_2eproto[11];
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_keyboard_2eproto[3];
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_keyboard_2eproto = nullptr;

const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_keyboard_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::keyboard::cdc::CdcFrame, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::keyboard::cdc::CdcFrame, head1_),
  PROTOBUF_FIELD_OFFSET(::keyboard::cdc::CdcFrame, head2_),
  PROTOBUF_FIELD_OFFSET(::keyboard::cdc::CdcFrame, payload_length_),
  PROTOBUF_FIELD_OFFSET(::keyboard::cdc::CdcFrame, type_),
  PROTOBUF_FIELD_OFFSET(::keyboard::cdc::CdcFrame, payload_),
  PROTOBUF_FIELD_OFFSET(::keyboard::cdc::CdcFrame, checksum_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::keyboard::cdc::CdcPacketBody, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::keyboard::cdc::CdcPacketBody, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  offsetof(::keyboard::cdc::CdcPacketBodyDefaultTypeInternal, hello_req_),
  offsetof(::keyboard::cdc::CdcPacketBodyDefaultTypeInternal, hello_rsp_),
  offsetof(::keyboard::cdc::CdcPacketBodyDefaultTypeInternal, bitmap_),
  offsetof(::keyboard::cdc::CdcPacketBodyDefaultTypeInternal, function_key_event_),
  offsetof(::keyboard::cdc::CdcPacketBodyDefaultTypeInternal, led_state_),
  offsetof(::keyboard::cdc::CdcPacketBodyDefaultTypeInternal, time_sync_),
  offsetof(::keyboard::cdc::CdcPacketBodyDefaultTypeInternal, theme_rgb_),
  offsetof(::keyboard::cdc::CdcPacketBodyDefaultTypeInternal, ack_),
  offsetof(::keyboard::cdc::CdcPacketBodyDefaultTypeInternal, error_),
  PROTOBUF_FIELD_OFFSET(::keyboard::cdc::CdcPacketBody, body_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::keyboard::cdc::HelloReq, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::keyboard::cdc::HelloReq, protocol_version_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::keyboard::cdc::HelloRsp, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::keyboard::cdc::HelloRsp, protocol_version_),
  PROTOBUF_FIELD_OFFSET(::keyboard::cdc::HelloRsp, vendor_id_),
  PROTOBUF_FIELD_OFFSET(::keyboard::cdc::HelloRsp, product_id_),
  PROTOBUF_FIELD_OFFSET(::keyboard::cdc::HelloRsp, firmware_major_),
  PROTOBUF_FIELD_OFFSET(::keyboard::cdc::HelloRsp, firmware_minor_),
  PROTOBUF_FIELD_OFFSET(::keyboard::cdc::HelloRsp, capability_flags_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::keyboard::cdc::Bitmap, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::keyboard::cdc::Bitmap, usage_bitmap_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::keyboard::cdc::FunctionKeyEvent, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::keyboard::cdc::FunctionKeyEvent, usage_),
  PROTOBUF_FIELD_OFFSET(::keyboard::cdc::FunctionKeyEvent, action_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::keyboard::cdc::LedState, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::keyboard::cdc::LedState, led_mask_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::keyboard::cdc::TimeSync, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::keyboard::cdc::TimeSync, version_),
  PROTOBUF_FIELD_OFFSET(::keyboard::cdc::TimeSync, flags_),
  PROTOBUF_FIELD_OFFSET(::keyboard::cdc::TimeSync, timezone_min_),
  PROTOBUF_FIELD_OFFSET(::keyboard::cdc::TimeSync, utc_ms_),
  PROTOBUF_FIELD_OFFSET(::keyboard::cdc::TimeSync, accuracy_ms_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::keyboard::cdc::ThemeRgb, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::keyboard::cdc::ThemeRgb, red_),
  PROTOBUF_FIELD_OFFSET(::keyboard::cdc::ThemeRgb, green_),
  PROTOBUF_FIELD_OFFSET(::keyboard::cdc::ThemeRgb, blue_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::keyboard::cdc::Ack, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::keyboard::cdc::Ack, acked_type_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::keyboard::cdc::Error, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::keyboard::cdc::Error, error_type_),
  PROTOBUF_FIELD_OFFSET(::keyboard::cdc::Error, error_code_),
};
static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  { 0, -1, sizeof(::keyboard::cdc::CdcFrame)},
  { 11, -1, sizeof(::keyboard::cdc::CdcPacketBody)},
  { 26, -1, sizeof(::keyboard::cdc::HelloReq)},
  { 32, -1, sizeof(::keyboard::cdc::HelloRsp)},
  { 43, -1, sizeof(::keyboard::cdc::Bitmap)},
  { 49, -1, sizeof(::keyboard::cdc::FunctionKeyEvent)},
  { 56, -1, sizeof(::keyboard::cdc::LedState)},
  { 62, -1, sizeof(::keyboard::cdc::TimeSync)},
  { 72, -1, sizeof(::keyboard::cdc::ThemeRgb)},
  { 80, -1, sizeof(::keyboard::cdc::Ack)},
  { 86, -1, sizeof(::keyboard::cdc::Error)},
};

static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::keyboard::cdc::_CdcFrame_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::keyboard::cdc::_CdcPacketBody_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::keyboard::cdc::_HelloReq_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::keyboard::cdc::_HelloRsp_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::keyboard::cdc::_Bitmap_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::keyboard::cdc::_FunctionKeyEvent_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::keyboard::cdc::_LedState_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::keyboard::cdc::_TimeSync_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::keyboard::cdc::_ThemeRgb_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::keyboard::cdc::_Ack_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::keyboard::cdc::_Error_default_instance_),
};

const char descriptor_table_protodef_keyboard_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
  "\n\016keyboard.proto\022\014keyboard.cdc\"\216\001\n\010CdcFr"
  "ame\022\r\n\005head1\030\001 \001(\r\022\r\n\005head2\030\002 \001(\r\022\026\n\016pay"
  "load_length\030\003 \001(\r\022)\n\004type\030\004 \001(\0162\033.keyboa"
  "rd.cdc.CdcPacketType\022\017\n\007payload\030\005 \001(\014\022\020\n"
  "\010checksum\030\006 \001(\r\"\246\003\n\rCdcPacketBody\022+\n\thel"
  "lo_req\030\001 \001(\0132\026.keyboard.cdc.HelloReqH\000\022+"
  "\n\thello_rsp\030\002 \001(\0132\026.keyboard.cdc.HelloRs"
  "pH\000\022&\n\006bitmap\030\003 \001(\0132\024.keyboard.cdc.Bitma"
  "pH\000\022<\n\022function_key_event\030\004 \001(\0132\036.keyboa"
  "rd.cdc.FunctionKeyEventH\000\022+\n\tled_state\030\005"
  " \001(\0132\026.keyboard.cdc.LedStateH\000\022+\n\ttime_s"
  "ync\030\006 \001(\0132\026.keyboard.cdc.TimeSyncH\000\022+\n\tt"
  "heme_rgb\030\007 \001(\0132\026.keyboard.cdc.ThemeRgbH\000"
  "\022 \n\003ack\030\010 \001(\0132\021.keyboard.cdc.AckH\000\022$\n\005er"
  "ror\030\t \001(\0132\023.keyboard.cdc.ErrorH\000B\006\n\004body"
  "\"$\n\010HelloReq\022\030\n\020protocol_version\030\001 \001(\r\"\225"
  "\001\n\010HelloRsp\022\030\n\020protocol_version\030\001 \001(\r\022\021\n"
  "\tvendor_id\030\002 \001(\r\022\022\n\nproduct_id\030\003 \001(\r\022\026\n\016"
  "firmware_major\030\004 \001(\r\022\026\n\016firmware_minor\030\005"
  " \001(\r\022\030\n\020capability_flags\030\006 \001(\r\"\036\n\006Bitmap"
  "\022\024\n\014usage_bitmap\030\001 \001(\014\"J\n\020FunctionKeyEve"
  "nt\022\r\n\005usage\030\001 \001(\r\022\'\n\006action\030\002 \001(\0162\027.keyb"
  "oard.cdc.KeyAction\"\034\n\010LedState\022\020\n\010led_ma"
  "sk\030\001 \001(\r\"e\n\010TimeSync\022\017\n\007version\030\001 \001(\r\022\r\n"
  "\005flags\030\002 \001(\r\022\024\n\014timezone_min\030\003 \001(\021\022\016\n\006ut"
  "c_ms\030\004 \001(\006\022\023\n\013accuracy_ms\030\005 \001(\007\"4\n\010Theme"
  "Rgb\022\013\n\003red\030\001 \001(\r\022\r\n\005green\030\002 \001(\r\022\014\n\004blue\030"
  "\003 \001(\r\"\031\n\003Ack\022\022\n\nacked_type\030\001 \001(\r\"H\n\005Erro"
  "r\022\022\n\nerror_type\030\001 \001(\r\022+\n\nerror_code\030\002 \001("
  "\0162\027.keyboard.cdc.ErrorCode*\277\002\n\rCdcPacket"
  "Type\022\033\n\027CDC_PACKET_TYPE_UNKNOWN\020\000\022\035\n\031CDC"
  "_PACKET_TYPE_HELLO_REQ\020\001\022\035\n\031CDC_PACKET_T"
  "YPE_HELLO_RSP\020\002\022\032\n\026CDC_PACKET_TYPE_BITMA"
  "P\020\020\022&\n\"CDC_PACKET_TYPE_FUNCTION_KEY_EVEN"
  "T\020 \022\035\n\031CDC_PACKET_TYPE_LED_STATE\020!\022\035\n\031CD"
  "C_PACKET_TYPE_TIME_SYNC\0200\022\035\n\031CDC_PACKET_"
  "TYPE_THEME_RGB\0201\022\027\n\023CDC_PACKET_TYPE_ACK\020"
  "~\022\031\n\025CDC_PACKET_TYPE_ERROR\020\177*9\n\tKeyActio"
  "n\022\026\n\022KEY_ACTION_RELEASE\020\000\022\024\n\020KEY_ACTION_"
  "PRESS\020\001*\224\001\n\tErrorCode\022\023\n\017ERROR_CODE_NONE"
  "\020\000\022\033\n\027ERROR_CODE_UNKNOWN_TYPE\020\001\022\035\n\031ERROR"
  "_CODE_INVALID_LENGTH\020\002\022\034\n\030ERROR_CODE_INV"
  "ALID_PARAM\020\003\022\030\n\024ERROR_CODE_NOT_READY\020\004b\006"
  "proto3"
  ;
static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_keyboard_2eproto_deps[1] = {
};
static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_keyboard_2eproto_sccs[11] = {
  &scc_info_Ack_keyboard_2eproto.base,
  &scc_info_Bitmap_keyboard_2eproto.base,
  &scc_info_CdcFrame_keyboard_2eproto.base,
  &scc_info_CdcPacketBody_keyboard_2eproto.base,
  &scc_info_Error_keyboard_2eproto.base,
  &scc_info_FunctionKeyEvent_keyboard_2eproto.base,
  &scc_info_HelloReq_keyboard_2eproto.base,
  &scc_info_HelloRsp_keyboard_2eproto.base,
  &scc_info_LedState_keyboard_2eproto.base,
  &scc_info_ThemeRgb_keyboard_2eproto.base,
  &scc_info_TimeSync_keyboard_2eproto.base,
};
static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_keyboard_2eproto_once;
const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_keyboard_2eproto = {
  false, false, descriptor_table_protodef_keyboard_2eproto, "keyboard.proto", 1726,
  &descriptor_table_keyboard_2eproto_once, descriptor_table_keyboard_2eproto_sccs, descriptor_table_keyboard_2eproto_deps, 11, 0,
  schemas, file_default_instances, TableStruct_keyboard_2eproto::offsets,
  file_level_metadata_keyboard_2eproto, 11, file_level_enum_descriptors_keyboard_2eproto, file_level_service_descriptors_keyboard_2eproto,
};

// Force running AddDescriptors() at dynamic initialization time.
static bool dynamic_init_dummy_keyboard_2eproto = (static_cast<void>(::PROTOBUF_NAMESPACE_ID::internal::AddDescriptors(&descriptor_table_keyboard_2eproto)), true);
namespace keyboard {
namespace cdc {
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CdcPacketType_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_keyboard_2eproto);
  return file_level_enum_descriptors_keyboard_2eproto[0];
}
bool CdcPacketType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 16:
    case 32:
    case 33:
    case 48:
    case 49:
    case 126:
    case 127:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* KeyAction_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_keyboard_2eproto);
  return file_level_enum_descriptors_keyboard_2eproto[1];
}
bool KeyAction_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
      return true;
    default:
      return false;
  }
}

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ErrorCode_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_keyboard_2eproto);
  return file_level_enum_descriptors_keyboard_2eproto[2];
}
bool ErrorCode_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
      return true;
    default:
      return false;
  }
}


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

void CdcFrame::InitAsDefaultInstance() {
}
class CdcFrame::_Internal {
 public:
};

CdcFrame::CdcFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyboard.cdc.CdcFrame)
}
CdcFrame::CdcFrame(const CdcFrame& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  payload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from._internal_payload().empty()) {
    payload_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_payload(),
      GetArena());
  }
  ::memcpy(&head1_, &from.head1_,
    static_cast<size_t>(reinterpret_cast<char*>(&checksum_) -
    reinterpret_cast<char*>(&head1_)) + sizeof(checksum_));
  // @@protoc_insertion_point(copy_constructor:keyboard.cdc.CdcFrame)
}

void CdcFrame::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_CdcFrame_keyboard_2eproto.base);
  payload_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&head1_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&checksum_) -
      reinterpret_cast<char*>(&head1_)) + sizeof(checksum_));
}

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

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

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


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

  payload_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  ::memset(&head1_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&checksum_) -
      reinterpret_cast<char*>(&head1_)) + sizeof(checksum_));
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* CdcFrame::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ::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) {
      // uint32 head1 = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          head1_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // uint32 head2 = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          head2_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // uint32 payload_length = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          payload_length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .keyboard.cdc.CdcPacketType type = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          _internal_set_type(static_cast<::keyboard::cdc::CdcPacketType>(val));
        } else goto handle_unusual;
        continue;
      // bytes payload = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          auto str = _internal_mutable_payload();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // uint32 checksum = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) {
          checksum_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&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:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  // uint32 head1 = 1;
  if (this->head1() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_head1(), target);
  }

  // uint32 head2 = 2;
  if (this->head2() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_head2(), target);
  }

  // uint32 payload_length = 3;
  if (this->payload_length() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_payload_length(), target);
  }

  // .keyboard.cdc.CdcPacketType type = 4;
  if (this->type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      4, this->_internal_type(), target);
  }

  // bytes payload = 5;
  if (this->payload().size() > 0) {
    target = stream->WriteBytesMaybeAliased(
        5, this->_internal_payload(), target);
  }

  // uint32 checksum = 6;
  if (this->checksum() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(6, this->_internal_checksum(), 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:keyboard.cdc.CdcFrame)
  return target;
}

size_t CdcFrame::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyboard.cdc.CdcFrame)
  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;

  // bytes payload = 5;
  if (this->payload().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->_internal_payload());
  }

  // uint32 head1 = 1;
  if (this->head1() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->_internal_head1());
  }

  // uint32 head2 = 2;
  if (this->head2() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->_internal_head2());
  }

  // uint32 payload_length = 3;
  if (this->payload_length() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->_internal_payload_length());
  }

  // .keyboard.cdc.CdcPacketType type = 4;
  if (this->type() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type());
  }

  // uint32 checksum = 6;
  if (this->checksum() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->_internal_checksum());
  }

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

void CdcFrame::MergeFrom(const CdcFrame& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:keyboard.cdc.CdcFrame)
  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.payload().size() > 0) {
    _internal_set_payload(from._internal_payload());
  }
  if (from.head1() != 0) {
    _internal_set_head1(from._internal_head1());
  }
  if (from.head2() != 0) {
    _internal_set_head2(from._internal_head2());
  }
  if (from.payload_length() != 0) {
    _internal_set_payload_length(from._internal_payload_length());
  }
  if (from.type() != 0) {
    _internal_set_type(from._internal_type());
  }
  if (from.checksum() != 0) {
    _internal_set_checksum(from._internal_checksum());
  }
}

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

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

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

void CdcFrame::InternalSwap(CdcFrame* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  payload_.Swap(&other->payload_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(CdcFrame, checksum_)
      + sizeof(CdcFrame::checksum_)
      - PROTOBUF_FIELD_OFFSET(CdcFrame, head1_)>(
          reinterpret_cast<char*>(&head1_),
          reinterpret_cast<char*>(&other->head1_));
}

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


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

void CdcPacketBody::InitAsDefaultInstance() {
  ::keyboard::cdc::_CdcPacketBody_default_instance_.hello_req_ = const_cast< ::keyboard::cdc::HelloReq*>(
      ::keyboard::cdc::HelloReq::internal_default_instance());
  ::keyboard::cdc::_CdcPacketBody_default_instance_.hello_rsp_ = const_cast< ::keyboard::cdc::HelloRsp*>(
      ::keyboard::cdc::HelloRsp::internal_default_instance());
  ::keyboard::cdc::_CdcPacketBody_default_instance_.bitmap_ = const_cast< ::keyboard::cdc::Bitmap*>(
      ::keyboard::cdc::Bitmap::internal_default_instance());
  ::keyboard::cdc::_CdcPacketBody_default_instance_.function_key_event_ = const_cast< ::keyboard::cdc::FunctionKeyEvent*>(
      ::keyboard::cdc::FunctionKeyEvent::internal_default_instance());
  ::keyboard::cdc::_CdcPacketBody_default_instance_.led_state_ = const_cast< ::keyboard::cdc::LedState*>(
      ::keyboard::cdc::LedState::internal_default_instance());
  ::keyboard::cdc::_CdcPacketBody_default_instance_.time_sync_ = const_cast< ::keyboard::cdc::TimeSync*>(
      ::keyboard::cdc::TimeSync::internal_default_instance());
  ::keyboard::cdc::_CdcPacketBody_default_instance_.theme_rgb_ = const_cast< ::keyboard::cdc::ThemeRgb*>(
      ::keyboard::cdc::ThemeRgb::internal_default_instance());
  ::keyboard::cdc::_CdcPacketBody_default_instance_.ack_ = const_cast< ::keyboard::cdc::Ack*>(
      ::keyboard::cdc::Ack::internal_default_instance());
  ::keyboard::cdc::_CdcPacketBody_default_instance_.error_ = const_cast< ::keyboard::cdc::Error*>(
      ::keyboard::cdc::Error::internal_default_instance());
}
class CdcPacketBody::_Internal {
 public:
  static const ::keyboard::cdc::HelloReq& hello_req(const CdcPacketBody* msg);
  static const ::keyboard::cdc::HelloRsp& hello_rsp(const CdcPacketBody* msg);
  static const ::keyboard::cdc::Bitmap& bitmap(const CdcPacketBody* msg);
  static const ::keyboard::cdc::FunctionKeyEvent& function_key_event(const CdcPacketBody* msg);
  static const ::keyboard::cdc::LedState& led_state(const CdcPacketBody* msg);
  static const ::keyboard::cdc::TimeSync& time_sync(const CdcPacketBody* msg);
  static const ::keyboard::cdc::ThemeRgb& theme_rgb(const CdcPacketBody* msg);
  static const ::keyboard::cdc::Ack& ack(const CdcPacketBody* msg);
  static const ::keyboard::cdc::Error& error(const CdcPacketBody* msg);
};

const ::keyboard::cdc::HelloReq&
CdcPacketBody::_Internal::hello_req(const CdcPacketBody* msg) {
  return *msg->body_.hello_req_;
}
const ::keyboard::cdc::HelloRsp&
CdcPacketBody::_Internal::hello_rsp(const CdcPacketBody* msg) {
  return *msg->body_.hello_rsp_;
}
const ::keyboard::cdc::Bitmap&
CdcPacketBody::_Internal::bitmap(const CdcPacketBody* msg) {
  return *msg->body_.bitmap_;
}
const ::keyboard::cdc::FunctionKeyEvent&
CdcPacketBody::_Internal::function_key_event(const CdcPacketBody* msg) {
  return *msg->body_.function_key_event_;
}
const ::keyboard::cdc::LedState&
CdcPacketBody::_Internal::led_state(const CdcPacketBody* msg) {
  return *msg->body_.led_state_;
}
const ::keyboard::cdc::TimeSync&
CdcPacketBody::_Internal::time_sync(const CdcPacketBody* msg) {
  return *msg->body_.time_sync_;
}
const ::keyboard::cdc::ThemeRgb&
CdcPacketBody::_Internal::theme_rgb(const CdcPacketBody* msg) {
  return *msg->body_.theme_rgb_;
}
const ::keyboard::cdc::Ack&
CdcPacketBody::_Internal::ack(const CdcPacketBody* msg) {
  return *msg->body_.ack_;
}
const ::keyboard::cdc::Error&
CdcPacketBody::_Internal::error(const CdcPacketBody* msg) {
  return *msg->body_.error_;
}
void CdcPacketBody::set_allocated_hello_req(::keyboard::cdc::HelloReq* hello_req) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  clear_body();
  if (hello_req) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(hello_req);
    if (message_arena != submessage_arena) {
      hello_req = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, hello_req, submessage_arena);
    }
    set_has_hello_req();
    body_.hello_req_ = hello_req;
  }
  // @@protoc_insertion_point(field_set_allocated:keyboard.cdc.CdcPacketBody.hello_req)
}
void CdcPacketBody::set_allocated_hello_rsp(::keyboard::cdc::HelloRsp* hello_rsp) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  clear_body();
  if (hello_rsp) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(hello_rsp);
    if (message_arena != submessage_arena) {
      hello_rsp = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, hello_rsp, submessage_arena);
    }
    set_has_hello_rsp();
    body_.hello_rsp_ = hello_rsp;
  }
  // @@protoc_insertion_point(field_set_allocated:keyboard.cdc.CdcPacketBody.hello_rsp)
}
void CdcPacketBody::set_allocated_bitmap(::keyboard::cdc::Bitmap* bitmap) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  clear_body();
  if (bitmap) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(bitmap);
    if (message_arena != submessage_arena) {
      bitmap = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, bitmap, submessage_arena);
    }
    set_has_bitmap();
    body_.bitmap_ = bitmap;
  }
  // @@protoc_insertion_point(field_set_allocated:keyboard.cdc.CdcPacketBody.bitmap)
}
void CdcPacketBody::set_allocated_function_key_event(::keyboard::cdc::FunctionKeyEvent* function_key_event) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  clear_body();
  if (function_key_event) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(function_key_event);
    if (message_arena != submessage_arena) {
      function_key_event = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, function_key_event, submessage_arena);
    }
    set_has_function_key_event();
    body_.function_key_event_ = function_key_event;
  }
  // @@protoc_insertion_point(field_set_allocated:keyboard.cdc.CdcPacketBody.function_key_event)
}
void CdcPacketBody::set_allocated_led_state(::keyboard::cdc::LedState* led_state) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  clear_body();
  if (led_state) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(led_state);
    if (message_arena != submessage_arena) {
      led_state = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, led_state, submessage_arena);
    }
    set_has_led_state();
    body_.led_state_ = led_state;
  }
  // @@protoc_insertion_point(field_set_allocated:keyboard.cdc.CdcPacketBody.led_state)
}
void CdcPacketBody::set_allocated_time_sync(::keyboard::cdc::TimeSync* time_sync) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  clear_body();
  if (time_sync) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(time_sync);
    if (message_arena != submessage_arena) {
      time_sync = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, time_sync, submessage_arena);
    }
    set_has_time_sync();
    body_.time_sync_ = time_sync;
  }
  // @@protoc_insertion_point(field_set_allocated:keyboard.cdc.CdcPacketBody.time_sync)
}
void CdcPacketBody::set_allocated_theme_rgb(::keyboard::cdc::ThemeRgb* theme_rgb) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  clear_body();
  if (theme_rgb) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(theme_rgb);
    if (message_arena != submessage_arena) {
      theme_rgb = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, theme_rgb, submessage_arena);
    }
    set_has_theme_rgb();
    body_.theme_rgb_ = theme_rgb;
  }
  // @@protoc_insertion_point(field_set_allocated:keyboard.cdc.CdcPacketBody.theme_rgb)
}
void CdcPacketBody::set_allocated_ack(::keyboard::cdc::Ack* ack) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  clear_body();
  if (ack) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(ack);
    if (message_arena != submessage_arena) {
      ack = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, ack, submessage_arena);
    }
    set_has_ack();
    body_.ack_ = ack;
  }
  // @@protoc_insertion_point(field_set_allocated:keyboard.cdc.CdcPacketBody.ack)
}
void CdcPacketBody::set_allocated_error(::keyboard::cdc::Error* error) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  clear_body();
  if (error) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(error);
    if (message_arena != submessage_arena) {
      error = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, error, submessage_arena);
    }
    set_has_error();
    body_.error_ = error;
  }
  // @@protoc_insertion_point(field_set_allocated:keyboard.cdc.CdcPacketBody.error)
}
CdcPacketBody::CdcPacketBody(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyboard.cdc.CdcPacketBody)
}
CdcPacketBody::CdcPacketBody(const CdcPacketBody& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  clear_has_body();
  switch (from.body_case()) {
    case kHelloReq: {
      _internal_mutable_hello_req()->::keyboard::cdc::HelloReq::MergeFrom(from._internal_hello_req());
      break;
    }
    case kHelloRsp: {
      _internal_mutable_hello_rsp()->::keyboard::cdc::HelloRsp::MergeFrom(from._internal_hello_rsp());
      break;
    }
    case kBitmap: {
      _internal_mutable_bitmap()->::keyboard::cdc::Bitmap::MergeFrom(from._internal_bitmap());
      break;
    }
    case kFunctionKeyEvent: {
      _internal_mutable_function_key_event()->::keyboard::cdc::FunctionKeyEvent::MergeFrom(from._internal_function_key_event());
      break;
    }
    case kLedState: {
      _internal_mutable_led_state()->::keyboard::cdc::LedState::MergeFrom(from._internal_led_state());
      break;
    }
    case kTimeSync: {
      _internal_mutable_time_sync()->::keyboard::cdc::TimeSync::MergeFrom(from._internal_time_sync());
      break;
    }
    case kThemeRgb: {
      _internal_mutable_theme_rgb()->::keyboard::cdc::ThemeRgb::MergeFrom(from._internal_theme_rgb());
      break;
    }
    case kAck: {
      _internal_mutable_ack()->::keyboard::cdc::Ack::MergeFrom(from._internal_ack());
      break;
    }
    case kError: {
      _internal_mutable_error()->::keyboard::cdc::Error::MergeFrom(from._internal_error());
      break;
    }
    case BODY_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:keyboard.cdc.CdcPacketBody)
}

void CdcPacketBody::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_CdcPacketBody_keyboard_2eproto.base);
  clear_has_body();
}

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

void CdcPacketBody::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  if (has_body()) {
    clear_body();
  }
}

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


void CdcPacketBody::clear_body() {
// @@protoc_insertion_point(one_of_clear_start:keyboard.cdc.CdcPacketBody)
  switch (body_case()) {
    case kHelloReq: {
      if (GetArena() == nullptr) {
        delete body_.hello_req_;
      }
      break;
    }
    case kHelloRsp: {
      if (GetArena() == nullptr) {
        delete body_.hello_rsp_;
      }
      break;
    }
    case kBitmap: {
      if (GetArena() == nullptr) {
        delete body_.bitmap_;
      }
      break;
    }
    case kFunctionKeyEvent: {
      if (GetArena() == nullptr) {
        delete body_.function_key_event_;
      }
      break;
    }
    case kLedState: {
      if (GetArena() == nullptr) {
        delete body_.led_state_;
      }
      break;
    }
    case kTimeSync: {
      if (GetArena() == nullptr) {
        delete body_.time_sync_;
      }
      break;
    }
    case kThemeRgb: {
      if (GetArena() == nullptr) {
        delete body_.theme_rgb_;
      }
      break;
    }
    case kAck: {
      if (GetArena() == nullptr) {
        delete body_.ack_;
      }
      break;
    }
    case kError: {
      if (GetArena() == nullptr) {
        delete body_.error_;
      }
      break;
    }
    case BODY_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = BODY_NOT_SET;
}


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

  clear_body();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* CdcPacketBody::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ::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) {
      // .keyboard.cdc.HelloReq hello_req = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_hello_req(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .keyboard.cdc.HelloRsp hello_rsp = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_hello_rsp(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .keyboard.cdc.Bitmap bitmap = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_bitmap(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .keyboard.cdc.FunctionKeyEvent function_key_event = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_function_key_event(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .keyboard.cdc.LedState led_state = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_led_state(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .keyboard.cdc.TimeSync time_sync = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          ptr = ctx->ParseMessage(_internal_mutable_time_sync(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .keyboard.cdc.ThemeRgb theme_rgb = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
          ptr = ctx->ParseMessage(_internal_mutable_theme_rgb(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .keyboard.cdc.Ack ack = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
          ptr = ctx->ParseMessage(_internal_mutable_ack(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .keyboard.cdc.Error error = 9;
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) {
          ptr = ctx->ParseMessage(_internal_mutable_error(), 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:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  // .keyboard.cdc.HelloReq hello_req = 1;
  if (_internal_has_hello_req()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::hello_req(this), target, stream);
  }

  // .keyboard.cdc.HelloRsp hello_rsp = 2;
  if (_internal_has_hello_rsp()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::hello_rsp(this), target, stream);
  }

  // .keyboard.cdc.Bitmap bitmap = 3;
  if (_internal_has_bitmap()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::bitmap(this), target, stream);
  }

  // .keyboard.cdc.FunctionKeyEvent function_key_event = 4;
  if (_internal_has_function_key_event()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        4, _Internal::function_key_event(this), target, stream);
  }

  // .keyboard.cdc.LedState led_state = 5;
  if (_internal_has_led_state()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        5, _Internal::led_state(this), target, stream);
  }

  // .keyboard.cdc.TimeSync time_sync = 6;
  if (_internal_has_time_sync()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        6, _Internal::time_sync(this), target, stream);
  }

  // .keyboard.cdc.ThemeRgb theme_rgb = 7;
  if (_internal_has_theme_rgb()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        7, _Internal::theme_rgb(this), target, stream);
  }

  // .keyboard.cdc.Ack ack = 8;
  if (_internal_has_ack()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        8, _Internal::ack(this), target, stream);
  }

  // .keyboard.cdc.Error error = 9;
  if (_internal_has_error()) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        9, _Internal::error(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:keyboard.cdc.CdcPacketBody)
  return target;
}

size_t CdcPacketBody::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyboard.cdc.CdcPacketBody)
  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;

  switch (body_case()) {
    // .keyboard.cdc.HelloReq hello_req = 1;
    case kHelloReq: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *body_.hello_req_);
      break;
    }
    // .keyboard.cdc.HelloRsp hello_rsp = 2;
    case kHelloRsp: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *body_.hello_rsp_);
      break;
    }
    // .keyboard.cdc.Bitmap bitmap = 3;
    case kBitmap: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *body_.bitmap_);
      break;
    }
    // .keyboard.cdc.FunctionKeyEvent function_key_event = 4;
    case kFunctionKeyEvent: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *body_.function_key_event_);
      break;
    }
    // .keyboard.cdc.LedState led_state = 5;
    case kLedState: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *body_.led_state_);
      break;
    }
    // .keyboard.cdc.TimeSync time_sync = 6;
    case kTimeSync: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *body_.time_sync_);
      break;
    }
    // .keyboard.cdc.ThemeRgb theme_rgb = 7;
    case kThemeRgb: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *body_.theme_rgb_);
      break;
    }
    // .keyboard.cdc.Ack ack = 8;
    case kAck: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *body_.ack_);
      break;
    }
    // .keyboard.cdc.Error error = 9;
    case kError: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *body_.error_);
      break;
    }
    case BODY_NOT_SET: {
      break;
    }
  }
  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 CdcPacketBody::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:keyboard.cdc.CdcPacketBody)
  GOOGLE_DCHECK_NE(&from, this);
  const CdcPacketBody* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<CdcPacketBody>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:keyboard.cdc.CdcPacketBody)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:keyboard.cdc.CdcPacketBody)
    MergeFrom(*source);
  }
}

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

  switch (from.body_case()) {
    case kHelloReq: {
      _internal_mutable_hello_req()->::keyboard::cdc::HelloReq::MergeFrom(from._internal_hello_req());
      break;
    }
    case kHelloRsp: {
      _internal_mutable_hello_rsp()->::keyboard::cdc::HelloRsp::MergeFrom(from._internal_hello_rsp());
      break;
    }
    case kBitmap: {
      _internal_mutable_bitmap()->::keyboard::cdc::Bitmap::MergeFrom(from._internal_bitmap());
      break;
    }
    case kFunctionKeyEvent: {
      _internal_mutable_function_key_event()->::keyboard::cdc::FunctionKeyEvent::MergeFrom(from._internal_function_key_event());
      break;
    }
    case kLedState: {
      _internal_mutable_led_state()->::keyboard::cdc::LedState::MergeFrom(from._internal_led_state());
      break;
    }
    case kTimeSync: {
      _internal_mutable_time_sync()->::keyboard::cdc::TimeSync::MergeFrom(from._internal_time_sync());
      break;
    }
    case kThemeRgb: {
      _internal_mutable_theme_rgb()->::keyboard::cdc::ThemeRgb::MergeFrom(from._internal_theme_rgb());
      break;
    }
    case kAck: {
      _internal_mutable_ack()->::keyboard::cdc::Ack::MergeFrom(from._internal_ack());
      break;
    }
    case kError: {
      _internal_mutable_error()->::keyboard::cdc::Error::MergeFrom(from._internal_error());
      break;
    }
    case BODY_NOT_SET: {
      break;
    }
  }
}

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

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

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

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

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


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

void HelloReq::InitAsDefaultInstance() {
}
class HelloReq::_Internal {
 public:
};

HelloReq::HelloReq(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyboard.cdc.HelloReq)
}
HelloReq::HelloReq(const HelloReq& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  protocol_version_ = from.protocol_version_;
  // @@protoc_insertion_point(copy_constructor:keyboard.cdc.HelloReq)
}

void HelloReq::SharedCtor() {
  protocol_version_ = 0u;
}

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

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

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


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

  protocol_version_ = 0u;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* HelloReq::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ::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) {
      // uint32 protocol_version = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          protocol_version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&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:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  // uint32 protocol_version = 1;
  if (this->protocol_version() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_protocol_version(), 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:keyboard.cdc.HelloReq)
  return target;
}

size_t HelloReq::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyboard.cdc.HelloReq)
  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;

  // uint32 protocol_version = 1;
  if (this->protocol_version() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->_internal_protocol_version());
  }

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

void HelloReq::MergeFrom(const HelloReq& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:keyboard.cdc.HelloReq)
  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.protocol_version() != 0) {
    _internal_set_protocol_version(from._internal_protocol_version());
  }
}

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

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

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

void HelloReq::InternalSwap(HelloReq* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(protocol_version_, other->protocol_version_);
}

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


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

void HelloRsp::InitAsDefaultInstance() {
}
class HelloRsp::_Internal {
 public:
};

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

void HelloRsp::SharedCtor() {
  ::memset(&protocol_version_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&capability_flags_) -
      reinterpret_cast<char*>(&protocol_version_)) + sizeof(capability_flags_));
}

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

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

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


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

  ::memset(&protocol_version_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&capability_flags_) -
      reinterpret_cast<char*>(&protocol_version_)) + sizeof(capability_flags_));
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* HelloRsp::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ::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) {
      // uint32 protocol_version = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          protocol_version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // uint32 vendor_id = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          vendor_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // uint32 product_id = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          product_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // uint32 firmware_major = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          firmware_major_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // uint32 firmware_minor = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          firmware_minor_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // uint32 capability_flags = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) {
          capability_flags_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&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:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  // uint32 protocol_version = 1;
  if (this->protocol_version() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_protocol_version(), target);
  }

  // uint32 vendor_id = 2;
  if (this->vendor_id() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_vendor_id(), target);
  }

  // uint32 product_id = 3;
  if (this->product_id() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_product_id(), target);
  }

  // uint32 firmware_major = 4;
  if (this->firmware_major() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->_internal_firmware_major(), target);
  }

  // uint32 firmware_minor = 5;
  if (this->firmware_minor() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(5, this->_internal_firmware_minor(), target);
  }

  // uint32 capability_flags = 6;
  if (this->capability_flags() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(6, this->_internal_capability_flags(), 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:keyboard.cdc.HelloRsp)
  return target;
}

size_t HelloRsp::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyboard.cdc.HelloRsp)
  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;

  // uint32 protocol_version = 1;
  if (this->protocol_version() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->_internal_protocol_version());
  }

  // uint32 vendor_id = 2;
  if (this->vendor_id() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->_internal_vendor_id());
  }

  // uint32 product_id = 3;
  if (this->product_id() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->_internal_product_id());
  }

  // uint32 firmware_major = 4;
  if (this->firmware_major() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->_internal_firmware_major());
  }

  // uint32 firmware_minor = 5;
  if (this->firmware_minor() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->_internal_firmware_minor());
  }

  // uint32 capability_flags = 6;
  if (this->capability_flags() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->_internal_capability_flags());
  }

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

void HelloRsp::MergeFrom(const HelloRsp& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:keyboard.cdc.HelloRsp)
  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.protocol_version() != 0) {
    _internal_set_protocol_version(from._internal_protocol_version());
  }
  if (from.vendor_id() != 0) {
    _internal_set_vendor_id(from._internal_vendor_id());
  }
  if (from.product_id() != 0) {
    _internal_set_product_id(from._internal_product_id());
  }
  if (from.firmware_major() != 0) {
    _internal_set_firmware_major(from._internal_firmware_major());
  }
  if (from.firmware_minor() != 0) {
    _internal_set_firmware_minor(from._internal_firmware_minor());
  }
  if (from.capability_flags() != 0) {
    _internal_set_capability_flags(from._internal_capability_flags());
  }
}

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

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

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

void HelloRsp::InternalSwap(HelloRsp* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(HelloRsp, capability_flags_)
      + sizeof(HelloRsp::capability_flags_)
      - PROTOBUF_FIELD_OFFSET(HelloRsp, protocol_version_)>(
          reinterpret_cast<char*>(&protocol_version_),
          reinterpret_cast<char*>(&other->protocol_version_));
}

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


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

void Bitmap::InitAsDefaultInstance() {
}
class Bitmap::_Internal {
 public:
};

Bitmap::Bitmap(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyboard.cdc.Bitmap)
}
Bitmap::Bitmap(const Bitmap& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  usage_bitmap_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (!from._internal_usage_bitmap().empty()) {
    usage_bitmap_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from._internal_usage_bitmap(),
      GetArena());
  }
  // @@protoc_insertion_point(copy_constructor:keyboard.cdc.Bitmap)
}

void Bitmap::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Bitmap_keyboard_2eproto.base);
  usage_bitmap_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

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

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

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


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

  usage_bitmap_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Bitmap::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ::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) {
      // bytes usage_bitmap = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_usage_bitmap();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          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:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  // bytes usage_bitmap = 1;
  if (this->usage_bitmap().size() > 0) {
    target = stream->WriteBytesMaybeAliased(
        1, this->_internal_usage_bitmap(), 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:keyboard.cdc.Bitmap)
  return target;
}

size_t Bitmap::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyboard.cdc.Bitmap)
  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;

  // bytes usage_bitmap = 1;
  if (this->usage_bitmap().size() > 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
        this->_internal_usage_bitmap());
  }

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

void Bitmap::MergeFrom(const Bitmap& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:keyboard.cdc.Bitmap)
  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.usage_bitmap().size() > 0) {
    _internal_set_usage_bitmap(from._internal_usage_bitmap());
  }
}

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

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

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

void Bitmap::InternalSwap(Bitmap* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  usage_bitmap_.Swap(&other->usage_bitmap_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}

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


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

void FunctionKeyEvent::InitAsDefaultInstance() {
}
class FunctionKeyEvent::_Internal {
 public:
};

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

void FunctionKeyEvent::SharedCtor() {
  ::memset(&usage_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&action_) -
      reinterpret_cast<char*>(&usage_)) + sizeof(action_));
}

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

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

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


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

  ::memset(&usage_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&action_) -
      reinterpret_cast<char*>(&usage_)) + sizeof(action_));
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* FunctionKeyEvent::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ::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) {
      // uint32 usage = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          usage_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .keyboard.cdc.KeyAction action = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          _internal_set_action(static_cast<::keyboard::cdc::KeyAction>(val));
        } 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:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  // uint32 usage = 1;
  if (this->usage() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_usage(), target);
  }

  // .keyboard.cdc.KeyAction action = 2;
  if (this->action() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      2, this->_internal_action(), 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:keyboard.cdc.FunctionKeyEvent)
  return target;
}

size_t FunctionKeyEvent::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyboard.cdc.FunctionKeyEvent)
  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;

  // uint32 usage = 1;
  if (this->usage() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->_internal_usage());
  }

  // .keyboard.cdc.KeyAction action = 2;
  if (this->action() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_action());
  }

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

void FunctionKeyEvent::MergeFrom(const FunctionKeyEvent& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:keyboard.cdc.FunctionKeyEvent)
  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.usage() != 0) {
    _internal_set_usage(from._internal_usage());
  }
  if (from.action() != 0) {
    _internal_set_action(from._internal_action());
  }
}

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

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

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

void FunctionKeyEvent::InternalSwap(FunctionKeyEvent* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(FunctionKeyEvent, action_)
      + sizeof(FunctionKeyEvent::action_)
      - PROTOBUF_FIELD_OFFSET(FunctionKeyEvent, usage_)>(
          reinterpret_cast<char*>(&usage_),
          reinterpret_cast<char*>(&other->usage_));
}

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


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

void LedState::InitAsDefaultInstance() {
}
class LedState::_Internal {
 public:
};

LedState::LedState(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyboard.cdc.LedState)
}
LedState::LedState(const LedState& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  led_mask_ = from.led_mask_;
  // @@protoc_insertion_point(copy_constructor:keyboard.cdc.LedState)
}

void LedState::SharedCtor() {
  led_mask_ = 0u;
}

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

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

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


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

  led_mask_ = 0u;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* LedState::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ::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) {
      // uint32 led_mask = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          led_mask_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&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:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  // uint32 led_mask = 1;
  if (this->led_mask() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_led_mask(), 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:keyboard.cdc.LedState)
  return target;
}

size_t LedState::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyboard.cdc.LedState)
  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;

  // uint32 led_mask = 1;
  if (this->led_mask() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->_internal_led_mask());
  }

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

void LedState::MergeFrom(const LedState& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:keyboard.cdc.LedState)
  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.led_mask() != 0) {
    _internal_set_led_mask(from._internal_led_mask());
  }
}

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

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

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

void LedState::InternalSwap(LedState* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(led_mask_, other->led_mask_);
}

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


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

void TimeSync::InitAsDefaultInstance() {
}
class TimeSync::_Internal {
 public:
};

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

void TimeSync::SharedCtor() {
  ::memset(&version_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&accuracy_ms_) -
      reinterpret_cast<char*>(&version_)) + sizeof(accuracy_ms_));
}

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

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

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


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

  ::memset(&version_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&accuracy_ms_) -
      reinterpret_cast<char*>(&version_)) + sizeof(accuracy_ms_));
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* TimeSync::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ::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) {
      // uint32 version = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          version_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // uint32 flags = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          flags_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // sint32 timezone_min = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          timezone_min_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarintZigZag32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // fixed64 utc_ms = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 33)) {
          utc_ms_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr);
          ptr += sizeof(::PROTOBUF_NAMESPACE_ID::uint64);
        } else goto handle_unusual;
        continue;
      // fixed32 accuracy_ms = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 45)) {
          accuracy_ms_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint32>(ptr);
          ptr += sizeof(::PROTOBUF_NAMESPACE_ID::uint32);
        } 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:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  // uint32 version = 1;
  if (this->version() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_version(), target);
  }

  // uint32 flags = 2;
  if (this->flags() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_flags(), target);
  }

  // sint32 timezone_min = 3;
  if (this->timezone_min() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteSInt32ToArray(3, this->_internal_timezone_min(), target);
  }

  // fixed64 utc_ms = 4;
  if (this->utc_ms() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFixed64ToArray(4, this->_internal_utc_ms(), target);
  }

  // fixed32 accuracy_ms = 5;
  if (this->accuracy_ms() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFixed32ToArray(5, this->_internal_accuracy_ms(), 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:keyboard.cdc.TimeSync)
  return target;
}

size_t TimeSync::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyboard.cdc.TimeSync)
  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;

  // uint32 version = 1;
  if (this->version() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->_internal_version());
  }

  // uint32 flags = 2;
  if (this->flags() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->_internal_flags());
  }

  // fixed64 utc_ms = 4;
  if (this->utc_ms() != 0) {
    total_size += 1 + 8;
  }

  // sint32 timezone_min = 3;
  if (this->timezone_min() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SInt32Size(
        this->_internal_timezone_min());
  }

  // fixed32 accuracy_ms = 5;
  if (this->accuracy_ms() != 0) {
    total_size += 1 + 4;
  }

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

void TimeSync::MergeFrom(const TimeSync& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:keyboard.cdc.TimeSync)
  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.version() != 0) {
    _internal_set_version(from._internal_version());
  }
  if (from.flags() != 0) {
    _internal_set_flags(from._internal_flags());
  }
  if (from.utc_ms() != 0) {
    _internal_set_utc_ms(from._internal_utc_ms());
  }
  if (from.timezone_min() != 0) {
    _internal_set_timezone_min(from._internal_timezone_min());
  }
  if (from.accuracy_ms() != 0) {
    _internal_set_accuracy_ms(from._internal_accuracy_ms());
  }
}

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

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

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

void TimeSync::InternalSwap(TimeSync* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(TimeSync, accuracy_ms_)
      + sizeof(TimeSync::accuracy_ms_)
      - PROTOBUF_FIELD_OFFSET(TimeSync, version_)>(
          reinterpret_cast<char*>(&version_),
          reinterpret_cast<char*>(&other->version_));
}

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


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

void ThemeRgb::InitAsDefaultInstance() {
}
class ThemeRgb::_Internal {
 public:
};

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

void ThemeRgb::SharedCtor() {
  ::memset(&red_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&blue_) -
      reinterpret_cast<char*>(&red_)) + sizeof(blue_));
}

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

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

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


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

  ::memset(&red_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&blue_) -
      reinterpret_cast<char*>(&red_)) + sizeof(blue_));
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* ThemeRgb::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ::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) {
      // uint32 red = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          red_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // uint32 green = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          green_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // uint32 blue = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          blue_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&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:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  // uint32 red = 1;
  if (this->red() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_red(), target);
  }

  // uint32 green = 2;
  if (this->green() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_green(), target);
  }

  // uint32 blue = 3;
  if (this->blue() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_blue(), 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:keyboard.cdc.ThemeRgb)
  return target;
}

size_t ThemeRgb::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyboard.cdc.ThemeRgb)
  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;

  // uint32 red = 1;
  if (this->red() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->_internal_red());
  }

  // uint32 green = 2;
  if (this->green() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->_internal_green());
  }

  // uint32 blue = 3;
  if (this->blue() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->_internal_blue());
  }

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

void ThemeRgb::MergeFrom(const ThemeRgb& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:keyboard.cdc.ThemeRgb)
  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.red() != 0) {
    _internal_set_red(from._internal_red());
  }
  if (from.green() != 0) {
    _internal_set_green(from._internal_green());
  }
  if (from.blue() != 0) {
    _internal_set_blue(from._internal_blue());
  }
}

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

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

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

void ThemeRgb::InternalSwap(ThemeRgb* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(ThemeRgb, blue_)
      + sizeof(ThemeRgb::blue_)
      - PROTOBUF_FIELD_OFFSET(ThemeRgb, red_)>(
          reinterpret_cast<char*>(&red_),
          reinterpret_cast<char*>(&other->red_));
}

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


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

void Ack::InitAsDefaultInstance() {
}
class Ack::_Internal {
 public:
};

Ack::Ack(::PROTOBUF_NAMESPACE_ID::Arena* arena)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena) {
  SharedCtor();
  RegisterArenaDtor(arena);
  // @@protoc_insertion_point(arena_constructor:keyboard.cdc.Ack)
}
Ack::Ack(const Ack& from)
  : ::PROTOBUF_NAMESPACE_ID::Message() {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  acked_type_ = from.acked_type_;
  // @@protoc_insertion_point(copy_constructor:keyboard.cdc.Ack)
}

void Ack::SharedCtor() {
  acked_type_ = 0u;
}

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

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

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


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

  acked_type_ = 0u;
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Ack::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ::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) {
      // uint32 acked_type = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          acked_type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&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:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  // uint32 acked_type = 1;
  if (this->acked_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_acked_type(), 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:keyboard.cdc.Ack)
  return target;
}

size_t Ack::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyboard.cdc.Ack)
  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;

  // uint32 acked_type = 1;
  if (this->acked_type() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->_internal_acked_type());
  }

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

void Ack::MergeFrom(const Ack& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:keyboard.cdc.Ack)
  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.acked_type() != 0) {
    _internal_set_acked_type(from._internal_acked_type());
  }
}

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

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

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

void Ack::InternalSwap(Ack* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(acked_type_, other->acked_type_);
}

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


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

void Error::InitAsDefaultInstance() {
}
class Error::_Internal {
 public:
};

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

void Error::SharedCtor() {
  ::memset(&error_type_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&error_code_) -
      reinterpret_cast<char*>(&error_type_)) + sizeof(error_code_));
}

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

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

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


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

  ::memset(&error_type_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&error_code_) -
      reinterpret_cast<char*>(&error_type_)) + sizeof(error_code_));
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* Error::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  ::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) {
      // uint32 error_type = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          error_type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .keyboard.cdc.ErrorCode error_code = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          _internal_set_error_code(static_cast<::keyboard::cdc::ErrorCode>(val));
        } 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:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

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

  // uint32 error_type = 1;
  if (this->error_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_error_type(), target);
  }

  // .keyboard.cdc.ErrorCode error_code = 2;
  if (this->error_code() != 0) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      2, this->_internal_error_code(), 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:keyboard.cdc.Error)
  return target;
}

size_t Error::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:keyboard.cdc.Error)
  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;

  // uint32 error_type = 1;
  if (this->error_type() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
        this->_internal_error_type());
  }

  // .keyboard.cdc.ErrorCode error_code = 2;
  if (this->error_code() != 0) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_error_code());
  }

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

void Error::MergeFrom(const Error& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:keyboard.cdc.Error)
  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.error_type() != 0) {
    _internal_set_error_type(from._internal_error_type());
  }
  if (from.error_code() != 0) {
    _internal_set_error_code(from._internal_error_code());
  }
}

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

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

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

void Error::InternalSwap(Error* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(Error, error_code_)
      + sizeof(Error::error_code_)
      - PROTOBUF_FIELD_OFFSET(Error, error_type_)>(
          reinterpret_cast<char*>(&error_type_),
          reinterpret_cast<char*>(&other->error_type_));
}

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


// @@protoc_insertion_point(namespace_scope)
}  // namespace cdc
}  // namespace keyboard
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::keyboard::cdc::CdcFrame* Arena::CreateMaybeMessage< ::keyboard::cdc::CdcFrame >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyboard::cdc::CdcFrame >(arena);
}
template<> PROTOBUF_NOINLINE ::keyboard::cdc::CdcPacketBody* Arena::CreateMaybeMessage< ::keyboard::cdc::CdcPacketBody >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyboard::cdc::CdcPacketBody >(arena);
}
template<> PROTOBUF_NOINLINE ::keyboard::cdc::HelloReq* Arena::CreateMaybeMessage< ::keyboard::cdc::HelloReq >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyboard::cdc::HelloReq >(arena);
}
template<> PROTOBUF_NOINLINE ::keyboard::cdc::HelloRsp* Arena::CreateMaybeMessage< ::keyboard::cdc::HelloRsp >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyboard::cdc::HelloRsp >(arena);
}
template<> PROTOBUF_NOINLINE ::keyboard::cdc::Bitmap* Arena::CreateMaybeMessage< ::keyboard::cdc::Bitmap >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyboard::cdc::Bitmap >(arena);
}
template<> PROTOBUF_NOINLINE ::keyboard::cdc::FunctionKeyEvent* Arena::CreateMaybeMessage< ::keyboard::cdc::FunctionKeyEvent >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyboard::cdc::FunctionKeyEvent >(arena);
}
template<> PROTOBUF_NOINLINE ::keyboard::cdc::LedState* Arena::CreateMaybeMessage< ::keyboard::cdc::LedState >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyboard::cdc::LedState >(arena);
}
template<> PROTOBUF_NOINLINE ::keyboard::cdc::TimeSync* Arena::CreateMaybeMessage< ::keyboard::cdc::TimeSync >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyboard::cdc::TimeSync >(arena);
}
template<> PROTOBUF_NOINLINE ::keyboard::cdc::ThemeRgb* Arena::CreateMaybeMessage< ::keyboard::cdc::ThemeRgb >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyboard::cdc::ThemeRgb >(arena);
}
template<> PROTOBUF_NOINLINE ::keyboard::cdc::Ack* Arena::CreateMaybeMessage< ::keyboard::cdc::Ack >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyboard::cdc::Ack >(arena);
}
template<> PROTOBUF_NOINLINE ::keyboard::cdc::Error* Arena::CreateMaybeMessage< ::keyboard::cdc::Error >(Arena* arena) {
  return Arena::CreateMessageInternal< ::keyboard::cdc::Error >(arena);
}
PROTOBUF_NAMESPACE_CLOSE

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