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

#include "hillab_beam_stabilization_system.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/io/zero_copy_stream_impl_lite.h"
#include "google/protobuf/generated_message_tctable_impl.h"
// @@protoc_insertion_point(includes)

// Must be included last.
#include "google/protobuf/port_def.inc"
PROTOBUF_PRAGMA_INIT_SEG
namespace _pb = ::google::protobuf;
namespace _pbi = ::google::protobuf::internal;
namespace _fl = ::google::protobuf::internal::field_layout;
namespace hillab {
namespace v4 {

inline constexpr Value::Impl_::Impl_(
    ::_pbi::ConstantInitialized) noexcept
      : value_{},
        _cached_size_{0},
        _oneof_case_{} {}

template <typename>
PROTOBUF_CONSTEXPR Value::Value(::_pbi::ConstantInitialized)
    : _impl_(::_pbi::ConstantInitialized()) {}
struct ValueDefaultTypeInternal {
  PROTOBUF_CONSTEXPR ValueDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~ValueDefaultTypeInternal() {}
  union {
    Value _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ValueDefaultTypeInternal _Value_default_instance_;

inline constexpr PresetResponse::Impl_::Impl_(
    ::_pbi::ConstantInitialized) noexcept
      : name_(
            &::google::protobuf::internal::fixed_address_empty_string,
            ::_pbi::ConstantInitialized()),
        _cached_size_{0} {}

template <typename>
PROTOBUF_CONSTEXPR PresetResponse::PresetResponse(::_pbi::ConstantInitialized)
    : _impl_(::_pbi::ConstantInitialized()) {}
struct PresetResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PresetResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PresetResponseDefaultTypeInternal() {}
  union {
    PresetResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PresetResponseDefaultTypeInternal _PresetResponse_default_instance_;

inline constexpr PresetRequest::Impl_::Impl_(
    ::_pbi::ConstantInitialized) noexcept
      : name_(
            &::google::protobuf::internal::fixed_address_empty_string,
            ::_pbi::ConstantInitialized()),
        _cached_size_{0} {}

template <typename>
PROTOBUF_CONSTEXPR PresetRequest::PresetRequest(::_pbi::ConstantInitialized)
    : _impl_(::_pbi::ConstantInitialized()) {}
struct PresetRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PresetRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PresetRequestDefaultTypeInternal() {}
  union {
    PresetRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PresetRequestDefaultTypeInternal _PresetRequest_default_instance_;

inline constexpr PresetListResponse::Impl_::Impl_(
    ::_pbi::ConstantInitialized) noexcept
      : name_list_{},
        _cached_size_{0} {}

template <typename>
PROTOBUF_CONSTEXPR PresetListResponse::PresetListResponse(::_pbi::ConstantInitialized)
    : _impl_(::_pbi::ConstantInitialized()) {}
struct PresetListResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PresetListResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PresetListResponseDefaultTypeInternal() {}
  union {
    PresetListResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PresetListResponseDefaultTypeInternal _PresetListResponse_default_instance_;

inline constexpr ImageStreamServerResponse::Impl_::Impl_(
    ::_pbi::ConstantInitialized) noexcept
      : ip_(
            &::google::protobuf::internal::fixed_address_empty_string,
            ::_pbi::ConstantInitialized()),
        sdp_(
            &::google::protobuf::internal::fixed_address_empty_string,
            ::_pbi::ConstantInitialized()),
        port_{0},
        mtu_{0},
        downscale_{0},
        running_{false},
        auto_running_{false},
        _cached_size_{0} {}

template <typename>
PROTOBUF_CONSTEXPR ImageStreamServerResponse::ImageStreamServerResponse(::_pbi::ConstantInitialized)
    : _impl_(::_pbi::ConstantInitialized()) {}
struct ImageStreamServerResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR ImageStreamServerResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~ImageStreamServerResponseDefaultTypeInternal() {}
  union {
    ImageStreamServerResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ImageStreamServerResponseDefaultTypeInternal _ImageStreamServerResponse_default_instance_;

inline constexpr ImageStreamServerRequest::Impl_::Impl_(
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        mtu_{0},
        running_{false},
        auto_running_{false},
        downscale_{0} {}

template <typename>
PROTOBUF_CONSTEXPR ImageStreamServerRequest::ImageStreamServerRequest(::_pbi::ConstantInitialized)
    : _impl_(::_pbi::ConstantInitialized()) {}
struct ImageStreamServerRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR ImageStreamServerRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~ImageStreamServerRequestDefaultTypeInternal() {}
  union {
    ImageStreamServerRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ImageStreamServerRequestDefaultTypeInternal _ImageStreamServerRequest_default_instance_;

inline constexpr GetRequest::Impl_::Impl_(
    ::_pbi::ConstantInitialized) noexcept
      : key_(
            &::google::protobuf::internal::fixed_address_empty_string,
            ::_pbi::ConstantInitialized()),
        _cached_size_{0} {}

template <typename>
PROTOBUF_CONSTEXPR GetRequest::GetRequest(::_pbi::ConstantInitialized)
    : _impl_(::_pbi::ConstantInitialized()) {}
struct GetRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetRequestDefaultTypeInternal() {}
  union {
    GetRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetRequestDefaultTypeInternal _GetRequest_default_instance_;

inline constexpr BeamProfile::Impl_::Impl_(
    ::_pbi::ConstantInitialized) noexcept
      : latest_value_{0},
        average_{0},
        standard_deviation_{0},
        index_{0},
        _cached_size_{0} {}

template <typename>
PROTOBUF_CONSTEXPR BeamProfile::BeamProfile(::_pbi::ConstantInitialized)
    : _impl_(::_pbi::ConstantInitialized()) {}
struct BeamProfileDefaultTypeInternal {
  PROTOBUF_CONSTEXPR BeamProfileDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~BeamProfileDefaultTypeInternal() {}
  union {
    BeamProfile _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BeamProfileDefaultTypeInternal _BeamProfile_default_instance_;

inline constexpr AppInfoResponse::Impl_::Impl_(
    ::_pbi::ConstantInitialized) noexcept
      : version_(
            &::google::protobuf::internal::fixed_address_empty_string,
            ::_pbi::ConstantInitialized()),
        _cached_size_{0} {}

template <typename>
PROTOBUF_CONSTEXPR AppInfoResponse::AppInfoResponse(::_pbi::ConstantInitialized)
    : _impl_(::_pbi::ConstantInitialized()) {}
struct AppInfoResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR AppInfoResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~AppInfoResponseDefaultTypeInternal() {}
  union {
    AppInfoResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AppInfoResponseDefaultTypeInternal _AppInfoResponse_default_instance_;

inline constexpr SystemLogStream::Impl_::Impl_(
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        message_(
            &::google::protobuf::internal::fixed_address_empty_string,
            ::_pbi::ConstantInitialized()),
        time_{nullptr},
        type_{static_cast< ::hillab::v4::SystemLogType >(0)} {}

template <typename>
PROTOBUF_CONSTEXPR SystemLogStream::SystemLogStream(::_pbi::ConstantInitialized)
    : _impl_(::_pbi::ConstantInitialized()) {}
struct SystemLogStreamDefaultTypeInternal {
  PROTOBUF_CONSTEXPR SystemLogStreamDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~SystemLogStreamDefaultTypeInternal() {}
  union {
    SystemLogStream _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SystemLogStreamDefaultTypeInternal _SystemLogStream_default_instance_;

inline constexpr SetRequest::Impl_::Impl_(
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        key_(
            &::google::protobuf::internal::fixed_address_empty_string,
            ::_pbi::ConstantInitialized()),
        value_{nullptr} {}

template <typename>
PROTOBUF_CONSTEXPR SetRequest::SetRequest(::_pbi::ConstantInitialized)
    : _impl_(::_pbi::ConstantInitialized()) {}
struct SetRequestDefaultTypeInternal {
  PROTOBUF_CONSTEXPR SetRequestDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~SetRequestDefaultTypeInternal() {}
  union {
    SetRequest _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SetRequestDefaultTypeInternal _SetRequest_default_instance_;

inline constexpr GetResponse::Impl_::Impl_(
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        key_(
            &::google::protobuf::internal::fixed_address_empty_string,
            ::_pbi::ConstantInitialized()),
        unit_(
            &::google::protobuf::internal::fixed_address_empty_string,
            ::_pbi::ConstantInitialized()),
        value_{nullptr},
        min_value_{nullptr},
        max_value_{nullptr} {}

template <typename>
PROTOBUF_CONSTEXPR GetResponse::GetResponse(::_pbi::ConstantInitialized)
    : _impl_(::_pbi::ConstantInitialized()) {}
struct GetResponseDefaultTypeInternal {
  PROTOBUF_CONSTEXPR GetResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~GetResponseDefaultTypeInternal() {}
  union {
    GetResponse _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetResponseDefaultTypeInternal _GetResponse_default_instance_;

inline constexpr BeamProfileStream::Impl_::Impl_(
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        beam_profiles_{},
        time_{nullptr} {}

template <typename>
PROTOBUF_CONSTEXPR BeamProfileStream::BeamProfileStream(::_pbi::ConstantInitialized)
    : _impl_(::_pbi::ConstantInitialized()) {}
struct BeamProfileStreamDefaultTypeInternal {
  PROTOBUF_CONSTEXPR BeamProfileStreamDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~BeamProfileStreamDefaultTypeInternal() {}
  union {
    BeamProfileStream _instance;
  };
};

PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BeamProfileStreamDefaultTypeInternal _BeamProfileStream_default_instance_;
}  // namespace v4
}  // namespace hillab
namespace hillab {
namespace v4 {
PROTOBUF_CONSTINIT const uint32_t SystemLogType_internal_data_[] = {
    131072u, 0u, };
bool SystemLogType_IsValid(int value) {
  return 0 <= value && value <= 1;
}
static ::google::protobuf::internal::ExplicitlyConstructed<std::string>
    SystemLogType_strings[2] = {};

static const char SystemLogType_names[] = {
    "SYSTEMLOGTYPE_ERROR"
    "SYSTEMLOGTYPE_INFO"
};

static const ::google::protobuf::internal::EnumEntry SystemLogType_entries[] =
    {
        {{&SystemLogType_names[0], 19}, 1},
        {{&SystemLogType_names[19], 18}, 0},
};

static const int SystemLogType_entries_by_number[] = {
    1,  // 0 -> SYSTEMLOGTYPE_INFO
    0,  // 1 -> SYSTEMLOGTYPE_ERROR
};

const std::string& SystemLogType_Name(SystemLogType value) {
  static const bool kDummy =
      ::google::protobuf::internal::InitializeEnumStrings(
          SystemLogType_entries, SystemLogType_entries_by_number,
          2, SystemLogType_strings);
  (void)kDummy;

  int idx = ::google::protobuf::internal::LookUpEnumName(
      SystemLogType_entries, SystemLogType_entries_by_number, 2,
      value);
  return idx == -1 ? ::google::protobuf::internal::GetEmptyString()
                   : SystemLogType_strings[idx].get();
}

bool SystemLogType_Parse(absl::string_view name, SystemLogType* value) {
  int int_value;
  bool success = ::google::protobuf::internal::LookUpEnumValue(
      SystemLogType_entries, 2, name, &int_value);
  if (success) {
    *value = static_cast<SystemLogType>(int_value);
  }
  return success;
}
// ===================================================================

class Value::_Internal {
 public:
  static constexpr ::int32_t kOneofCaseOffset =
    PROTOBUF_FIELD_OFFSET(::hillab::v4::Value, _impl_._oneof_case_);
};

Value::Value(::google::protobuf::Arena* arena)
    : ::google::protobuf::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:hillab.v4.Value)
}
inline PROTOBUF_NDEBUG_INLINE Value::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena,
    const Impl_& from)
      : value_{},
        _cached_size_{0},
        _oneof_case_{from._oneof_case_[0]} {}

Value::Value(
    ::google::protobuf::Arena* arena,
    const Value& from)
    : ::google::protobuf::MessageLite(arena) {
  Value* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<std::string>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_);
  switch (value_case()) {
    case VALUE_NOT_SET:
      break;
      case kBoolValue:
        _impl_.value_.bool_value_ = from._impl_.value_.bool_value_;
        break;
      case kIntValue:
        _impl_.value_.int_value_ = from._impl_.value_.int_value_;
        break;
      case kFloatValue:
        _impl_.value_.float_value_ = from._impl_.value_.float_value_;
        break;
      case kStringValue:
        new (&_impl_.value_.string_value_) decltype(_impl_.value_.string_value_){arena, from._impl_.value_.string_value_};
        break;
  }

  // @@protoc_insertion_point(copy_constructor:hillab.v4.Value)
}
inline PROTOBUF_NDEBUG_INLINE Value::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility,
    ::google::protobuf::Arena* arena)
      : value_{},
        _cached_size_{0},
        _oneof_case_{} {}

inline void Value::SharedCtor(::_pb::Arena* arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
}
Value::~Value() {
  // @@protoc_insertion_point(destructor:hillab.v4.Value)
  _internal_metadata_.Delete<std::string>();
  SharedDtor();
}
inline void Value::SharedDtor() {
  ABSL_DCHECK(GetArena() == nullptr);
  if (has_value()) {
    clear_value();
  }
  _impl_.~Impl_();
}

void Value::clear_value() {
// @@protoc_insertion_point(one_of_clear_start:hillab.v4.Value)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  switch (value_case()) {
    case kBoolValue: {
      // No need to clear
      break;
    }
    case kIntValue: {
      // No need to clear
      break;
    }
    case kFloatValue: {
      // No need to clear
      break;
    }
    case kStringValue: {
      _impl_.value_.string_value_.Destroy();
      break;
    }
    case VALUE_NOT_SET: {
      break;
    }
  }
  _impl_._oneof_case_[0] = VALUE_NOT_SET;
}


PROTOBUF_NOINLINE void Value::Clear() {
// @@protoc_insertion_point(message_clear_start:hillab.v4.Value)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  clear_value();
  _internal_metadata_.Clear<std::string>();
}

const char* Value::_InternalParse(
    const char* ptr, ::_pbi::ParseContext* ctx) {
  ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header);
  return ptr;
}


PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::_pbi::TcParseTable<0, 4, 0, 36, 2> Value::_table_ = {
  {
    0,  // no _has_bits_
    0, // no _extensions_
    4, 0,  // max_field_number, fast_idx_mask
    offsetof(decltype(_table_), field_lookup_table),
    4294967280,  // skipmap
    offsetof(decltype(_table_), field_entries),
    4,  // num_field_entries
    0,  // num_aux_entries
    offsetof(decltype(_table_), field_names),  // no aux_entries
    &_Value_default_instance_._instance,
    ::_pbi::TcParser::GenericFallbackLite,  // fallback
  }, {{
    {::_pbi::TcParser::MiniParse, {}},
  }}, {{
    65535, 65535
  }}, {{
    // bool bool_value = 1;
    {PROTOBUF_FIELD_OFFSET(Value, _impl_.value_.bool_value_), _Internal::kOneofCaseOffset + 0, 0,
    (0 | ::_fl::kFcOneof | ::_fl::kBool)},
    // int32 int_value = 2;
    {PROTOBUF_FIELD_OFFSET(Value, _impl_.value_.int_value_), _Internal::kOneofCaseOffset + 0, 0,
    (0 | ::_fl::kFcOneof | ::_fl::kInt32)},
    // float float_value = 3;
    {PROTOBUF_FIELD_OFFSET(Value, _impl_.value_.float_value_), _Internal::kOneofCaseOffset + 0, 0,
    (0 | ::_fl::kFcOneof | ::_fl::kFloat)},
    // string string_value = 4;
    {PROTOBUF_FIELD_OFFSET(Value, _impl_.value_.string_value_), _Internal::kOneofCaseOffset + 0, 0,
    (0 | ::_fl::kFcOneof | ::_fl::kUtf8String | ::_fl::kRepAString)},
  }},
  // no aux_entries
  {{
    "\17\0\0\0\14\0\0\0"
    "hillab.v4.Value"
    "string_value"
  }},
};

::uint8_t* Value::_InternalSerialize(
    ::uint8_t* target,
    ::google::protobuf::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:hillab.v4.Value)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  switch (value_case()) {
    case kBoolValue: {
      target = stream->EnsureSpace(target);
      target = ::_pbi::WireFormatLite::WriteBoolToArray(
          1, this->_internal_bool_value(), target);
      break;
    }
    case kIntValue: {
      target = ::google::protobuf::internal::WireFormatLite::
          WriteInt32ToArrayWithField<2>(
              stream, this->_internal_int_value(), target);
      break;
    }
    case kFloatValue: {
      target = stream->EnsureSpace(target);
      target = ::_pbi::WireFormatLite::WriteFloatToArray(
          3, this->_internal_float_value(), target);
      break;
    }
    case kStringValue: {
      const std::string& _s = this->_internal_string_value();
      ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
          _s.data(), static_cast<int>(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "hillab.v4.Value.string_value");
      target = stream->WriteStringMaybeAliased(4, _s, target);
      break;
    }
    default:
      break;
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(
        _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:hillab.v4.Value)
  return target;
}

::size_t Value::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:hillab.v4.Value)
  ::size_t total_size = 0;

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

  switch (value_case()) {
    // bool bool_value = 1;
    case kBoolValue: {
      total_size += 2;
      break;
    }
    // int32 int_value = 2;
    case kIntValue: {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this->_internal_int_value());
      break;
    }
    // float float_value = 3;
    case kFloatValue: {
      total_size += 5;
      break;
    }
    // string string_value = 4;
    case kStringValue: {
      total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize(
                                      this->_internal_string_value());
      break;
    }
    case VALUE_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString).size();
  }
  _impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size));
  return total_size;
}

void Value::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const Value*>(
      &from));
}

void Value::MergeFrom(const Value& from) {
  Value* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:hillab.v4.Value)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  switch (from.value_case()) {
    case kBoolValue: {
      _this->_internal_set_bool_value(from._internal_bool_value());
      break;
    }
    case kIntValue: {
      _this->_internal_set_int_value(from._internal_int_value());
      break;
    }
    case kFloatValue: {
      _this->_internal_set_float_value(from._internal_float_value());
      break;
    }
    case kStringValue: {
      _this->_internal_set_string_value(from._internal_string_value());
      break;
    }
    case VALUE_NOT_SET: {
      break;
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

PROTOBUF_NOINLINE bool Value::IsInitialized() const {
  return true;
}

::_pbi::CachedSize* Value::AccessCachedSize() const {
  return &_impl_._cached_size_;
}
void Value::InternalSwap(Value* PROTOBUF_RESTRICT other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_.value_, other->_impl_.value_);
  swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
}

std::string Value::GetTypeName() const {
  return "hillab.v4.Value";
}

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

class SetRequest::_Internal {
 public:
  using HasBits = decltype(std::declval<SetRequest>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
    8 * PROTOBUF_FIELD_OFFSET(SetRequest, _impl_._has_bits_);
  static const ::hillab::v4::Value& value(const SetRequest* msg);
  static void set_has_value(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

const ::hillab::v4::Value& SetRequest::_Internal::value(const SetRequest* msg) {
  return *msg->_impl_.value_;
}
SetRequest::SetRequest(::google::protobuf::Arena* arena)
    : ::google::protobuf::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:hillab.v4.SetRequest)
}
inline PROTOBUF_NDEBUG_INLINE SetRequest::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena,
    const Impl_& from)
      : _has_bits_{from._has_bits_},
        _cached_size_{0},
        key_(arena, from.key_) {}

SetRequest::SetRequest(
    ::google::protobuf::Arena* arena,
    const SetRequest& from)
    : ::google::protobuf::MessageLite(arena) {
  SetRequest* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<std::string>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_);
  ::uint32_t cached_has_bits = _impl_._has_bits_[0];
  _impl_.value_ = (cached_has_bits & 0x00000001u)
                ? CreateMaybeMessage<::hillab::v4::Value>(arena, *from._impl_.value_)
                : nullptr;

  // @@protoc_insertion_point(copy_constructor:hillab.v4.SetRequest)
}
inline PROTOBUF_NDEBUG_INLINE SetRequest::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility,
    ::google::protobuf::Arena* arena)
      : _cached_size_{0},
        key_(arena) {}

inline void SetRequest::SharedCtor(::_pb::Arena* arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  _impl_.value_ = {};
}
SetRequest::~SetRequest() {
  // @@protoc_insertion_point(destructor:hillab.v4.SetRequest)
  _internal_metadata_.Delete<std::string>();
  SharedDtor();
}
inline void SetRequest::SharedDtor() {
  ABSL_DCHECK(GetArena() == nullptr);
  _impl_.key_.Destroy();
  delete _impl_.value_;
  _impl_.~Impl_();
}

PROTOBUF_NOINLINE void SetRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:hillab.v4.SetRequest)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.key_.ClearToEmpty();
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    ABSL_DCHECK(_impl_.value_ != nullptr);
    _impl_.value_->Clear();
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* SetRequest::_InternalParse(
    const char* ptr, ::_pbi::ParseContext* ctx) {
  ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header);
  return ptr;
}


PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::_pbi::TcParseTable<1, 2, 1, 32, 2> SetRequest::_table_ = {
  {
    PROTOBUF_FIELD_OFFSET(SetRequest, _impl_._has_bits_),
    0, // no _extensions_
    2, 8,  // max_field_number, fast_idx_mask
    offsetof(decltype(_table_), field_lookup_table),
    4294967292,  // skipmap
    offsetof(decltype(_table_), field_entries),
    2,  // num_field_entries
    1,  // num_aux_entries
    offsetof(decltype(_table_), aux_entries),
    &_SetRequest_default_instance_._instance,
    ::_pbi::TcParser::GenericFallbackLite,  // fallback
  }, {{
    // .hillab.v4.Value value = 2;
    {::_pbi::TcParser::FastMtS1,
     {18, 0, 0, PROTOBUF_FIELD_OFFSET(SetRequest, _impl_.value_)}},
    // string key = 1;
    {::_pbi::TcParser::FastUS1,
     {10, 63, 0, PROTOBUF_FIELD_OFFSET(SetRequest, _impl_.key_)}},
  }}, {{
    65535, 65535
  }}, {{
    // string key = 1;
    {PROTOBUF_FIELD_OFFSET(SetRequest, _impl_.key_), -1, 0,
    (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)},
    // .hillab.v4.Value value = 2;
    {PROTOBUF_FIELD_OFFSET(SetRequest, _impl_.value_), _Internal::kHasBitsOffset + 0, 0,
    (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
  }}, {{
    {::_pbi::TcParser::GetTable<::hillab::v4::Value>()},
  }}, {{
    "\24\3\0\0\0\0\0\0"
    "hillab.v4.SetRequest"
    "key"
  }},
};

::uint8_t* SetRequest::_InternalSerialize(
    ::uint8_t* target,
    ::google::protobuf::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:hillab.v4.SetRequest)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  // string key = 1;
  if (!this->_internal_key().empty()) {
    const std::string& _s = this->_internal_key();
    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "hillab.v4.SetRequest.key");
    target = stream->WriteStringMaybeAliased(1, _s, target);
  }

  cached_has_bits = _impl_._has_bits_[0];
  // .hillab.v4.Value value = 2;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
        2, _Internal::value(this),
        _Internal::value(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(
        _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:hillab.v4.SetRequest)
  return target;
}

::size_t SetRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:hillab.v4.SetRequest)
  ::size_t total_size = 0;

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

  // string key = 1;
  if (!this->_internal_key().empty()) {
    total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize(
                                    this->_internal_key());
  }

  // .hillab.v4.Value value = 2;
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size +=
        1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.value_);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString).size();
  }
  _impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size));
  return total_size;
}

void SetRequest::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const SetRequest*>(
      &from));
}

void SetRequest::MergeFrom(const SetRequest& from) {
  SetRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:hillab.v4.SetRequest)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_key().empty()) {
    _this->_internal_set_key(from._internal_key());
  }
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_internal_mutable_value()->::hillab::v4::Value::MergeFrom(
        from._internal_value());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

PROTOBUF_NOINLINE bool SetRequest::IsInitialized() const {
  return true;
}

::_pbi::CachedSize* SetRequest::AccessCachedSize() const {
  return &_impl_._cached_size_;
}
void SetRequest::InternalSwap(SetRequest* PROTOBUF_RESTRICT other) {
  using std::swap;
  auto* arena = GetArena();
  ABSL_DCHECK_EQ(arena, other->GetArena());
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.key_, &other->_impl_.key_, arena);
  swap(_impl_.value_, other->_impl_.value_);
}

std::string SetRequest::GetTypeName() const {
  return "hillab.v4.SetRequest";
}

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

class GetRequest::_Internal {
 public:
};

GetRequest::GetRequest(::google::protobuf::Arena* arena)
    : ::google::protobuf::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:hillab.v4.GetRequest)
}
inline PROTOBUF_NDEBUG_INLINE GetRequest::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena,
    const Impl_& from)
      : key_(arena, from.key_),
        _cached_size_{0} {}

GetRequest::GetRequest(
    ::google::protobuf::Arena* arena,
    const GetRequest& from)
    : ::google::protobuf::MessageLite(arena) {
  GetRequest* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<std::string>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_);

  // @@protoc_insertion_point(copy_constructor:hillab.v4.GetRequest)
}
inline PROTOBUF_NDEBUG_INLINE GetRequest::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility,
    ::google::protobuf::Arena* arena)
      : key_(arena),
        _cached_size_{0} {}

inline void GetRequest::SharedCtor(::_pb::Arena* arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
}
GetRequest::~GetRequest() {
  // @@protoc_insertion_point(destructor:hillab.v4.GetRequest)
  _internal_metadata_.Delete<std::string>();
  SharedDtor();
}
inline void GetRequest::SharedDtor() {
  ABSL_DCHECK(GetArena() == nullptr);
  _impl_.key_.Destroy();
  _impl_.~Impl_();
}

PROTOBUF_NOINLINE void GetRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:hillab.v4.GetRequest)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.key_.ClearToEmpty();
  _internal_metadata_.Clear<std::string>();
}

const char* GetRequest::_InternalParse(
    const char* ptr, ::_pbi::ParseContext* ctx) {
  ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header);
  return ptr;
}


PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::_pbi::TcParseTable<0, 1, 0, 32, 2> GetRequest::_table_ = {
  {
    0,  // no _has_bits_
    0, // no _extensions_
    1, 0,  // max_field_number, fast_idx_mask
    offsetof(decltype(_table_), field_lookup_table),
    4294967294,  // skipmap
    offsetof(decltype(_table_), field_entries),
    1,  // num_field_entries
    0,  // num_aux_entries
    offsetof(decltype(_table_), field_names),  // no aux_entries
    &_GetRequest_default_instance_._instance,
    ::_pbi::TcParser::GenericFallbackLite,  // fallback
  }, {{
    // string key = 1;
    {::_pbi::TcParser::FastUS1,
     {10, 63, 0, PROTOBUF_FIELD_OFFSET(GetRequest, _impl_.key_)}},
  }}, {{
    65535, 65535
  }}, {{
    // string key = 1;
    {PROTOBUF_FIELD_OFFSET(GetRequest, _impl_.key_), 0, 0,
    (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)},
  }},
  // no aux_entries
  {{
    "\24\3\0\0\0\0\0\0"
    "hillab.v4.GetRequest"
    "key"
  }},
};

::uint8_t* GetRequest::_InternalSerialize(
    ::uint8_t* target,
    ::google::protobuf::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:hillab.v4.GetRequest)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  // string key = 1;
  if (!this->_internal_key().empty()) {
    const std::string& _s = this->_internal_key();
    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "hillab.v4.GetRequest.key");
    target = stream->WriteStringMaybeAliased(1, _s, target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(
        _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:hillab.v4.GetRequest)
  return target;
}

::size_t GetRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:hillab.v4.GetRequest)
  ::size_t total_size = 0;

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

  // string key = 1;
  if (!this->_internal_key().empty()) {
    total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize(
                                    this->_internal_key());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString).size();
  }
  _impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size));
  return total_size;
}

void GetRequest::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetRequest*>(
      &from));
}

void GetRequest::MergeFrom(const GetRequest& from) {
  GetRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:hillab.v4.GetRequest)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_key().empty()) {
    _this->_internal_set_key(from._internal_key());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

PROTOBUF_NOINLINE bool GetRequest::IsInitialized() const {
  return true;
}

::_pbi::CachedSize* GetRequest::AccessCachedSize() const {
  return &_impl_._cached_size_;
}
void GetRequest::InternalSwap(GetRequest* PROTOBUF_RESTRICT other) {
  using std::swap;
  auto* arena = GetArena();
  ABSL_DCHECK_EQ(arena, other->GetArena());
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.key_, &other->_impl_.key_, arena);
}

std::string GetRequest::GetTypeName() const {
  return "hillab.v4.GetRequest";
}

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

class GetResponse::_Internal {
 public:
  using HasBits = decltype(std::declval<GetResponse>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
    8 * PROTOBUF_FIELD_OFFSET(GetResponse, _impl_._has_bits_);
  static const ::hillab::v4::Value& value(const GetResponse* msg);
  static void set_has_value(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_unit(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::hillab::v4::Value& min_value(const GetResponse* msg);
  static void set_has_min_value(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static const ::hillab::v4::Value& max_value(const GetResponse* msg);
  static void set_has_max_value(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
};

const ::hillab::v4::Value& GetResponse::_Internal::value(const GetResponse* msg) {
  return *msg->_impl_.value_;
}
const ::hillab::v4::Value& GetResponse::_Internal::min_value(const GetResponse* msg) {
  return *msg->_impl_.min_value_;
}
const ::hillab::v4::Value& GetResponse::_Internal::max_value(const GetResponse* msg) {
  return *msg->_impl_.max_value_;
}
GetResponse::GetResponse(::google::protobuf::Arena* arena)
    : ::google::protobuf::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:hillab.v4.GetResponse)
}
inline PROTOBUF_NDEBUG_INLINE GetResponse::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena,
    const Impl_& from)
      : _has_bits_{from._has_bits_},
        _cached_size_{0},
        key_(arena, from.key_),
        unit_(arena, from.unit_) {}

GetResponse::GetResponse(
    ::google::protobuf::Arena* arena,
    const GetResponse& from)
    : ::google::protobuf::MessageLite(arena) {
  GetResponse* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<std::string>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_);
  ::uint32_t cached_has_bits = _impl_._has_bits_[0];
  _impl_.value_ = (cached_has_bits & 0x00000002u)
                ? CreateMaybeMessage<::hillab::v4::Value>(arena, *from._impl_.value_)
                : nullptr;
  _impl_.min_value_ = (cached_has_bits & 0x00000004u)
                ? CreateMaybeMessage<::hillab::v4::Value>(arena, *from._impl_.min_value_)
                : nullptr;
  _impl_.max_value_ = (cached_has_bits & 0x00000008u)
                ? CreateMaybeMessage<::hillab::v4::Value>(arena, *from._impl_.max_value_)
                : nullptr;

  // @@protoc_insertion_point(copy_constructor:hillab.v4.GetResponse)
}
inline PROTOBUF_NDEBUG_INLINE GetResponse::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility,
    ::google::protobuf::Arena* arena)
      : _cached_size_{0},
        key_(arena),
        unit_(arena) {}

inline void GetResponse::SharedCtor(::_pb::Arena* arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  ::memset(reinterpret_cast<char *>(&_impl_) +
               offsetof(Impl_, value_),
           0,
           offsetof(Impl_, max_value_) -
               offsetof(Impl_, value_) +
               sizeof(Impl_::max_value_));
}
GetResponse::~GetResponse() {
  // @@protoc_insertion_point(destructor:hillab.v4.GetResponse)
  _internal_metadata_.Delete<std::string>();
  SharedDtor();
}
inline void GetResponse::SharedDtor() {
  ABSL_DCHECK(GetArena() == nullptr);
  _impl_.key_.Destroy();
  _impl_.unit_.Destroy();
  delete _impl_.value_;
  delete _impl_.min_value_;
  delete _impl_.max_value_;
  _impl_.~Impl_();
}

PROTOBUF_NOINLINE void GetResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:hillab.v4.GetResponse)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.key_.ClearToEmpty();
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    if (cached_has_bits & 0x00000001u) {
      _impl_.unit_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000002u) {
      ABSL_DCHECK(_impl_.value_ != nullptr);
      _impl_.value_->Clear();
    }
    if (cached_has_bits & 0x00000004u) {
      ABSL_DCHECK(_impl_.min_value_ != nullptr);
      _impl_.min_value_->Clear();
    }
    if (cached_has_bits & 0x00000008u) {
      ABSL_DCHECK(_impl_.max_value_ != nullptr);
      _impl_.max_value_->Clear();
    }
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* GetResponse::_InternalParse(
    const char* ptr, ::_pbi::ParseContext* ctx) {
  ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header);
  return ptr;
}


PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::_pbi::TcParseTable<3, 5, 3, 37, 2> GetResponse::_table_ = {
  {
    PROTOBUF_FIELD_OFFSET(GetResponse, _impl_._has_bits_),
    0, // no _extensions_
    5, 56,  // max_field_number, fast_idx_mask
    offsetof(decltype(_table_), field_lookup_table),
    4294967264,  // skipmap
    offsetof(decltype(_table_), field_entries),
    5,  // num_field_entries
    3,  // num_aux_entries
    offsetof(decltype(_table_), aux_entries),
    &_GetResponse_default_instance_._instance,
    ::_pbi::TcParser::GenericFallbackLite,  // fallback
  }, {{
    {::_pbi::TcParser::MiniParse, {}},
    // string key = 1;
    {::_pbi::TcParser::FastUS1,
     {10, 63, 0, PROTOBUF_FIELD_OFFSET(GetResponse, _impl_.key_)}},
    // .hillab.v4.Value value = 2;
    {::_pbi::TcParser::FastMtS1,
     {18, 1, 0, PROTOBUF_FIELD_OFFSET(GetResponse, _impl_.value_)}},
    // optional string unit = 3;
    {::_pbi::TcParser::FastUS1,
     {26, 0, 0, PROTOBUF_FIELD_OFFSET(GetResponse, _impl_.unit_)}},
    // optional .hillab.v4.Value min_value = 4;
    {::_pbi::TcParser::FastMtS1,
     {34, 2, 1, PROTOBUF_FIELD_OFFSET(GetResponse, _impl_.min_value_)}},
    // optional .hillab.v4.Value max_value = 5;
    {::_pbi::TcParser::FastMtS1,
     {42, 3, 2, PROTOBUF_FIELD_OFFSET(GetResponse, _impl_.max_value_)}},
    {::_pbi::TcParser::MiniParse, {}},
    {::_pbi::TcParser::MiniParse, {}},
  }}, {{
    65535, 65535
  }}, {{
    // string key = 1;
    {PROTOBUF_FIELD_OFFSET(GetResponse, _impl_.key_), -1, 0,
    (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)},
    // .hillab.v4.Value value = 2;
    {PROTOBUF_FIELD_OFFSET(GetResponse, _impl_.value_), _Internal::kHasBitsOffset + 1, 0,
    (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
    // optional string unit = 3;
    {PROTOBUF_FIELD_OFFSET(GetResponse, _impl_.unit_), _Internal::kHasBitsOffset + 0, 0,
    (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)},
    // optional .hillab.v4.Value min_value = 4;
    {PROTOBUF_FIELD_OFFSET(GetResponse, _impl_.min_value_), _Internal::kHasBitsOffset + 2, 1,
    (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
    // optional .hillab.v4.Value max_value = 5;
    {PROTOBUF_FIELD_OFFSET(GetResponse, _impl_.max_value_), _Internal::kHasBitsOffset + 3, 2,
    (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
  }}, {{
    {::_pbi::TcParser::GetTable<::hillab::v4::Value>()},
    {::_pbi::TcParser::GetTable<::hillab::v4::Value>()},
    {::_pbi::TcParser::GetTable<::hillab::v4::Value>()},
  }}, {{
    "\25\3\0\4\0\0\0\0"
    "hillab.v4.GetResponse"
    "key"
    "unit"
  }},
};

::uint8_t* GetResponse::_InternalSerialize(
    ::uint8_t* target,
    ::google::protobuf::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:hillab.v4.GetResponse)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  // string key = 1;
  if (!this->_internal_key().empty()) {
    const std::string& _s = this->_internal_key();
    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "hillab.v4.GetResponse.key");
    target = stream->WriteStringMaybeAliased(1, _s, target);
  }

  cached_has_bits = _impl_._has_bits_[0];
  // .hillab.v4.Value value = 2;
  if (cached_has_bits & 0x00000002u) {
    target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
        2, _Internal::value(this),
        _Internal::value(this).GetCachedSize(), target, stream);
  }

  // optional string unit = 3;
  if (cached_has_bits & 0x00000001u) {
    const std::string& _s = this->_internal_unit();
    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "hillab.v4.GetResponse.unit");
    target = stream->WriteStringMaybeAliased(3, _s, target);
  }

  // optional .hillab.v4.Value min_value = 4;
  if (cached_has_bits & 0x00000004u) {
    target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
        4, _Internal::min_value(this),
        _Internal::min_value(this).GetCachedSize(), target, stream);
  }

  // optional .hillab.v4.Value max_value = 5;
  if (cached_has_bits & 0x00000008u) {
    target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
        5, _Internal::max_value(this),
        _Internal::max_value(this).GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(
        _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:hillab.v4.GetResponse)
  return target;
}

::size_t GetResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:hillab.v4.GetResponse)
  ::size_t total_size = 0;

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

  // string key = 1;
  if (!this->_internal_key().empty()) {
    total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize(
                                    this->_internal_key());
  }

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    // optional string unit = 3;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize(
                                      this->_internal_unit());
    }

    // .hillab.v4.Value value = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size +=
          1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.value_);
    }

    // optional .hillab.v4.Value min_value = 4;
    if (cached_has_bits & 0x00000004u) {
      total_size +=
          1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.min_value_);
    }

    // optional .hillab.v4.Value max_value = 5;
    if (cached_has_bits & 0x00000008u) {
      total_size +=
          1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.max_value_);
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString).size();
  }
  _impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size));
  return total_size;
}

void GetResponse::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const GetResponse*>(
      &from));
}

void GetResponse::MergeFrom(const GetResponse& from) {
  GetResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:hillab.v4.GetResponse)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_key().empty()) {
    _this->_internal_set_key(from._internal_key());
  }
  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    if (cached_has_bits & 0x00000001u) {
      _this->_internal_set_unit(from._internal_unit());
    }
    if (cached_has_bits & 0x00000002u) {
      _this->_internal_mutable_value()->::hillab::v4::Value::MergeFrom(
          from._internal_value());
    }
    if (cached_has_bits & 0x00000004u) {
      _this->_internal_mutable_min_value()->::hillab::v4::Value::MergeFrom(
          from._internal_min_value());
    }
    if (cached_has_bits & 0x00000008u) {
      _this->_internal_mutable_max_value()->::hillab::v4::Value::MergeFrom(
          from._internal_max_value());
    }
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

PROTOBUF_NOINLINE bool GetResponse::IsInitialized() const {
  return true;
}

::_pbi::CachedSize* GetResponse::AccessCachedSize() const {
  return &_impl_._cached_size_;
}
void GetResponse::InternalSwap(GetResponse* PROTOBUF_RESTRICT other) {
  using std::swap;
  auto* arena = GetArena();
  ABSL_DCHECK_EQ(arena, other->GetArena());
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.key_, &other->_impl_.key_, arena);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.unit_, &other->_impl_.unit_, arena);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(GetResponse, _impl_.max_value_)
      + sizeof(GetResponse::_impl_.max_value_)
      - PROTOBUF_FIELD_OFFSET(GetResponse, _impl_.value_)>(
          reinterpret_cast<char*>(&_impl_.value_),
          reinterpret_cast<char*>(&other->_impl_.value_));
}

std::string GetResponse::GetTypeName() const {
  return "hillab.v4.GetResponse";
}

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

class BeamProfile::_Internal {
 public:
};

BeamProfile::BeamProfile(::google::protobuf::Arena* arena)
    : ::google::protobuf::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:hillab.v4.BeamProfile)
}
BeamProfile::BeamProfile(
    ::google::protobuf::Arena* arena, const BeamProfile& from)
    : BeamProfile(arena) {
  MergeFrom(from);
}
inline PROTOBUF_NDEBUG_INLINE BeamProfile::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility,
    ::google::protobuf::Arena* arena)
      : _cached_size_{0} {}

inline void BeamProfile::SharedCtor(::_pb::Arena* arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  ::memset(reinterpret_cast<char *>(&_impl_) +
               offsetof(Impl_, latest_value_),
           0,
           offsetof(Impl_, index_) -
               offsetof(Impl_, latest_value_) +
               sizeof(Impl_::index_));
}
BeamProfile::~BeamProfile() {
  // @@protoc_insertion_point(destructor:hillab.v4.BeamProfile)
  _internal_metadata_.Delete<std::string>();
  SharedDtor();
}
inline void BeamProfile::SharedDtor() {
  ABSL_DCHECK(GetArena() == nullptr);
  _impl_.~Impl_();
}

PROTOBUF_NOINLINE void BeamProfile::Clear() {
// @@protoc_insertion_point(message_clear_start:hillab.v4.BeamProfile)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  ::memset(&_impl_.latest_value_, 0, static_cast<::size_t>(
      reinterpret_cast<char*>(&_impl_.index_) -
      reinterpret_cast<char*>(&_impl_.latest_value_)) + sizeof(_impl_.index_));
  _internal_metadata_.Clear<std::string>();
}

const char* BeamProfile::_InternalParse(
    const char* ptr, ::_pbi::ParseContext* ctx) {
  ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header);
  return ptr;
}


PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::_pbi::TcParseTable<2, 4, 0, 0, 2> BeamProfile::_table_ = {
  {
    0,  // no _has_bits_
    0, // no _extensions_
    4, 24,  // max_field_number, fast_idx_mask
    offsetof(decltype(_table_), field_lookup_table),
    4294967280,  // skipmap
    offsetof(decltype(_table_), field_entries),
    4,  // num_field_entries
    0,  // num_aux_entries
    offsetof(decltype(_table_), field_names),  // no aux_entries
    &_BeamProfile_default_instance_._instance,
    ::_pbi::TcParser::GenericFallbackLite,  // fallback
  }, {{
    // double standard_deviation = 4;
    {::_pbi::TcParser::FastF64S1,
     {33, 63, 0, PROTOBUF_FIELD_OFFSET(BeamProfile, _impl_.standard_deviation_)}},
    // int32 index = 1;
    {::_pbi::TcParser::FastV32S1,
     {8, 63, 0, PROTOBUF_FIELD_OFFSET(BeamProfile, _impl_.index_)}},
    // double latest_value = 2;
    {::_pbi::TcParser::FastF64S1,
     {17, 63, 0, PROTOBUF_FIELD_OFFSET(BeamProfile, _impl_.latest_value_)}},
    // double average = 3;
    {::_pbi::TcParser::FastF64S1,
     {25, 63, 0, PROTOBUF_FIELD_OFFSET(BeamProfile, _impl_.average_)}},
  }}, {{
    65535, 65535
  }}, {{
    // int32 index = 1;
    {PROTOBUF_FIELD_OFFSET(BeamProfile, _impl_.index_), 0, 0,
    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
    // double latest_value = 2;
    {PROTOBUF_FIELD_OFFSET(BeamProfile, _impl_.latest_value_), 0, 0,
    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
    // double average = 3;
    {PROTOBUF_FIELD_OFFSET(BeamProfile, _impl_.average_), 0, 0,
    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
    // double standard_deviation = 4;
    {PROTOBUF_FIELD_OFFSET(BeamProfile, _impl_.standard_deviation_), 0, 0,
    (0 | ::_fl::kFcSingular | ::_fl::kDouble)},
  }},
  // no aux_entries
  {{
  }},
};

::uint8_t* BeamProfile::_InternalSerialize(
    ::uint8_t* target,
    ::google::protobuf::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:hillab.v4.BeamProfile)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  // int32 index = 1;
  if (this->_internal_index() != 0) {
    target = ::google::protobuf::internal::WireFormatLite::
        WriteInt32ToArrayWithField<1>(
            stream, this->_internal_index(), target);
  }

  // double latest_value = 2;
  static_assert(sizeof(::uint64_t) == sizeof(double),
                "Code assumes ::uint64_t and double are the same size.");
  double tmp_latest_value = this->_internal_latest_value();
  ::uint64_t raw_latest_value;
  memcpy(&raw_latest_value, &tmp_latest_value, sizeof(tmp_latest_value));
  if (raw_latest_value != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        2, this->_internal_latest_value(), target);
  }

  // double average = 3;
  static_assert(sizeof(::uint64_t) == sizeof(double),
                "Code assumes ::uint64_t and double are the same size.");
  double tmp_average = this->_internal_average();
  ::uint64_t raw_average;
  memcpy(&raw_average, &tmp_average, sizeof(tmp_average));
  if (raw_average != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        3, this->_internal_average(), target);
  }

  // double standard_deviation = 4;
  static_assert(sizeof(::uint64_t) == sizeof(double),
                "Code assumes ::uint64_t and double are the same size.");
  double tmp_standard_deviation = this->_internal_standard_deviation();
  ::uint64_t raw_standard_deviation;
  memcpy(&raw_standard_deviation, &tmp_standard_deviation, sizeof(tmp_standard_deviation));
  if (raw_standard_deviation != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        4, this->_internal_standard_deviation(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(
        _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:hillab.v4.BeamProfile)
  return target;
}

::size_t BeamProfile::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:hillab.v4.BeamProfile)
  ::size_t total_size = 0;

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

  // double latest_value = 2;
  static_assert(sizeof(::uint64_t) == sizeof(double),
                "Code assumes ::uint64_t and double are the same size.");
  double tmp_latest_value = this->_internal_latest_value();
  ::uint64_t raw_latest_value;
  memcpy(&raw_latest_value, &tmp_latest_value, sizeof(tmp_latest_value));
  if (raw_latest_value != 0) {
    total_size += 9;
  }

  // double average = 3;
  static_assert(sizeof(::uint64_t) == sizeof(double),
                "Code assumes ::uint64_t and double are the same size.");
  double tmp_average = this->_internal_average();
  ::uint64_t raw_average;
  memcpy(&raw_average, &tmp_average, sizeof(tmp_average));
  if (raw_average != 0) {
    total_size += 9;
  }

  // double standard_deviation = 4;
  static_assert(sizeof(::uint64_t) == sizeof(double),
                "Code assumes ::uint64_t and double are the same size.");
  double tmp_standard_deviation = this->_internal_standard_deviation();
  ::uint64_t raw_standard_deviation;
  memcpy(&raw_standard_deviation, &tmp_standard_deviation, sizeof(tmp_standard_deviation));
  if (raw_standard_deviation != 0) {
    total_size += 9;
  }

  // int32 index = 1;
  if (this->_internal_index() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
        this->_internal_index());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString).size();
  }
  _impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size));
  return total_size;
}

void BeamProfile::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const BeamProfile*>(
      &from));
}

void BeamProfile::MergeFrom(const BeamProfile& from) {
  BeamProfile* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:hillab.v4.BeamProfile)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  static_assert(sizeof(::uint64_t) == sizeof(double),
                "Code assumes ::uint64_t and double are the same size.");
  double tmp_latest_value = from._internal_latest_value();
  ::uint64_t raw_latest_value;
  memcpy(&raw_latest_value, &tmp_latest_value, sizeof(tmp_latest_value));
  if (raw_latest_value != 0) {
    _this->_internal_set_latest_value(from._internal_latest_value());
  }
  static_assert(sizeof(::uint64_t) == sizeof(double),
                "Code assumes ::uint64_t and double are the same size.");
  double tmp_average = from._internal_average();
  ::uint64_t raw_average;
  memcpy(&raw_average, &tmp_average, sizeof(tmp_average));
  if (raw_average != 0) {
    _this->_internal_set_average(from._internal_average());
  }
  static_assert(sizeof(::uint64_t) == sizeof(double),
                "Code assumes ::uint64_t and double are the same size.");
  double tmp_standard_deviation = from._internal_standard_deviation();
  ::uint64_t raw_standard_deviation;
  memcpy(&raw_standard_deviation, &tmp_standard_deviation, sizeof(tmp_standard_deviation));
  if (raw_standard_deviation != 0) {
    _this->_internal_set_standard_deviation(from._internal_standard_deviation());
  }
  if (from._internal_index() != 0) {
    _this->_internal_set_index(from._internal_index());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

PROTOBUF_NOINLINE bool BeamProfile::IsInitialized() const {
  return true;
}

::_pbi::CachedSize* BeamProfile::AccessCachedSize() const {
  return &_impl_._cached_size_;
}
void BeamProfile::InternalSwap(BeamProfile* PROTOBUF_RESTRICT other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(BeamProfile, _impl_.index_)
      + sizeof(BeamProfile::_impl_.index_)
      - PROTOBUF_FIELD_OFFSET(BeamProfile, _impl_.latest_value_)>(
          reinterpret_cast<char*>(&_impl_.latest_value_),
          reinterpret_cast<char*>(&other->_impl_.latest_value_));
}

std::string BeamProfile::GetTypeName() const {
  return "hillab.v4.BeamProfile";
}

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

class BeamProfileStream::_Internal {
 public:
  using HasBits = decltype(std::declval<BeamProfileStream>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
    8 * PROTOBUF_FIELD_OFFSET(BeamProfileStream, _impl_._has_bits_);
  static const ::google::protobuf::Timestamp& time(const BeamProfileStream* msg);
  static void set_has_time(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

const ::google::protobuf::Timestamp& BeamProfileStream::_Internal::time(const BeamProfileStream* msg) {
  return *msg->_impl_.time_;
}
void BeamProfileStream::clear_time() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.time_ != nullptr) _impl_.time_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
BeamProfileStream::BeamProfileStream(::google::protobuf::Arena* arena)
    : ::google::protobuf::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:hillab.v4.BeamProfileStream)
}
inline PROTOBUF_NDEBUG_INLINE BeamProfileStream::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena,
    const Impl_& from)
      : _has_bits_{from._has_bits_},
        _cached_size_{0},
        beam_profiles_{visibility, arena, from.beam_profiles_} {}

BeamProfileStream::BeamProfileStream(
    ::google::protobuf::Arena* arena,
    const BeamProfileStream& from)
    : ::google::protobuf::MessageLite(arena) {
  BeamProfileStream* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<std::string>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_);
  ::uint32_t cached_has_bits = _impl_._has_bits_[0];
  _impl_.time_ = (cached_has_bits & 0x00000001u)
                ? CreateMaybeMessage<::google::protobuf::Timestamp>(arena, *from._impl_.time_)
                : nullptr;

  // @@protoc_insertion_point(copy_constructor:hillab.v4.BeamProfileStream)
}
inline PROTOBUF_NDEBUG_INLINE BeamProfileStream::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility,
    ::google::protobuf::Arena* arena)
      : _cached_size_{0},
        beam_profiles_{visibility, arena} {}

inline void BeamProfileStream::SharedCtor(::_pb::Arena* arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  _impl_.time_ = {};
}
BeamProfileStream::~BeamProfileStream() {
  // @@protoc_insertion_point(destructor:hillab.v4.BeamProfileStream)
  _internal_metadata_.Delete<std::string>();
  SharedDtor();
}
inline void BeamProfileStream::SharedDtor() {
  ABSL_DCHECK(GetArena() == nullptr);
  delete _impl_.time_;
  _impl_.~Impl_();
}

PROTOBUF_NOINLINE void BeamProfileStream::Clear() {
// @@protoc_insertion_point(message_clear_start:hillab.v4.BeamProfileStream)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.beam_profiles_.Clear();
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    ABSL_DCHECK(_impl_.time_ != nullptr);
    _impl_.time_->Clear();
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* BeamProfileStream::_InternalParse(
    const char* ptr, ::_pbi::ParseContext* ctx) {
  ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header);
  return ptr;
}


PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::_pbi::TcParseTable<1, 2, 2, 0, 2> BeamProfileStream::_table_ = {
  {
    PROTOBUF_FIELD_OFFSET(BeamProfileStream, _impl_._has_bits_),
    0, // no _extensions_
    2, 8,  // max_field_number, fast_idx_mask
    offsetof(decltype(_table_), field_lookup_table),
    4294967292,  // skipmap
    offsetof(decltype(_table_), field_entries),
    2,  // num_field_entries
    2,  // num_aux_entries
    offsetof(decltype(_table_), aux_entries),
    &_BeamProfileStream_default_instance_._instance,
    ::_pbi::TcParser::GenericFallbackLite,  // fallback
  }, {{
    // repeated .hillab.v4.BeamProfile beam_profiles = 2;
    {::_pbi::TcParser::FastMtR1,
     {18, 63, 1, PROTOBUF_FIELD_OFFSET(BeamProfileStream, _impl_.beam_profiles_)}},
    // .google.protobuf.Timestamp time = 1;
    {::_pbi::TcParser::FastMtS1,
     {10, 0, 0, PROTOBUF_FIELD_OFFSET(BeamProfileStream, _impl_.time_)}},
  }}, {{
    65535, 65535
  }}, {{
    // .google.protobuf.Timestamp time = 1;
    {PROTOBUF_FIELD_OFFSET(BeamProfileStream, _impl_.time_), _Internal::kHasBitsOffset + 0, 0,
    (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
    // repeated .hillab.v4.BeamProfile beam_profiles = 2;
    {PROTOBUF_FIELD_OFFSET(BeamProfileStream, _impl_.beam_profiles_), -1, 1,
    (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)},
  }}, {{
    {::_pbi::TcParser::GetTable<::google::protobuf::Timestamp>()},
    {::_pbi::TcParser::GetTable<::hillab::v4::BeamProfile>()},
  }}, {{
  }},
};

::uint8_t* BeamProfileStream::_InternalSerialize(
    ::uint8_t* target,
    ::google::protobuf::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:hillab.v4.BeamProfileStream)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  // .google.protobuf.Timestamp time = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
        1, _Internal::time(this),
        _Internal::time(this).GetCachedSize(), target, stream);
  }

  // repeated .hillab.v4.BeamProfile beam_profiles = 2;
  for (unsigned i = 0,
      n = static_cast<unsigned>(this->_internal_beam_profiles_size()); i < n; i++) {
    const auto& repfield = this->_internal_beam_profiles().Get(i);
    target = ::google::protobuf::internal::WireFormatLite::
        InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(
        _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:hillab.v4.BeamProfileStream)
  return target;
}

::size_t BeamProfileStream::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:hillab.v4.BeamProfileStream)
  ::size_t total_size = 0;

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

  // repeated .hillab.v4.BeamProfile beam_profiles = 2;
  total_size += 1UL * this->_internal_beam_profiles_size();
  for (const auto& msg : this->_internal_beam_profiles()) {
    total_size +=
      ::google::protobuf::internal::WireFormatLite::MessageSize(msg);
  }
  // .google.protobuf.Timestamp time = 1;
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size +=
        1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.time_);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString).size();
  }
  _impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size));
  return total_size;
}

void BeamProfileStream::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const BeamProfileStream*>(
      &from));
}

void BeamProfileStream::MergeFrom(const BeamProfileStream& from) {
  BeamProfileStream* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:hillab.v4.BeamProfileStream)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_internal_mutable_beam_profiles()->MergeFrom(
      from._internal_beam_profiles());
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_internal_mutable_time()->::google::protobuf::Timestamp::MergeFrom(
        from._internal_time());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

PROTOBUF_NOINLINE bool BeamProfileStream::IsInitialized() const {
  return true;
}

::_pbi::CachedSize* BeamProfileStream::AccessCachedSize() const {
  return &_impl_._cached_size_;
}
void BeamProfileStream::InternalSwap(BeamProfileStream* PROTOBUF_RESTRICT other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  _impl_.beam_profiles_.InternalSwap(&other->_impl_.beam_profiles_);
  swap(_impl_.time_, other->_impl_.time_);
}

std::string BeamProfileStream::GetTypeName() const {
  return "hillab.v4.BeamProfileStream";
}

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

class AppInfoResponse::_Internal {
 public:
};

AppInfoResponse::AppInfoResponse(::google::protobuf::Arena* arena)
    : ::google::protobuf::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:hillab.v4.AppInfoResponse)
}
inline PROTOBUF_NDEBUG_INLINE AppInfoResponse::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena,
    const Impl_& from)
      : version_(arena, from.version_),
        _cached_size_{0} {}

AppInfoResponse::AppInfoResponse(
    ::google::protobuf::Arena* arena,
    const AppInfoResponse& from)
    : ::google::protobuf::MessageLite(arena) {
  AppInfoResponse* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<std::string>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_);

  // @@protoc_insertion_point(copy_constructor:hillab.v4.AppInfoResponse)
}
inline PROTOBUF_NDEBUG_INLINE AppInfoResponse::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility,
    ::google::protobuf::Arena* arena)
      : version_(arena),
        _cached_size_{0} {}

inline void AppInfoResponse::SharedCtor(::_pb::Arena* arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
}
AppInfoResponse::~AppInfoResponse() {
  // @@protoc_insertion_point(destructor:hillab.v4.AppInfoResponse)
  _internal_metadata_.Delete<std::string>();
  SharedDtor();
}
inline void AppInfoResponse::SharedDtor() {
  ABSL_DCHECK(GetArena() == nullptr);
  _impl_.version_.Destroy();
  _impl_.~Impl_();
}

PROTOBUF_NOINLINE void AppInfoResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:hillab.v4.AppInfoResponse)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.version_.ClearToEmpty();
  _internal_metadata_.Clear<std::string>();
}

const char* AppInfoResponse::_InternalParse(
    const char* ptr, ::_pbi::ParseContext* ctx) {
  ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header);
  return ptr;
}


PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::_pbi::TcParseTable<0, 1, 0, 41, 2> AppInfoResponse::_table_ = {
  {
    0,  // no _has_bits_
    0, // no _extensions_
    1, 0,  // max_field_number, fast_idx_mask
    offsetof(decltype(_table_), field_lookup_table),
    4294967294,  // skipmap
    offsetof(decltype(_table_), field_entries),
    1,  // num_field_entries
    0,  // num_aux_entries
    offsetof(decltype(_table_), field_names),  // no aux_entries
    &_AppInfoResponse_default_instance_._instance,
    ::_pbi::TcParser::GenericFallbackLite,  // fallback
  }, {{
    // string version = 1;
    {::_pbi::TcParser::FastUS1,
     {10, 63, 0, PROTOBUF_FIELD_OFFSET(AppInfoResponse, _impl_.version_)}},
  }}, {{
    65535, 65535
  }}, {{
    // string version = 1;
    {PROTOBUF_FIELD_OFFSET(AppInfoResponse, _impl_.version_), 0, 0,
    (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)},
  }},
  // no aux_entries
  {{
    "\31\7\0\0\0\0\0\0"
    "hillab.v4.AppInfoResponse"
    "version"
  }},
};

::uint8_t* AppInfoResponse::_InternalSerialize(
    ::uint8_t* target,
    ::google::protobuf::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:hillab.v4.AppInfoResponse)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  // string version = 1;
  if (!this->_internal_version().empty()) {
    const std::string& _s = this->_internal_version();
    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "hillab.v4.AppInfoResponse.version");
    target = stream->WriteStringMaybeAliased(1, _s, target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(
        _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:hillab.v4.AppInfoResponse)
  return target;
}

::size_t AppInfoResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:hillab.v4.AppInfoResponse)
  ::size_t total_size = 0;

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

  // string version = 1;
  if (!this->_internal_version().empty()) {
    total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize(
                                    this->_internal_version());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString).size();
  }
  _impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size));
  return total_size;
}

void AppInfoResponse::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const AppInfoResponse*>(
      &from));
}

void AppInfoResponse::MergeFrom(const AppInfoResponse& from) {
  AppInfoResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:hillab.v4.AppInfoResponse)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_version().empty()) {
    _this->_internal_set_version(from._internal_version());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

PROTOBUF_NOINLINE bool AppInfoResponse::IsInitialized() const {
  return true;
}

::_pbi::CachedSize* AppInfoResponse::AccessCachedSize() const {
  return &_impl_._cached_size_;
}
void AppInfoResponse::InternalSwap(AppInfoResponse* PROTOBUF_RESTRICT other) {
  using std::swap;
  auto* arena = GetArena();
  ABSL_DCHECK_EQ(arena, other->GetArena());
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.version_, &other->_impl_.version_, arena);
}

std::string AppInfoResponse::GetTypeName() const {
  return "hillab.v4.AppInfoResponse";
}

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

class PresetRequest::_Internal {
 public:
};

PresetRequest::PresetRequest(::google::protobuf::Arena* arena)
    : ::google::protobuf::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:hillab.v4.PresetRequest)
}
inline PROTOBUF_NDEBUG_INLINE PresetRequest::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena,
    const Impl_& from)
      : name_(arena, from.name_),
        _cached_size_{0} {}

PresetRequest::PresetRequest(
    ::google::protobuf::Arena* arena,
    const PresetRequest& from)
    : ::google::protobuf::MessageLite(arena) {
  PresetRequest* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<std::string>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_);

  // @@protoc_insertion_point(copy_constructor:hillab.v4.PresetRequest)
}
inline PROTOBUF_NDEBUG_INLINE PresetRequest::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility,
    ::google::protobuf::Arena* arena)
      : name_(arena),
        _cached_size_{0} {}

inline void PresetRequest::SharedCtor(::_pb::Arena* arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
}
PresetRequest::~PresetRequest() {
  // @@protoc_insertion_point(destructor:hillab.v4.PresetRequest)
  _internal_metadata_.Delete<std::string>();
  SharedDtor();
}
inline void PresetRequest::SharedDtor() {
  ABSL_DCHECK(GetArena() == nullptr);
  _impl_.name_.Destroy();
  _impl_.~Impl_();
}

PROTOBUF_NOINLINE void PresetRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:hillab.v4.PresetRequest)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.name_.ClearToEmpty();
  _internal_metadata_.Clear<std::string>();
}

const char* PresetRequest::_InternalParse(
    const char* ptr, ::_pbi::ParseContext* ctx) {
  ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header);
  return ptr;
}


PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::_pbi::TcParseTable<0, 1, 0, 36, 2> PresetRequest::_table_ = {
  {
    0,  // no _has_bits_
    0, // no _extensions_
    1, 0,  // max_field_number, fast_idx_mask
    offsetof(decltype(_table_), field_lookup_table),
    4294967294,  // skipmap
    offsetof(decltype(_table_), field_entries),
    1,  // num_field_entries
    0,  // num_aux_entries
    offsetof(decltype(_table_), field_names),  // no aux_entries
    &_PresetRequest_default_instance_._instance,
    ::_pbi::TcParser::GenericFallbackLite,  // fallback
  }, {{
    // string name = 1;
    {::_pbi::TcParser::FastUS1,
     {10, 63, 0, PROTOBUF_FIELD_OFFSET(PresetRequest, _impl_.name_)}},
  }}, {{
    65535, 65535
  }}, {{
    // string name = 1;
    {PROTOBUF_FIELD_OFFSET(PresetRequest, _impl_.name_), 0, 0,
    (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)},
  }},
  // no aux_entries
  {{
    "\27\4\0\0\0\0\0\0"
    "hillab.v4.PresetRequest"
    "name"
  }},
};

::uint8_t* PresetRequest::_InternalSerialize(
    ::uint8_t* target,
    ::google::protobuf::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:hillab.v4.PresetRequest)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  // string name = 1;
  if (!this->_internal_name().empty()) {
    const std::string& _s = this->_internal_name();
    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "hillab.v4.PresetRequest.name");
    target = stream->WriteStringMaybeAliased(1, _s, target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(
        _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:hillab.v4.PresetRequest)
  return target;
}

::size_t PresetRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:hillab.v4.PresetRequest)
  ::size_t total_size = 0;

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

  // string name = 1;
  if (!this->_internal_name().empty()) {
    total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize(
                                    this->_internal_name());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString).size();
  }
  _impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size));
  return total_size;
}

void PresetRequest::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const PresetRequest*>(
      &from));
}

void PresetRequest::MergeFrom(const PresetRequest& from) {
  PresetRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:hillab.v4.PresetRequest)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_name().empty()) {
    _this->_internal_set_name(from._internal_name());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

PROTOBUF_NOINLINE bool PresetRequest::IsInitialized() const {
  return true;
}

::_pbi::CachedSize* PresetRequest::AccessCachedSize() const {
  return &_impl_._cached_size_;
}
void PresetRequest::InternalSwap(PresetRequest* PROTOBUF_RESTRICT other) {
  using std::swap;
  auto* arena = GetArena();
  ABSL_DCHECK_EQ(arena, other->GetArena());
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.name_, &other->_impl_.name_, arena);
}

std::string PresetRequest::GetTypeName() const {
  return "hillab.v4.PresetRequest";
}

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

class PresetResponse::_Internal {
 public:
};

PresetResponse::PresetResponse(::google::protobuf::Arena* arena)
    : ::google::protobuf::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:hillab.v4.PresetResponse)
}
inline PROTOBUF_NDEBUG_INLINE PresetResponse::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena,
    const Impl_& from)
      : name_(arena, from.name_),
        _cached_size_{0} {}

PresetResponse::PresetResponse(
    ::google::protobuf::Arena* arena,
    const PresetResponse& from)
    : ::google::protobuf::MessageLite(arena) {
  PresetResponse* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<std::string>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_);

  // @@protoc_insertion_point(copy_constructor:hillab.v4.PresetResponse)
}
inline PROTOBUF_NDEBUG_INLINE PresetResponse::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility,
    ::google::protobuf::Arena* arena)
      : name_(arena),
        _cached_size_{0} {}

inline void PresetResponse::SharedCtor(::_pb::Arena* arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
}
PresetResponse::~PresetResponse() {
  // @@protoc_insertion_point(destructor:hillab.v4.PresetResponse)
  _internal_metadata_.Delete<std::string>();
  SharedDtor();
}
inline void PresetResponse::SharedDtor() {
  ABSL_DCHECK(GetArena() == nullptr);
  _impl_.name_.Destroy();
  _impl_.~Impl_();
}

PROTOBUF_NOINLINE void PresetResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:hillab.v4.PresetResponse)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.name_.ClearToEmpty();
  _internal_metadata_.Clear<std::string>();
}

const char* PresetResponse::_InternalParse(
    const char* ptr, ::_pbi::ParseContext* ctx) {
  ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header);
  return ptr;
}


PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::_pbi::TcParseTable<0, 1, 0, 37, 2> PresetResponse::_table_ = {
  {
    0,  // no _has_bits_
    0, // no _extensions_
    1, 0,  // max_field_number, fast_idx_mask
    offsetof(decltype(_table_), field_lookup_table),
    4294967294,  // skipmap
    offsetof(decltype(_table_), field_entries),
    1,  // num_field_entries
    0,  // num_aux_entries
    offsetof(decltype(_table_), field_names),  // no aux_entries
    &_PresetResponse_default_instance_._instance,
    ::_pbi::TcParser::GenericFallbackLite,  // fallback
  }, {{
    // string name = 1;
    {::_pbi::TcParser::FastUS1,
     {10, 63, 0, PROTOBUF_FIELD_OFFSET(PresetResponse, _impl_.name_)}},
  }}, {{
    65535, 65535
  }}, {{
    // string name = 1;
    {PROTOBUF_FIELD_OFFSET(PresetResponse, _impl_.name_), 0, 0,
    (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)},
  }},
  // no aux_entries
  {{
    "\30\4\0\0\0\0\0\0"
    "hillab.v4.PresetResponse"
    "name"
  }},
};

::uint8_t* PresetResponse::_InternalSerialize(
    ::uint8_t* target,
    ::google::protobuf::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:hillab.v4.PresetResponse)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  // string name = 1;
  if (!this->_internal_name().empty()) {
    const std::string& _s = this->_internal_name();
    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "hillab.v4.PresetResponse.name");
    target = stream->WriteStringMaybeAliased(1, _s, target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(
        _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:hillab.v4.PresetResponse)
  return target;
}

::size_t PresetResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:hillab.v4.PresetResponse)
  ::size_t total_size = 0;

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

  // string name = 1;
  if (!this->_internal_name().empty()) {
    total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize(
                                    this->_internal_name());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString).size();
  }
  _impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size));
  return total_size;
}

void PresetResponse::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const PresetResponse*>(
      &from));
}

void PresetResponse::MergeFrom(const PresetResponse& from) {
  PresetResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:hillab.v4.PresetResponse)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_name().empty()) {
    _this->_internal_set_name(from._internal_name());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

PROTOBUF_NOINLINE bool PresetResponse::IsInitialized() const {
  return true;
}

::_pbi::CachedSize* PresetResponse::AccessCachedSize() const {
  return &_impl_._cached_size_;
}
void PresetResponse::InternalSwap(PresetResponse* PROTOBUF_RESTRICT other) {
  using std::swap;
  auto* arena = GetArena();
  ABSL_DCHECK_EQ(arena, other->GetArena());
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.name_, &other->_impl_.name_, arena);
}

std::string PresetResponse::GetTypeName() const {
  return "hillab.v4.PresetResponse";
}

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

class PresetListResponse::_Internal {
 public:
};

PresetListResponse::PresetListResponse(::google::protobuf::Arena* arena)
    : ::google::protobuf::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:hillab.v4.PresetListResponse)
}
inline PROTOBUF_NDEBUG_INLINE PresetListResponse::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena,
    const Impl_& from)
      : name_list_{visibility, arena, from.name_list_},
        _cached_size_{0} {}

PresetListResponse::PresetListResponse(
    ::google::protobuf::Arena* arena,
    const PresetListResponse& from)
    : ::google::protobuf::MessageLite(arena) {
  PresetListResponse* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<std::string>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_);

  // @@protoc_insertion_point(copy_constructor:hillab.v4.PresetListResponse)
}
inline PROTOBUF_NDEBUG_INLINE PresetListResponse::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility,
    ::google::protobuf::Arena* arena)
      : name_list_{visibility, arena},
        _cached_size_{0} {}

inline void PresetListResponse::SharedCtor(::_pb::Arena* arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
}
PresetListResponse::~PresetListResponse() {
  // @@protoc_insertion_point(destructor:hillab.v4.PresetListResponse)
  _internal_metadata_.Delete<std::string>();
  SharedDtor();
}
inline void PresetListResponse::SharedDtor() {
  ABSL_DCHECK(GetArena() == nullptr);
  _impl_.~Impl_();
}

PROTOBUF_NOINLINE void PresetListResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:hillab.v4.PresetListResponse)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.name_list_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* PresetListResponse::_InternalParse(
    const char* ptr, ::_pbi::ParseContext* ctx) {
  ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header);
  return ptr;
}


PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::_pbi::TcParseTable<0, 1, 0, 46, 2> PresetListResponse::_table_ = {
  {
    0,  // no _has_bits_
    0, // no _extensions_
    1, 0,  // max_field_number, fast_idx_mask
    offsetof(decltype(_table_), field_lookup_table),
    4294967294,  // skipmap
    offsetof(decltype(_table_), field_entries),
    1,  // num_field_entries
    0,  // num_aux_entries
    offsetof(decltype(_table_), field_names),  // no aux_entries
    &_PresetListResponse_default_instance_._instance,
    ::_pbi::TcParser::GenericFallbackLite,  // fallback
  }, {{
    // repeated string name_list = 1;
    {::_pbi::TcParser::FastUR1,
     {10, 63, 0, PROTOBUF_FIELD_OFFSET(PresetListResponse, _impl_.name_list_)}},
  }}, {{
    65535, 65535
  }}, {{
    // repeated string name_list = 1;
    {PROTOBUF_FIELD_OFFSET(PresetListResponse, _impl_.name_list_), 0, 0,
    (0 | ::_fl::kFcRepeated | ::_fl::kUtf8String | ::_fl::kRepSString)},
  }},
  // no aux_entries
  {{
    "\34\11\0\0\0\0\0\0"
    "hillab.v4.PresetListResponse"
    "name_list"
  }},
};

::uint8_t* PresetListResponse::_InternalSerialize(
    ::uint8_t* target,
    ::google::protobuf::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:hillab.v4.PresetListResponse)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  // repeated string name_list = 1;
  for (int i = 0, n = this->_internal_name_list_size(); i < n; ++i) {
    const auto& s = this->_internal_name_list().Get(i);
    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
        s.data(), static_cast<int>(s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "hillab.v4.PresetListResponse.name_list");
    target = stream->WriteString(1, s, target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(
        _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:hillab.v4.PresetListResponse)
  return target;
}

::size_t PresetListResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:hillab.v4.PresetListResponse)
  ::size_t total_size = 0;

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

  // repeated string name_list = 1;
  total_size += 1 * ::google::protobuf::internal::FromIntSize(_internal_name_list().size());
  for (int i = 0, n = _internal_name_list().size(); i < n; ++i) {
    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
        _internal_name_list().Get(i));
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString).size();
  }
  _impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size));
  return total_size;
}

void PresetListResponse::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const PresetListResponse*>(
      &from));
}

void PresetListResponse::MergeFrom(const PresetListResponse& from) {
  PresetListResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:hillab.v4.PresetListResponse)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  _this->_internal_mutable_name_list()->MergeFrom(from._internal_name_list());
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

PROTOBUF_NOINLINE bool PresetListResponse::IsInitialized() const {
  return true;
}

::_pbi::CachedSize* PresetListResponse::AccessCachedSize() const {
  return &_impl_._cached_size_;
}
void PresetListResponse::InternalSwap(PresetListResponse* PROTOBUF_RESTRICT other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  _impl_.name_list_.InternalSwap(&other->_impl_.name_list_);
}

std::string PresetListResponse::GetTypeName() const {
  return "hillab.v4.PresetListResponse";
}

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

class ImageStreamServerRequest::_Internal {
 public:
  using HasBits = decltype(std::declval<ImageStreamServerRequest>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
    8 * PROTOBUF_FIELD_OFFSET(ImageStreamServerRequest, _impl_._has_bits_);
  static void set_has_running(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_mtu(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_downscale(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_auto_running(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
};

ImageStreamServerRequest::ImageStreamServerRequest(::google::protobuf::Arena* arena)
    : ::google::protobuf::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:hillab.v4.ImageStreamServerRequest)
}
ImageStreamServerRequest::ImageStreamServerRequest(
    ::google::protobuf::Arena* arena, const ImageStreamServerRequest& from)
    : ImageStreamServerRequest(arena) {
  MergeFrom(from);
}
inline PROTOBUF_NDEBUG_INLINE ImageStreamServerRequest::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility,
    ::google::protobuf::Arena* arena)
      : _cached_size_{0} {}

inline void ImageStreamServerRequest::SharedCtor(::_pb::Arena* arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  ::memset(reinterpret_cast<char *>(&_impl_) +
               offsetof(Impl_, mtu_),
           0,
           offsetof(Impl_, downscale_) -
               offsetof(Impl_, mtu_) +
               sizeof(Impl_::downscale_));
}
ImageStreamServerRequest::~ImageStreamServerRequest() {
  // @@protoc_insertion_point(destructor:hillab.v4.ImageStreamServerRequest)
  _internal_metadata_.Delete<std::string>();
  SharedDtor();
}
inline void ImageStreamServerRequest::SharedDtor() {
  ABSL_DCHECK(GetArena() == nullptr);
  _impl_.~Impl_();
}

PROTOBUF_NOINLINE void ImageStreamServerRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:hillab.v4.ImageStreamServerRequest)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    ::memset(&_impl_.mtu_, 0, static_cast<::size_t>(
        reinterpret_cast<char*>(&_impl_.downscale_) -
        reinterpret_cast<char*>(&_impl_.mtu_)) + sizeof(_impl_.downscale_));
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* ImageStreamServerRequest::_InternalParse(
    const char* ptr, ::_pbi::ParseContext* ctx) {
  ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header);
  return ptr;
}


PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::_pbi::TcParseTable<2, 4, 0, 0, 2> ImageStreamServerRequest::_table_ = {
  {
    PROTOBUF_FIELD_OFFSET(ImageStreamServerRequest, _impl_._has_bits_),
    0, // no _extensions_
    4, 24,  // max_field_number, fast_idx_mask
    offsetof(decltype(_table_), field_lookup_table),
    4294967280,  // skipmap
    offsetof(decltype(_table_), field_entries),
    4,  // num_field_entries
    0,  // num_aux_entries
    offsetof(decltype(_table_), field_names),  // no aux_entries
    &_ImageStreamServerRequest_default_instance_._instance,
    ::_pbi::TcParser::GenericFallbackLite,  // fallback
  }, {{
    // optional bool auto_running = 4;
    {::_pbi::TcParser::FastV8S1,
     {32, 2, 0, PROTOBUF_FIELD_OFFSET(ImageStreamServerRequest, _impl_.auto_running_)}},
    // optional bool running = 1;
    {::_pbi::TcParser::FastV8S1,
     {8, 1, 0, PROTOBUF_FIELD_OFFSET(ImageStreamServerRequest, _impl_.running_)}},
    // optional int32 mtu = 2;
    {::_pbi::TcParser::FastV32S1,
     {16, 0, 0, PROTOBUF_FIELD_OFFSET(ImageStreamServerRequest, _impl_.mtu_)}},
    // optional int32 downscale = 3;
    {::_pbi::TcParser::FastV32S1,
     {24, 3, 0, PROTOBUF_FIELD_OFFSET(ImageStreamServerRequest, _impl_.downscale_)}},
  }}, {{
    65535, 65535
  }}, {{
    // optional bool running = 1;
    {PROTOBUF_FIELD_OFFSET(ImageStreamServerRequest, _impl_.running_), _Internal::kHasBitsOffset + 1, 0,
    (0 | ::_fl::kFcOptional | ::_fl::kBool)},
    // optional int32 mtu = 2;
    {PROTOBUF_FIELD_OFFSET(ImageStreamServerRequest, _impl_.mtu_), _Internal::kHasBitsOffset + 0, 0,
    (0 | ::_fl::kFcOptional | ::_fl::kInt32)},
    // optional int32 downscale = 3;
    {PROTOBUF_FIELD_OFFSET(ImageStreamServerRequest, _impl_.downscale_), _Internal::kHasBitsOffset + 3, 0,
    (0 | ::_fl::kFcOptional | ::_fl::kInt32)},
    // optional bool auto_running = 4;
    {PROTOBUF_FIELD_OFFSET(ImageStreamServerRequest, _impl_.auto_running_), _Internal::kHasBitsOffset + 2, 0,
    (0 | ::_fl::kFcOptional | ::_fl::kBool)},
  }},
  // no aux_entries
  {{
  }},
};

::uint8_t* ImageStreamServerRequest::_InternalSerialize(
    ::uint8_t* target,
    ::google::protobuf::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:hillab.v4.ImageStreamServerRequest)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  // optional bool running = 1;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(
        1, this->_internal_running(), target);
  }

  // optional int32 mtu = 2;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::
        WriteInt32ToArrayWithField<2>(
            stream, this->_internal_mtu(), target);
  }

  // optional int32 downscale = 3;
  if (cached_has_bits & 0x00000008u) {
    target = ::google::protobuf::internal::WireFormatLite::
        WriteInt32ToArrayWithField<3>(
            stream, this->_internal_downscale(), target);
  }

  // optional bool auto_running = 4;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(
        4, this->_internal_auto_running(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(
        _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:hillab.v4.ImageStreamServerRequest)
  return target;
}

::size_t ImageStreamServerRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:hillab.v4.ImageStreamServerRequest)
  ::size_t total_size = 0;

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

  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    // optional int32 mtu = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this->_internal_mtu());
    }

    // optional bool running = 1;
    if (cached_has_bits & 0x00000002u) {
      total_size += 2;
    }

    // optional bool auto_running = 4;
    if (cached_has_bits & 0x00000004u) {
      total_size += 2;
    }

    // optional int32 downscale = 3;
    if (cached_has_bits & 0x00000008u) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this->_internal_downscale());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString).size();
  }
  _impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size));
  return total_size;
}

void ImageStreamServerRequest::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const ImageStreamServerRequest*>(
      &from));
}

void ImageStreamServerRequest::MergeFrom(const ImageStreamServerRequest& from) {
  ImageStreamServerRequest* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:hillab.v4.ImageStreamServerRequest)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._impl_._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    if (cached_has_bits & 0x00000001u) {
      _this->_impl_.mtu_ = from._impl_.mtu_;
    }
    if (cached_has_bits & 0x00000002u) {
      _this->_impl_.running_ = from._impl_.running_;
    }
    if (cached_has_bits & 0x00000004u) {
      _this->_impl_.auto_running_ = from._impl_.auto_running_;
    }
    if (cached_has_bits & 0x00000008u) {
      _this->_impl_.downscale_ = from._impl_.downscale_;
    }
    _this->_impl_._has_bits_[0] |= cached_has_bits;
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

PROTOBUF_NOINLINE bool ImageStreamServerRequest::IsInitialized() const {
  return true;
}

::_pbi::CachedSize* ImageStreamServerRequest::AccessCachedSize() const {
  return &_impl_._cached_size_;
}
void ImageStreamServerRequest::InternalSwap(ImageStreamServerRequest* PROTOBUF_RESTRICT other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(ImageStreamServerRequest, _impl_.downscale_)
      + sizeof(ImageStreamServerRequest::_impl_.downscale_)
      - PROTOBUF_FIELD_OFFSET(ImageStreamServerRequest, _impl_.mtu_)>(
          reinterpret_cast<char*>(&_impl_.mtu_),
          reinterpret_cast<char*>(&other->_impl_.mtu_));
}

std::string ImageStreamServerRequest::GetTypeName() const {
  return "hillab.v4.ImageStreamServerRequest";
}

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

class ImageStreamServerResponse::_Internal {
 public:
};

ImageStreamServerResponse::ImageStreamServerResponse(::google::protobuf::Arena* arena)
    : ::google::protobuf::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:hillab.v4.ImageStreamServerResponse)
}
inline PROTOBUF_NDEBUG_INLINE ImageStreamServerResponse::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena,
    const Impl_& from)
      : ip_(arena, from.ip_),
        sdp_(arena, from.sdp_),
        _cached_size_{0} {}

ImageStreamServerResponse::ImageStreamServerResponse(
    ::google::protobuf::Arena* arena,
    const ImageStreamServerResponse& from)
    : ::google::protobuf::MessageLite(arena) {
  ImageStreamServerResponse* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<std::string>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_);
  ::memcpy(reinterpret_cast<char *>(&_impl_) +
               offsetof(Impl_, port_),
           reinterpret_cast<const char *>(&from._impl_) +
               offsetof(Impl_, port_),
           offsetof(Impl_, auto_running_) -
               offsetof(Impl_, port_) +
               sizeof(Impl_::auto_running_));

  // @@protoc_insertion_point(copy_constructor:hillab.v4.ImageStreamServerResponse)
}
inline PROTOBUF_NDEBUG_INLINE ImageStreamServerResponse::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility,
    ::google::protobuf::Arena* arena)
      : ip_(arena),
        sdp_(arena),
        _cached_size_{0} {}

inline void ImageStreamServerResponse::SharedCtor(::_pb::Arena* arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  ::memset(reinterpret_cast<char *>(&_impl_) +
               offsetof(Impl_, port_),
           0,
           offsetof(Impl_, auto_running_) -
               offsetof(Impl_, port_) +
               sizeof(Impl_::auto_running_));
}
ImageStreamServerResponse::~ImageStreamServerResponse() {
  // @@protoc_insertion_point(destructor:hillab.v4.ImageStreamServerResponse)
  _internal_metadata_.Delete<std::string>();
  SharedDtor();
}
inline void ImageStreamServerResponse::SharedDtor() {
  ABSL_DCHECK(GetArena() == nullptr);
  _impl_.ip_.Destroy();
  _impl_.sdp_.Destroy();
  _impl_.~Impl_();
}

PROTOBUF_NOINLINE void ImageStreamServerResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:hillab.v4.ImageStreamServerResponse)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.ip_.ClearToEmpty();
  _impl_.sdp_.ClearToEmpty();
  ::memset(&_impl_.port_, 0, static_cast<::size_t>(
      reinterpret_cast<char*>(&_impl_.auto_running_) -
      reinterpret_cast<char*>(&_impl_.port_)) + sizeof(_impl_.auto_running_));
  _internal_metadata_.Clear<std::string>();
}

const char* ImageStreamServerResponse::_InternalParse(
    const char* ptr, ::_pbi::ParseContext* ctx) {
  ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header);
  return ptr;
}


PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::_pbi::TcParseTable<3, 7, 0, 49, 2> ImageStreamServerResponse::_table_ = {
  {
    0,  // no _has_bits_
    0, // no _extensions_
    7, 56,  // max_field_number, fast_idx_mask
    offsetof(decltype(_table_), field_lookup_table),
    4294967168,  // skipmap
    offsetof(decltype(_table_), field_entries),
    7,  // num_field_entries
    0,  // num_aux_entries
    offsetof(decltype(_table_), field_names),  // no aux_entries
    &_ImageStreamServerResponse_default_instance_._instance,
    ::_pbi::TcParser::GenericFallbackLite,  // fallback
  }, {{
    {::_pbi::TcParser::MiniParse, {}},
    // string ip = 1;
    {::_pbi::TcParser::FastUS1,
     {10, 63, 0, PROTOBUF_FIELD_OFFSET(ImageStreamServerResponse, _impl_.ip_)}},
    // int32 port = 2;
    {::_pbi::TcParser::FastV32S1,
     {16, 63, 0, PROTOBUF_FIELD_OFFSET(ImageStreamServerResponse, _impl_.port_)}},
    // int32 mtu = 3;
    {::_pbi::TcParser::FastV32S1,
     {24, 63, 0, PROTOBUF_FIELD_OFFSET(ImageStreamServerResponse, _impl_.mtu_)}},
    // int32 downscale = 4;
    {::_pbi::TcParser::FastV32S1,
     {32, 63, 0, PROTOBUF_FIELD_OFFSET(ImageStreamServerResponse, _impl_.downscale_)}},
    // bool running = 5;
    {::_pbi::TcParser::FastV8S1,
     {40, 63, 0, PROTOBUF_FIELD_OFFSET(ImageStreamServerResponse, _impl_.running_)}},
    // bool auto_running = 6;
    {::_pbi::TcParser::FastV8S1,
     {48, 63, 0, PROTOBUF_FIELD_OFFSET(ImageStreamServerResponse, _impl_.auto_running_)}},
    // string sdp = 7;
    {::_pbi::TcParser::FastUS1,
     {58, 63, 0, PROTOBUF_FIELD_OFFSET(ImageStreamServerResponse, _impl_.sdp_)}},
  }}, {{
    65535, 65535
  }}, {{
    // string ip = 1;
    {PROTOBUF_FIELD_OFFSET(ImageStreamServerResponse, _impl_.ip_), 0, 0,
    (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)},
    // int32 port = 2;
    {PROTOBUF_FIELD_OFFSET(ImageStreamServerResponse, _impl_.port_), 0, 0,
    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
    // int32 mtu = 3;
    {PROTOBUF_FIELD_OFFSET(ImageStreamServerResponse, _impl_.mtu_), 0, 0,
    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
    // int32 downscale = 4;
    {PROTOBUF_FIELD_OFFSET(ImageStreamServerResponse, _impl_.downscale_), 0, 0,
    (0 | ::_fl::kFcSingular | ::_fl::kInt32)},
    // bool running = 5;
    {PROTOBUF_FIELD_OFFSET(ImageStreamServerResponse, _impl_.running_), 0, 0,
    (0 | ::_fl::kFcSingular | ::_fl::kBool)},
    // bool auto_running = 6;
    {PROTOBUF_FIELD_OFFSET(ImageStreamServerResponse, _impl_.auto_running_), 0, 0,
    (0 | ::_fl::kFcSingular | ::_fl::kBool)},
    // string sdp = 7;
    {PROTOBUF_FIELD_OFFSET(ImageStreamServerResponse, _impl_.sdp_), 0, 0,
    (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)},
  }},
  // no aux_entries
  {{
    "\43\2\0\0\0\0\0\3"
    "hillab.v4.ImageStreamServerResponse"
    "ip"
    "sdp"
  }},
};

::uint8_t* ImageStreamServerResponse::_InternalSerialize(
    ::uint8_t* target,
    ::google::protobuf::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:hillab.v4.ImageStreamServerResponse)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  // string ip = 1;
  if (!this->_internal_ip().empty()) {
    const std::string& _s = this->_internal_ip();
    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "hillab.v4.ImageStreamServerResponse.ip");
    target = stream->WriteStringMaybeAliased(1, _s, target);
  }

  // int32 port = 2;
  if (this->_internal_port() != 0) {
    target = ::google::protobuf::internal::WireFormatLite::
        WriteInt32ToArrayWithField<2>(
            stream, this->_internal_port(), target);
  }

  // int32 mtu = 3;
  if (this->_internal_mtu() != 0) {
    target = ::google::protobuf::internal::WireFormatLite::
        WriteInt32ToArrayWithField<3>(
            stream, this->_internal_mtu(), target);
  }

  // int32 downscale = 4;
  if (this->_internal_downscale() != 0) {
    target = ::google::protobuf::internal::WireFormatLite::
        WriteInt32ToArrayWithField<4>(
            stream, this->_internal_downscale(), target);
  }

  // bool running = 5;
  if (this->_internal_running() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(
        5, this->_internal_running(), target);
  }

  // bool auto_running = 6;
  if (this->_internal_auto_running() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteBoolToArray(
        6, this->_internal_auto_running(), target);
  }

  // string sdp = 7;
  if (!this->_internal_sdp().empty()) {
    const std::string& _s = this->_internal_sdp();
    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "hillab.v4.ImageStreamServerResponse.sdp");
    target = stream->WriteStringMaybeAliased(7, _s, target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(
        _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:hillab.v4.ImageStreamServerResponse)
  return target;
}

::size_t ImageStreamServerResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:hillab.v4.ImageStreamServerResponse)
  ::size_t total_size = 0;

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

  // string ip = 1;
  if (!this->_internal_ip().empty()) {
    total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize(
                                    this->_internal_ip());
  }

  // string sdp = 7;
  if (!this->_internal_sdp().empty()) {
    total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize(
                                    this->_internal_sdp());
  }

  // int32 port = 2;
  if (this->_internal_port() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
        this->_internal_port());
  }

  // int32 mtu = 3;
  if (this->_internal_mtu() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
        this->_internal_mtu());
  }

  // int32 downscale = 4;
  if (this->_internal_downscale() != 0) {
    total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
        this->_internal_downscale());
  }

  // bool running = 5;
  if (this->_internal_running() != 0) {
    total_size += 2;
  }

  // bool auto_running = 6;
  if (this->_internal_auto_running() != 0) {
    total_size += 2;
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString).size();
  }
  _impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size));
  return total_size;
}

void ImageStreamServerResponse::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const ImageStreamServerResponse*>(
      &from));
}

void ImageStreamServerResponse::MergeFrom(const ImageStreamServerResponse& from) {
  ImageStreamServerResponse* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:hillab.v4.ImageStreamServerResponse)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_ip().empty()) {
    _this->_internal_set_ip(from._internal_ip());
  }
  if (!from._internal_sdp().empty()) {
    _this->_internal_set_sdp(from._internal_sdp());
  }
  if (from._internal_port() != 0) {
    _this->_internal_set_port(from._internal_port());
  }
  if (from._internal_mtu() != 0) {
    _this->_internal_set_mtu(from._internal_mtu());
  }
  if (from._internal_downscale() != 0) {
    _this->_internal_set_downscale(from._internal_downscale());
  }
  if (from._internal_running() != 0) {
    _this->_internal_set_running(from._internal_running());
  }
  if (from._internal_auto_running() != 0) {
    _this->_internal_set_auto_running(from._internal_auto_running());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

PROTOBUF_NOINLINE bool ImageStreamServerResponse::IsInitialized() const {
  return true;
}

::_pbi::CachedSize* ImageStreamServerResponse::AccessCachedSize() const {
  return &_impl_._cached_size_;
}
void ImageStreamServerResponse::InternalSwap(ImageStreamServerResponse* PROTOBUF_RESTRICT other) {
  using std::swap;
  auto* arena = GetArena();
  ABSL_DCHECK_EQ(arena, other->GetArena());
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.ip_, &other->_impl_.ip_, arena);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.sdp_, &other->_impl_.sdp_, arena);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(ImageStreamServerResponse, _impl_.auto_running_)
      + sizeof(ImageStreamServerResponse::_impl_.auto_running_)
      - PROTOBUF_FIELD_OFFSET(ImageStreamServerResponse, _impl_.port_)>(
          reinterpret_cast<char*>(&_impl_.port_),
          reinterpret_cast<char*>(&other->_impl_.port_));
}

std::string ImageStreamServerResponse::GetTypeName() const {
  return "hillab.v4.ImageStreamServerResponse";
}

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

class SystemLogStream::_Internal {
 public:
  using HasBits = decltype(std::declval<SystemLogStream>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
    8 * PROTOBUF_FIELD_OFFSET(SystemLogStream, _impl_._has_bits_);
  static const ::google::protobuf::Timestamp& time(const SystemLogStream* msg);
  static void set_has_time(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

const ::google::protobuf::Timestamp& SystemLogStream::_Internal::time(const SystemLogStream* msg) {
  return *msg->_impl_.time_;
}
void SystemLogStream::clear_time() {
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  if (_impl_.time_ != nullptr) _impl_.time_->Clear();
  _impl_._has_bits_[0] &= ~0x00000001u;
}
SystemLogStream::SystemLogStream(::google::protobuf::Arena* arena)
    : ::google::protobuf::MessageLite(arena) {
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:hillab.v4.SystemLogStream)
}
inline PROTOBUF_NDEBUG_INLINE SystemLogStream::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena,
    const Impl_& from)
      : _has_bits_{from._has_bits_},
        _cached_size_{0},
        message_(arena, from.message_) {}

SystemLogStream::SystemLogStream(
    ::google::protobuf::Arena* arena,
    const SystemLogStream& from)
    : ::google::protobuf::MessageLite(arena) {
  SystemLogStream* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<std::string>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_);
  ::uint32_t cached_has_bits = _impl_._has_bits_[0];
  _impl_.time_ = (cached_has_bits & 0x00000001u)
                ? CreateMaybeMessage<::google::protobuf::Timestamp>(arena, *from._impl_.time_)
                : nullptr;
  _impl_.type_ = from._impl_.type_;

  // @@protoc_insertion_point(copy_constructor:hillab.v4.SystemLogStream)
}
inline PROTOBUF_NDEBUG_INLINE SystemLogStream::Impl_::Impl_(
    ::google::protobuf::internal::InternalVisibility visibility,
    ::google::protobuf::Arena* arena)
      : _cached_size_{0},
        message_(arena) {}

inline void SystemLogStream::SharedCtor(::_pb::Arena* arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  ::memset(reinterpret_cast<char *>(&_impl_) +
               offsetof(Impl_, time_),
           0,
           offsetof(Impl_, type_) -
               offsetof(Impl_, time_) +
               sizeof(Impl_::type_));
}
SystemLogStream::~SystemLogStream() {
  // @@protoc_insertion_point(destructor:hillab.v4.SystemLogStream)
  _internal_metadata_.Delete<std::string>();
  SharedDtor();
}
inline void SystemLogStream::SharedDtor() {
  ABSL_DCHECK(GetArena() == nullptr);
  _impl_.message_.Destroy();
  delete _impl_.time_;
  _impl_.~Impl_();
}

PROTOBUF_NOINLINE void SystemLogStream::Clear() {
// @@protoc_insertion_point(message_clear_start:hillab.v4.SystemLogStream)
  PROTOBUF_TSAN_WRITE(&_impl_._tsan_detect_race);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  _impl_.message_.ClearToEmpty();
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    ABSL_DCHECK(_impl_.time_ != nullptr);
    _impl_.time_->Clear();
  }
  _impl_.type_ = 0;
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<std::string>();
}

const char* SystemLogStream::_InternalParse(
    const char* ptr, ::_pbi::ParseContext* ctx) {
  ptr = ::_pbi::TcParser::ParseLoop(this, ptr, ctx, &_table_.header);
  return ptr;
}


PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::_pbi::TcParseTable<2, 3, 1, 41, 2> SystemLogStream::_table_ = {
  {
    PROTOBUF_FIELD_OFFSET(SystemLogStream, _impl_._has_bits_),
    0, // no _extensions_
    3, 24,  // max_field_number, fast_idx_mask
    offsetof(decltype(_table_), field_lookup_table),
    4294967288,  // skipmap
    offsetof(decltype(_table_), field_entries),
    3,  // num_field_entries
    1,  // num_aux_entries
    offsetof(decltype(_table_), aux_entries),
    &_SystemLogStream_default_instance_._instance,
    ::_pbi::TcParser::GenericFallbackLite,  // fallback
  }, {{
    {::_pbi::TcParser::MiniParse, {}},
    // .google.protobuf.Timestamp time = 1;
    {::_pbi::TcParser::FastMtS1,
     {10, 0, 0, PROTOBUF_FIELD_OFFSET(SystemLogStream, _impl_.time_)}},
    // .hillab.v4.SystemLogType type = 2;
    {::_pbi::TcParser::FastV32S1,
     {16, 63, 0, PROTOBUF_FIELD_OFFSET(SystemLogStream, _impl_.type_)}},
    // string message = 3;
    {::_pbi::TcParser::FastUS1,
     {26, 63, 0, PROTOBUF_FIELD_OFFSET(SystemLogStream, _impl_.message_)}},
  }}, {{
    65535, 65535
  }}, {{
    // .google.protobuf.Timestamp time = 1;
    {PROTOBUF_FIELD_OFFSET(SystemLogStream, _impl_.time_), _Internal::kHasBitsOffset + 0, 0,
    (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
    // .hillab.v4.SystemLogType type = 2;
    {PROTOBUF_FIELD_OFFSET(SystemLogStream, _impl_.type_), -1, 0,
    (0 | ::_fl::kFcSingular | ::_fl::kOpenEnum)},
    // string message = 3;
    {PROTOBUF_FIELD_OFFSET(SystemLogStream, _impl_.message_), -1, 0,
    (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)},
  }}, {{
    {::_pbi::TcParser::GetTable<::google::protobuf::Timestamp>()},
  }}, {{
    "\31\0\0\7\0\0\0\0"
    "hillab.v4.SystemLogStream"
    "message"
  }},
};

::uint8_t* SystemLogStream::_InternalSerialize(
    ::uint8_t* target,
    ::google::protobuf::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:hillab.v4.SystemLogStream)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;

  cached_has_bits = _impl_._has_bits_[0];
  // .google.protobuf.Timestamp time = 1;
  if (cached_has_bits & 0x00000001u) {
    target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
        1, _Internal::time(this),
        _Internal::time(this).GetCachedSize(), target, stream);
  }

  // .hillab.v4.SystemLogType type = 2;
  if (this->_internal_type() != 0) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        2, this->_internal_type(), target);
  }

  // string message = 3;
  if (!this->_internal_message().empty()) {
    const std::string& _s = this->_internal_message();
    ::google::protobuf::internal::WireFormatLite::VerifyUtf8String(
        _s.data(), static_cast<int>(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "hillab.v4.SystemLogStream.message");
    target = stream->WriteStringMaybeAliased(3, _s, target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = stream->WriteRaw(
        _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString).data(),
        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString).size()), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:hillab.v4.SystemLogStream)
  return target;
}

::size_t SystemLogStream::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:hillab.v4.SystemLogStream)
  ::size_t total_size = 0;

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

  // string message = 3;
  if (!this->_internal_message().empty()) {
    total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize(
                                    this->_internal_message());
  }

  // .google.protobuf.Timestamp time = 1;
  cached_has_bits = _impl_._has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size +=
        1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*_impl_.time_);
  }

  // .hillab.v4.SystemLogType type = 2;
  if (this->_internal_type() != 0) {
    total_size += 1 +
                  ::_pbi::WireFormatLite::EnumSize(this->_internal_type());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    total_size += _internal_metadata_.unknown_fields<std::string>(::google::protobuf::internal::GetEmptyString).size();
  }
  _impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size));
  return total_size;
}

void SystemLogStream::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::_pbi::DownCast<const SystemLogStream*>(
      &from));
}

void SystemLogStream::MergeFrom(const SystemLogStream& from) {
  SystemLogStream* const _this = this;
  // @@protoc_insertion_point(class_specific_merge_from_start:hillab.v4.SystemLogStream)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void) cached_has_bits;

  if (!from._internal_message().empty()) {
    _this->_internal_set_message(from._internal_message());
  }
  if ((from._impl_._has_bits_[0] & 0x00000001u) != 0) {
    _this->_internal_mutable_time()->::google::protobuf::Timestamp::MergeFrom(
        from._internal_time());
  }
  if (from._internal_type() != 0) {
    _this->_internal_set_type(from._internal_type());
  }
  _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
}

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

PROTOBUF_NOINLINE bool SystemLogStream::IsInitialized() const {
  return true;
}

::_pbi::CachedSize* SystemLogStream::AccessCachedSize() const {
  return &_impl_._cached_size_;
}
void SystemLogStream::InternalSwap(SystemLogStream* PROTOBUF_RESTRICT other) {
  using std::swap;
  auto* arena = GetArena();
  ABSL_DCHECK_EQ(arena, other->GetArena());
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.message_, &other->_impl_.message_, arena);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(SystemLogStream, _impl_.type_)
      + sizeof(SystemLogStream::_impl_.type_)
      - PROTOBUF_FIELD_OFFSET(SystemLogStream, _impl_.time_)>(
          reinterpret_cast<char*>(&_impl_.time_),
          reinterpret_cast<char*>(&other->_impl_.time_));
}

std::string SystemLogStream::GetTypeName() const {
  return "hillab.v4.SystemLogStream";
}

// @@protoc_insertion_point(namespace_scope)
}  // namespace v4
}  // namespace hillab
namespace google {
namespace protobuf {
}  // namespace protobuf
}  // namespace google
// @@protoc_insertion_point(global_scope)
#include "google/protobuf/port_undef.inc"
